User-Mode Networking Rewrite/Improvement Branch.

Goals: 
        - NSP, LSP Support for DNS/Winsock Queries.
        - Fix formatting of my MSAFD code
        - Fix header file issues
        - Fix bugs in my msafd implementation
        - Implement ws2help and wshtcpip for msafd to use.

svn path=/branches/umode_net_branch/; revision=14243

CREDITS

@@ -0,0 +1,78 @@
+ReactOS is available thanks to the work of
+
+Emanuele Aliberti <ea@iol.it>
+Robert Bergkvist <fragdance@hotmail.com>
+Hartmut Birr <hartmut.birr@gmx.de>
+Aleksey Bragin <aleksey@studiocerebral.com>
+Richard Campbell <eek2121@comcast.net>
+Gunnar Andre' Dalsnes <hardon@online.no>
+Arindam Das
+Boudewijn Dekker <ariadne@xs4all.nl>
+Robert Dickenson <robd@reactos.org>
+Marty Dill <mdill@uvic.ca>
+Jason Eager
+Steven Edwards <steven_ed4153@yahoo.com>
+Iwan Fatahi <i_fatahi@hotmail.com>
+Jason Filby <jasonfilby@yahoo.com>
+Martin Fuchs <martin-fuchs@gmx.net>
+Jurgen van Gael <jurgen.vangael@student.kuleuven.ac.be>
+Ge van Geldorp <ge@gse.nl>
+Andrew Greenwood <lists@silverblade.co.uk>
+Casper S. Hornstrup <chorns@users.sourceforge.net>
+KJK::Hyperion <noog@libero.it>
+Eugene Ingerman <geneing@myrealbox.com>
+Rex Jolliff <rex@lvcablemodem.com>
+Guido de Jong
+Victor Kirhenshtein <sauros@iname.com>
+Eric Kohl <ekohl@rz-online.de>
+Hans Kremer
+Frederik Leemans
+Jean Michault
+Royce Mitchell III <royce3@ev1.net>
+Filip Navara <xnavara@volny.cz>
+Jim Noeth
+Mike Nordell ("tamlin")
+Hernan Ochoa
+Brian Palmer <brianp@sginet.com>
+Paolo Pantaleo <paolopan@freemail.it>
+Matt Pyne
+Phillip Susi <phreak@iag.net>
+James B. Tabor <jimtabor@adsl-64-217-116-74.dsl.hstntx.swbell.net>
+Mark Tempel <mtempel@visi.com>
+Vizzini <vizzini@plasmic.com>
+Mark Weaver <mark@npsl.co.uk>
+Thomas Weidenmueller <w3seek@users.sourceforge.net>
+Jason Weiler
+David Welch <welch@cwcom.net>
+Jonathan Wilson <jonwil@tpgi.com.au>
+Art Yerkes <ayerkes@speakeasy.net>
+
+Graphic Design from
+
+Everaldo (http://everaldo.com) for Explorer icons
+
+Source and inspiration from
+
+WINE (http://www.winehq.com)
+WinFree (http://www.stack.nl/~onno/win32/)
+Linux (http://www.kernel.org)
+XFree86 (http://www.xfree86.org/)
+
+References (Rex's at least)
+
+Baker, Art. The Windows NT Device Driver Book. Prentice Hall, 1997.
+Borate, Dabak & Phadke. Undocumented Windows NT. M&T Books, 1999.
+Brain, Marshall. Win32 System Services. Prentice Hall, 1996.
+Cant, Chris. Writing Windows WDM Device Drivers. R&D Books, 1999.
+Canton & Sanchez. IBM Microcomputers: A Programmer's Handbook. McGraw Hill, 1990.
+Davis & Wallace. Windows Undocumented File Formats. R&D Books, 1997.
+Mason & Viscarola. Windows NT Device Driver Development. Macmillan, 1999.
+Mitchell, Stan. Inside the Windows 95 File System. O'Reilly, 1997.
+Murray, James D. Windows NT Event Logging. O'Reilly, 1998.
+Nagar, Rajeev. Windows NT File System Internals. O'Reilly, 1997.
+Osbourne, Sandra. Windows NT Registry: A Settings Reference. New Riders, 1998.
+Pietrek, Matt. Windows 95 System Programming Secrets. IDG, 1995.
+Richter, Jeffery. Advanced Windows, 3rd ed. Microsoft, 1997.
+Simon, Richard J. Windows NT Win32 API Superbible. Waite Group, 1996.
+Solomon, David A. Inside Windows NT, 2nd Ed. Microsoft, 1998.
+"The NT Insider." Open Systems Resources, 1999-2000.

Doxyfile

@@ -0,0 +1,211 @@
+# Doxyfile 1.3.5
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = ReactOS
+PROJECT_NUMBER         = 
+OUTPUT_DIRECTORY       = doxy-doc
+OUTPUT_LANGUAGE        = English
+USE_WINDOWS_ENCODING   = YES
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        = .
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = YES
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP         = NO
+INHERIT_DOCS           = NO
+DISTRIBUTE_GROUP_DOC   = NO
+TAB_SIZE               = 8
+ALIASES                = 
+OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_JAVA   = NO
+SUBGROUPING            = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = YES
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = YES
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+SHOW_INCLUDE_FILES     = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = NO
+WARN_IF_UNDOCUMENTED   = NO
+WARN_IF_DOC_ERROR      = YES
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = hal \
+                         subsys \
+                         services \
+                         regtests \
+						 iface
+FILE_PATTERNS          = *.c \
+                         *.h
+RECURSIVE              = YES
+EXCLUDE                = subsys/win32k \
+                         subsys/system/explorer
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = YES
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = YES
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+VERBATIM_HEADERS       = NO
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = 
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+CHM_FILE               = 
+HHC_LOCATION           = 
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = YES
+TREEVIEW_WIDTH         = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = YES
+RTF_HYPERLINKS         = YES
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX = 
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = NO
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = include
+INCLUDE_FILE_PATTERNS  = *.h
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+HIDE_UNDOC_RELATIONS   = NO
+HAVE_DOT               = YES
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+UML_LOOK               = NO
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = YES
+GRAPHICAL_HIERARCHY    = YES
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+MAX_DOT_GRAPH_DEPTH    = 0
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = YES

INSTALL

@@ -0,0 +1,73 @@
+1. Build environment
+
+To build the system you need either mingw32 installed on Windows or a mingw32
+cross compiler running on unix. You may obtain MinGW binaries that build
+ReactOS from http://www.reactos.com. 
+
+
+2. Building ReactOS
+
+To build from Windows run 'make' (wihout the quotes) from the top directory.
+To build from unix, edit rules.mak and change the PREFIX variable to the
+correct value for your cross-compiler. Run 'export HOST=mingw32-linux' to
+tell the ReactOS build system that it is building ReactOS on a linux machine.
+Now run 'make'.
+
+
+3. Installation
+
+The system can only be installed on the first partition on the first harddisk.
+The partition must be formatted as FAT16 or FAT32. The system can only be
+started from DOS and not from a Windows DOS-prompt.
+
+ReactOS can be installed from the source distribution or from the binary
+distribution. The two ways to install ReactOS are explained below.
+
+
+3.1 Installation from sources
+
+To install ReactOS after building it, type 'make install'. This will create
+the directory 'reactos' in the top directory. Copy this directory to the root
+of your first partition on your first harddisk. This is usually c:\ on a
+Windows machine.
+
+If you don't want to copy the files manually every time you run a 'make install',
+you can specify the directory where the files are to be copied to during
+installation.
+
+In rules.mak find the variable INSTALL_DIR and change the assigned value to the
+name of the directory where the files are to be copied to. If you are using
+Windows this could be:
+
+    INSTALL_DIR = c:\reactos
+
+If you are on linux this could be:
+
+    INSTALL_DIR = /mnt/windows/reactos
+
+Save the changes to rules.mak and run 'make install' to install the files to
+the new location. If you don't want to change rules.mak, you can specify the
+installtion directory when invoking make. Run
+'make INSTALL_DIR=c:\reactos install' to install to c:\reactos.
+
+
+3.2 Installation from binany distribution
+
+To install ReactOS from the binary distribution, extract the archive contents
+to c:\reactos. Remember to extract the files with full paths.
+
+
+4. Booting ReactOS
+
+Startup in DOS mode. 'cd' to c:\reactos and type 'boot' and press <enter>.
+A simple shell is started where you can use simple commands like 'cd' and 'dir'.
+
+
+5. Help
+
+If you run into problems or have suggestions for making ReactOS better, please
+surf to the address below and subscribe to one or more of the mailing lists.
+
+http://www.reactos.com/index.php?tab=discussion&section=lists
+
+ReactOS Development Team

Jamfile

@@ -0,0 +1,5 @@
+# Main jamfile for ReactOS
+
+SubDir ROS_TOP ;
+
+SubInclude ROS_TOP Lib ;

Jamrules

@@ -0,0 +1,54 @@
+# customization for ReactOS goes here
+
+# The SharedLibrary and SharedLibraryFromObjects rules were
+# borrowed from here:
+# http://www.differentpla.net/~roger/devel/jam/tutorial/shared_lib/index.html
+
+SUFSHR = .dll ;
+RM = rm ; # rm comes with MinGW, and the default del doesn't work in some cases
+
+rule SharedLibrary
+{
+	SharedLibraryFromObjects $(<) : $(>:S=$(SUFOBJ)) ;
+	Objects $(>) ;
+}
+
+rule SharedLibraryFromObjects
+{
+	local _s _t ;
+
+	# Add grist to file names
+	# Add suffix to dll
+
+	_s = [ FGristFiles $(>) ] ;
+	_t = [ FAppendSuffix $(<) : $(SUFSHR) ] ;
+
+	if $(_t) != $(<)
+	{
+	    DEPENDS $(<) : $(_t) ;
+	    NOTFILE $(<) ;
+	}
+
+	# make compiled sources a dependency of target
+
+	DEPENDS exe : $(_t) ;
+	DEPENDS $(_t) : $(_s) ;
+	MakeLocate $(_t) : $(LOCATE_TARGET) ;
+
+	Clean clean : $(_t) ;
+
+	Link $(_t) : $(_s) ;
+}
+
+# nasm needs to know the output file first, or it doesn't
+# recognize -I  :(
+actions As
+{
+	$(AS) -o $(<) $(ASFLAGS) -I$(HDRS) $(>)
+}
+
+AS = nasm ;
+
+# why isn't DEFINES working? :(
+#DEFINES += _M_IX86 ;
+CCFLAGS += -D_M_IX86 ;

LGPL.txt

@@ -2,7 +2,7 @@
 		       Version 2.1, February 1999
 
  Copyright (C) 1991, 1999 Free Software Foundation, Inc.
-     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -485,7 +485,7 @@ convey the exclusion of warranty; and each file should have at least the
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 Also add information on how to contact you by electronic and paper mail.
 

README

@@ -0,0 +1,28 @@
+========================
+ReactOS Version 0.2.x
+Updated June 23rd, 2004
+========================
+
+1. What is ReactOS?
+
+   ReactOS is an Open Source effort to develop a quality operating system
+that is compatible with Windows NT applications and drivers.
+
+   The ReactOS project, although currently focused on Windows NT 4.0
+compatibility, is always keeping an eye towards compatibility with
+future Windows NT releases, that is, Windows 2000 (NT 5.0) and
+Windows XP (NT 5.1).
+
+More information is available at http://www.reactos.com.
+
+2. Building ReactOS
+
+See the INSTALL file for more details.
+
+3. More information
+
+See the doc subdirectory for some sparse notes
+
+4. Who is responsible
+
+See the CREDITS file

apistatus.lst

@@ -0,0 +1,33 @@
+; Format:
+;   COMPONENT_NAME PATH_TO_COMPONENT_SOURCES
+; COMPONENT_NAME            - Name of the component. Eg. kernel32.dll.
+; PATH_TO_COMPONENT_SOURCES - Relative path to sources (relative to
+;                             where rgenstat is run from).
+advapi32.dll reactos/lib/advapi32
+crtdll.dll reactos/lib/crtdll
+gdi32.dll reactos/lib/gdi32
+gdiplus.dll reactos/lib/gdiplus
+iphlpapi.dll reactos/lib/iphlpapi
+kernel32.dll reactos/lib/kernel32
+lz32.dll reactos/lib/lzexpand
+msvcrt.dll reactos/lib/msvcrt
+ole32.dll reactos/lib/ole32
+oleaut32.dll reactos/lib/oleaut32
+rpcrt4.dll reactos/lib/rpcrt4
+secur32.dll reactos/lib/secur32
+shell32.dll reactos/lib/shell32
+snmpapi.dll reactos/lib/snmpapi
+user32.dll reactos/lib/user32
+version.dll reactos/lib/version
+winmm.dll reactos/lib/winmm
+winspool.dll reactos/lib/winspool
+ws2_32.dll reactos/lib/ws2_32
+wsock32.dll reactos/lib/wsock32
+videoprt.dll reactos/drivers/video/videoprt
+ndis.sys reactos/drivers/net/ndis
+tdi.sys reactos/drivers/net/tdi
+class2.sys reactos/drivers/storage/class2
+scsiport.sys reactos/drivers/storage/scsiport
+ntoskrnl.exe reactos/ntoskrnl
+ntoskrnl.exe reactos/lib/rtl
+win32k.sys reactos/subsys/win32k

apps/Doxyfile

@@ -0,0 +1,207 @@
+# Doxyfile 1.3.5
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = "ReactOS Apps & Tools"
+PROJECT_NUMBER         = 
+OUTPUT_DIRECTORY       = doxy-doc
+OUTPUT_LANGUAGE        = English
+USE_WINDOWS_ENCODING   = YES
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        = ..
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = YES
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP         = NO
+INHERIT_DOCS           = NO
+DISTRIBUTE_GROUP_DOC   = NO
+TAB_SIZE               = 8
+ALIASES                = 
+OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_JAVA   = NO
+SUBGROUPING            = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = NO
+EXTRACT_STATIC         = NO
+EXTRACT_LOCAL_CLASSES  = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = YES
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+SHOW_INCLUDE_FILES     = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = NO
+WARN_IF_UNDOCUMENTED   = NO
+WARN_IF_DOC_ERROR      = YES
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = . \
+                         ../tools
+FILE_PATTERNS          = *.c \
+                         *.h
+RECURSIVE              = YES
+EXCLUDE                = 
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = 
+EXAMPLE_RECURSIVE      = YES
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = YES
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+VERBATIM_HEADERS       = NO
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = 
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+CHM_FILE               = 
+HHC_LOCATION           = 
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = YES
+TREEVIEW_WIDTH         = 200
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = YES
+RTF_HYPERLINKS         = YES
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX = 
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = NO
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = ../include
+INCLUDE_FILE_PATTERNS  = *.h
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+HIDE_UNDOC_RELATIONS   = NO
+HAVE_DOT               = YES
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+UML_LOOK               = NO
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = YES
+GRAPHICAL_HIERARCHY    = YES
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+MAX_DOT_GRAPH_DEPTH    = 0
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = YES

apps/Makefile

@@ -0,0 +1,13 @@
+# $Id$
+#
+# ReactOS apps and tools makefile to generate Doxygen documentation
+#
+
+
+docu:
+	doxygen Doxyfile
+
+.PHONY: docu
+
+
+# EOF

apps/testsets/Makefile

@@ -0,0 +1,162 @@
+#
+# ReactOS system testsets makefile
+#
+
+PATH_TO_TOP = ../..
+
+include $(PATH_TO_TOP)/rules.mak
+
+
+# Testset applications
+TEST_SETS = loadlib
+
+TEST_KERNEL32 = 
+
+TEST_MSVCRT = 
+
+TEST_COM = 
+
+TEST_SEH = 
+
+TEST_REGRESSIONS = 
+
+all: $(TEST_SETS)  $(TEST_KERNEL32) $(TEST_MSVCRT) $(TEST_COM) $(TEST_SEH) $(TEST_REGRESSIONS) 
+
+depends: 
+
+implib: $(TEST_SETS:%=%_implib) \
+	$(TEST_KERNEL32:%=%_implib) \
+	$(TEST_MSVCRT:%=%_implib) \
+	$(TEST_COM:%=%_implib) \
+	$(TEST_SEH:%=%_implib) \
+	$(TEST_REGRESSIONS:%=%_implib)
+
+clean: 	$(TEST_SETS:%=%_clean) \
+	$(TEST_KERNEL32:%=%_clean) \
+	$(TEST_MSVCRT:%=%_clean) \
+	$(TEST_COM:%=%_clean) \
+	$(TEST_SEH:%=%_clean) \
+	$(TEST_REGRESSIONS:%=%_clean)
+
+install: $(TEST_SETS:%=%_install) \
+	 $(TEST_KERNEL32:%=%_install) \
+	 $(TEST_MSVCRT:%=%_install) \
+	 $(TEST_COM:%=%_install) \
+	 $(TEST_SEH:%=%_install) \
+	 $(TEST_REGRESSIONS:%=%_install)
+
+.PHONY: all depends implib clean install
+
+
+#
+# Testset Applications
+#
+$(TEST_SETS): %:
+	$(MAKE) -C $*
+
+$(TEST_SETS:%=%_implib): %_implib:
+	$(MAKE) -C $* implib
+
+$(TEST_SETS:%=%_clean): %_clean:
+	$(MAKE) -C $* clean
+
+$(TEST_SETS:%=%_install): %_install:
+	$(MAKE) -C $* install
+
+.PHONY: $(TEST_SETS) $(TEST_SETS:%=%_implib) $(TEST_SETS:%=%_clean) $(TEST_SETS:%=%_install)
+
+
+#
+# Kernel32 Test Applications
+#
+$(TEST_KERNEL32): %:
+	$(MAKE) -C kernel32/$*
+
+$(TEST_KERNEL32:%=%_implib): %_implib:
+	$(MAKE) -C kernel32/$* implib
+
+$(TEST_KERNEL32:%=%_clean): %_clean:
+	$(MAKE) -C kernel32/$* clean
+
+$(TEST_KERNEL32:%=%_install): %_install:
+	$(MAKE) -C kernel32/$* install
+
+.PHONY: $(TEST_KERNEL32) $(TEST_KERNEL32:%=%_implib) $(TEST_KERNEL32:%=%_clean) $(TEST_KERNEL32:%=%_install)
+
+
+#
+# msvcrt Test Applications
+#
+$(TEST_MSVCRT): %:
+	$(MAKE) -C msvcrt/$*
+
+$(TEST_MSVCRT:%=%_implib): %_implib:
+	$(MAKE) -C msvcrt/$* implib
+
+$(TEST_MSVCRT:%=%_clean): %_clean:
+	$(MAKE) -C msvcrt/$* clean
+
+$(TEST_MSVCRT:%=%_install): %_install:
+	$(MAKE) -C msvcrt/$* install
+
+.PHONY: $(TEST_MSVCRT) $(TEST_MSVCRT:%=%_implib) $(TEST_MSVCRT:%=%_clean) $(TEST_MSVCRT:%=%_install)
+
+
+#
+# COM Test Applications
+#
+$(TEST_COM): %:
+	$(MAKE) -C com/$*
+
+$(TEST_COM:%=%_implib): %_implib:
+	$(MAKE) -C com/$* implib
+
+$(TEST_COM:%=%_clean): %_clean:
+	$(MAKE) -C com/$* clean
+
+$(TEST_COM:%=%_install): %_install:
+	$(MAKE) -C com/$* install
+
+.PHONY: $(TEST_COM) $(TEST_COM:%=%_implib) $(TEST_COM:%=%_clean) $(TEST_COM:%=%_install)
+
+
+#
+# SEH Test Applications
+#
+$(TEST_SEH): %:
+	$(MAKE) -C seh/$*
+
+$(TEST_SEH:%=%_implib): %_implib:
+	$(MAKE) -C seh/$* implib
+
+$(TEST_SEH:%=%_clean): %_clean:
+	$(MAKE) -C seh/$* clean
+
+$(TEST_SEH:%=%_install): %_install:
+	$(MAKE) -C seh/$* install
+
+.PHONY: $(TEST_SEH) $(TEST_SEH:%=%_implib) $(TEST_SEH:%=%_clean) $(TEST_SEH:%=%_install)
+
+
+#
+# Regression Test Applications
+#
+$(TEST_REGRESSIONS): %:
+	$(MAKE) -C regres/$*
+
+$(TEST_REGRESSIONS:%=%_implib): %_implib:
+	$(MAKE) -C regres/$* implib
+
+$(TEST_REGRESSIONS:%=%_clean): %_clean:
+	$(MAKE) -C regres/$* clean
+
+$(TEST_REGRESSIONS:%=%_install): %_install:
+	$(MAKE) -C regres/$* install
+
+.PHONY: $(TEST_REGRESSIONS) $(TEST_REGRESSIONS:%=%_implib) $(TEST_REGRESSIONS:%=%_clean) $(TEST_REGRESSIONS:%=%_install)
+
+
+etags:
+	find . -name "*.[ch]" -print | etags --language=c -
+
+# EOF

apps/testsets/loadlib/loadlib.c

@@ -1,5 +1,5 @@
 /*
- *  ReactOS test program -
+ *  ReactOS test program - 
  *
  *  loadlib.c
  *
@@ -91,7 +91,7 @@ const char* appName(const char* argv0)
     const char* name;
 
     name = (const char*)strrchr(argv0, '\\');
-    if (name != NULL)
+    if (name != NULL) 
         return name + 1;
     return argv0;
 }

apps/testsets/loadlib/loadlib.h

@@ -1,5 +1,5 @@
 /*
- *  ReactOS test program -
+ *  ReactOS test program - 
  *
  *  loadlib.h
  *

apps/testsets/loadlib/makefile

@@ -0,0 +1,24 @@
+#
+# $Id: makefile,v 1.0
+
+PATH_TO_TOP = ../../..
+
+TARGET_NORC = yes
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = loadlib
+
+TARGET_CFLAGS = -Wall -Werror -D_USE_W32API -DUNICODE -D_UNICODE
+
+TARGET_SDKLIBS = kernel32.a ntdll.a 
+
+TARGET_OBJECTS = $(TARGET_NAME).o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk
+
+# EOF

apps/testsets/msvcrt/fileio/_tfileio.c

@@ -1,5 +1,5 @@
 /*
- *  ReactOS test program -
+ *  ReactOS test program - 
  *
  *  _tfileio.c
  *
@@ -31,8 +31,8 @@
 #define _tfopen      _wfopen
 #define _tunlink     _wunlink
 #define _TEOF        WEOF
-#define _gettchar    getwchar
-#define _puttchar    putwchar
+#define _gettchar    getwchar 
+#define _puttchar    putwchar  
 #define _THEX_FORMAT _T("0x%04x ")
 #else /*UNICODE*/
 #define _tfopen      fopen

apps/testsets/msvcrt/fileio/fileio.c

@@ -1,5 +1,5 @@
 /*
- *  ReactOS test program -
+ *  ReactOS test program - 
  *
  *  _fileio.c
  *

apps/testsets/msvcrt/fileio/main.c

@@ -0,0 +1,124 @@
+/*
+ *  ReactOS test program - 
+ *
+ *  main.c
+ *
+ *  Copyright (C) 2002  Robert Dickenson <robd@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <tchar.h>
+#include <wchar.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "main.h"
+
+
+#define VERSION 1
+
+#ifdef UNICODE
+#define TARGET  "UNICODE"
+#else
+#define TARGET  "MBCS"
+#endif
+
+BOOL verbose_flagged = 0;
+BOOL status_flagged = 0;
+
+int usage(char* argv0)
+{
+    printf("USAGE: %s test_id [unicode]|[ansi] [clean]|[status][verbose]\n", argv0);
+    printf("\tWhere test_id is one of:\n");
+    printf("\t0 - (default) regression mode, run tests 1-4 displaying failures only\n");
+    printf("\t1 - Write DOS style eol data to file in text mode (text.dos)\n");
+    printf("\t2 - Write NIX style eol data to file in binary mode (binary.dos)\n");
+    printf("\t3 - Write DOS style eol data to file in text mode (text.nix)\n");
+    printf("\t4 - Write NIX style eol data to file in binary mode (binary.nix)\n");
+    printf("\t5 - Echo console line input\n");
+    printf("\t6 - Dump console line input in hex format\n");
+    printf("\t7 - The source code is your friend\n");
+    printf("\t[unicode] - perform tests using UNICODE versions of library functions\n");
+    printf("\t[ansi] - perform tests using ANSI versions of library functions\n");
+    printf("\t    If neither unicode or ansi is specified build default is used\n");
+    printf("\t[clean] - delete all temporary test output files\n");
+    printf("\t[status] - enable extra status display while running\n");
+    printf("\t[verbose] - enable verbose output when running\n");
+    return 0;
+}
+
+int __cdecl main(int argc, char* argv[])
+{
+    int test_num = 0;
+    int version = 0;
+    int result = 0;
+    int i = 0;
+
+    printf("%s test application - build %03d (default: %s)\n", argv[0], VERSION, TARGET);
+    if (argc < 2) {
+        return usage(argv[0]);
+    }
+    for (i = 1; i < argc; i++) {
+        if (strstr(argv[i], "ansi") || strstr(argv[i], "ANSI")) {
+            version = 1;
+        } else if (strstr(argv[i], "unicode") || strstr(argv[i], "UNICODE")) {
+            version = 2;
+        } else if (strstr(argv[i], "clean") || strstr(argv[i], "CLEAN")) {
+            test_num = -1;
+        } else if (strstr(argv[i], "verbose") || strstr(argv[i], "VERBOSE")) {
+            verbose_flagged = 1;
+        } else if (strstr(argv[i], "status") || strstr(argv[i], "STATUS")) {
+            status_flagged = 1;
+        } else {
+            test_num = atoi(argv[1]);
+            //if (test_num < 0
+        }
+    }
+    for (i = test_num; i <= test_num; i++) {
+        if (!test_num) {
+            test_num = 4;
+            i = 1;
+        }
+        switch (version) {
+        case 1:
+            result = run_ansi_tests(i);
+            break;
+        case 2:
+            result = run_unicode_tests(i);
+            break;
+        default:
+            result = run_ansi_tests(i);
+            result = run_unicode_tests(i);
+            break;
+        }
+    }
+    printf("finished\n");
+    return result;
+}
+
+#ifndef __GNUC__
+
+char* args[] = { "fileio.exe", "0", "unicode", "verbose"};
+
+int __cdecl mainCRTStartup(void)
+{
+    main(2, args);
+    return 0;
+}
+
+#endif /*__GNUC__*/

apps/testsets/msvcrt/fileio/main.h

@@ -0,0 +1,42 @@
+/*
+ *  ReactOS test program - 
+ *
+ *  main.h
+ *
+ *  Copyright (C) 2002  Robert Dickenson <robd@reactos.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __MAIN_H__
+#define __MAIN_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+int app_main(int argc, char* argv[]);
+DWORD GetInput(char* Buffer, int buflen);
+
+int test_ansi_files(int test_num);
+int test_unicode_files(int test_num);
+
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif // __MAIN_H__

apps/testsets/msvcrt/fileio/makefile

@@ -0,0 +1,27 @@
+#
+# $Id: makefile,v 1.0
+
+PATH_TO_TOP = ../../../..
+
+TEST_ROOT = $(PATH_TO_TOP)/apps/testsets/test
+
+TARGET_NORC = yes
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = fileio
+
+#TARGET_CFLAGS = -I$(TEST_ROOT) -DDBG -DUNICODE -D_UNICODE
+TARGET_CFLAGS = -I$(TEST_ROOT) -DDBG
+
+TARGET_SDKLIBS = ntdll.a kernel32.a
+
+TARGET_OBJECTS = $(TARGET_NAME).o wfileio.o main.o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk
+
+# EOF

apps/testsets/msvcrt/fileio/wfileio.c

@@ -1,5 +1,5 @@
 /*
- *  ReactOS test program -
+ *  ReactOS test program - 
  *
  *  wfileio.c
  *

apps/utils/Makefile

@@ -0,0 +1,71 @@
+#
+# ReactOS system utilities makefile
+#
+
+PATH_TO_TOP = ../..
+
+include $(PATH_TO_TOP)/rules.mak
+
+
+# Console system utilities
+# cabman cat net objdir partinfo pice ps sc stats
+UTIL_APPS = cat objdir partinfo pnpdump sc shutdown stats tickcount ps
+
+UTIL_NET_APPS = arp finger ftp ipconfig netstat ping route telnet whois
+
+
+all: $(UTIL_APPS) $(UTIL_NET_APPS)
+
+depends: 
+
+implib: $(UTIL_APPS:%=%_implib) \
+	$(UTIL_NET_APPS:%=%_implib)
+
+clean: 	$(UTIL_APPS:%=%_clean) \
+	$(UTIL_NET_APPS:%=%_clean)
+
+install: $(UTIL_APPS:%=%_install) \
+	 $(UTIL_NET_APPS:%=%_install)
+
+.PHONY: all depends implib clean install
+
+
+#
+# Utility Applications
+#
+$(UTIL_APPS): %:
+	$(MAKE) -C $*
+
+$(UTIL_APPS:%=%_implib): %_implib:
+	$(MAKE) -C $* implib
+
+$(UTIL_APPS:%=%_clean): %_clean:
+	$(MAKE) -C $* clean
+
+$(UTIL_APPS:%=%_install): %_install:
+	$(MAKE) -C $* install
+
+.PHONY: $(UTIL_APPS) $(UTIL_APPS:%=%_implib) $(UTIL_APPS:%=%_clean) $(UTIL_APPS:%=%_install)
+
+#
+# GUI Utility Applications
+#
+$(UTIL_NET_APPS): %:
+	$(MAKE) -C net/$*
+
+$(UTIL_NET_APPS:%=%_implib): %_implib:
+	$(MAKE) -C net/$* implib
+
+$(UTIL_NET_APPS:%=%_clean): %_clean:
+	$(MAKE) -C net/$* clean
+
+$(UTIL_NET_APPS:%=%_install): %_install:
+	$(MAKE) -C net/$* install
+
+.PHONY: $(UTIL_NET_APPS) $(UTIL_NET_APPS:%=%_implib) $(UTIL_NET_APPS:%=%_clean) $(UTIL_NET_APPS:%=%_install)
+
+
+etags:
+	find . -name "*.[ch]" -print | etags --language=c -
+
+# EOF

apps/utils/binpatch/Makefile

@@ -0,0 +1,21 @@
+PATH_TO_TOP = ../../..
+
+TARGET_NORC = yes
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = binpatch
+
+TARGET_SDKLIBS = 
+
+TARGET_OBJECTS = patch.o
+
+TARGET_CFLAGS += -Wall -Werror
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk
+
+# EOF

apps/utils/binpatch/patch.c

@@ -0,0 +1,615 @@
+#include <conio.h>
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+/** DEFINES *******************************************************************/
+
+#define PATCH_BUFFER_SIZE           4096    /* Maximum size of a patch */
+#define PATCH_BUFFER_MAGIC          "\xde\xad\xbe\xef MaGiC MaRk "
+#define SIZEOF_PATCH_BUFFER_MAGIC   (sizeof (PATCH_BUFFER_MAGIC) - 1)
+
+/** TYPES *********************************************************************/
+
+typedef struct _PatchedByte
+{
+   int            offset;    /*!< File offset of the patched byte. */
+   unsigned char  expected;  /*!< Expected (original) value of the byte. */
+   unsigned char  patched;   /*!< Patched (new) value for the byte. */
+} PatchedByte;
+
+typedef struct _PatchedFile
+{
+   const char  *name;        /*!< Name of the file to be patched. */
+   int          fileSize;    /*!< Size of the file in bytes. */
+   int          patchCount;  /*!< Number of patches for the file. */
+   PatchedByte *patches;     /*!< Patches for the file. */
+} PatchedFile;
+
+typedef struct _Patch
+{
+   const char   *name;       /*!< Name of the patch. */
+   int           fileCount;  /*!< Number of files in the patch. */
+   PatchedFile  *files;      /*!< Files for the patch. */
+} Patch;
+
+/** FUNCTION PROTOTYPES *******************************************************/
+
+static void printUsage();
+
+/** GLOBALS *******************************************************************/
+
+static Patch m_patch = { NULL, 0, NULL };
+static int m_argc = 0;
+static char **m_argv = NULL;
+
+/* patch buffer where we put the patch info into */
+static unsigned char m_patchBuffer[SIZEOF_PATCH_BUFFER_MAGIC + PATCH_BUFFER_SIZE] =
+   PATCH_BUFFER_MAGIC;
+
+/** HELPER FUNCTIONS **********************************************************/
+
+static void *
+loadFile(const char *fileName, int *fileSize_)
+{
+   FILE *f;
+   struct stat sb;
+   int fileSize;
+   void *p;
+   
+   /* Open the file */
+   f = fopen(fileName, "rb");
+   if (f == NULL)
+   {
+      printf("Couldn't open file %s for reading!\n", fileName);
+      return NULL;
+   }
+   
+   /* Get file size */
+   if (fstat(fileno(f), &sb) < 0)
+   {
+      fclose(f);
+      printf("Couldn't get size of file %s!\n", fileName);
+      return NULL;
+   }
+   fileSize = sb.st_size;
+   
+   /* Load file */
+   p = malloc(fileSize);
+   if (p == NULL)
+   {
+      fclose(f);
+      printf("Couldn't allocate %d bytes for file %s!\n", fileSize, fileName);
+      return NULL;
+   }
+   
+   if (fread(p, fileSize, 1, f) != 1)
+   {
+      fclose(f);
+      free(p);
+      printf("Couldn't read file %s into memory!\n", fileName);
+      return NULL;
+   }
+   
+   /* Close file */
+   fclose(f);
+   
+   *fileSize_ = fileSize;
+   return p;
+}
+
+
+static int
+saveFile(const char *fileName, void *file, int fileSize)
+{
+   FILE *f;
+
+   /* Open the file */
+   f = fopen(fileName, "wb");
+   if (f == NULL)
+   {
+      printf("Couldn't open file %s for writing!\n", fileName);
+      return -1;
+   }
+
+   /* Write file */
+   if (fwrite(file, fileSize, 1, f) != 1)
+   {
+      fclose(f);
+      printf("Couldn't write file %s!\n", fileName);
+      return -1;
+   }
+
+   /* Close file */
+   fclose(f);
+   return 0;
+}
+
+
+static int
+compareFiles(
+   PatchedFile *patchedFile,
+   const char *originalFileName)
+{
+   const char *patchedFileName = patchedFile->name;
+   unsigned char *origChunk, *patchedChunk;
+   int origSize, patchedSize, i, patchCount;
+   PatchedByte *patches = NULL;
+   int patchesArrayCount = 0;
+   
+   /* Load both files */
+   origChunk = loadFile(originalFileName, &origSize);
+   if (origChunk == NULL)
+      return -1;
+   patchedChunk = loadFile(patchedFileName, &patchedSize);
+   if (patchedChunk == NULL)
+   {
+      free(origChunk);
+      return -1;
+   }
+   if (origSize != patchedSize)
+   {
+      free(origChunk);
+      free(patchedChunk);
+      printf("File size of %s and %s differs (%d != %d)\n",
+             originalFileName, patchedFileName,
+             origSize, patchedSize);
+      return -1;
+   }
+   
+   /* Compare the files and record any differences */
+   printf("Comparing %s to %s", originalFileName, patchedFileName);
+   for (i = 0, patchCount = 0; i < origSize; i++)
+   {
+      if (origChunk[i] != patchedChunk[i])
+      {
+         patchCount++;
+         
+         /* Resize patches array if needed */
+         if (patchesArrayCount < patchCount)
+         {
+            PatchedByte *newPatches;
+            newPatches = realloc(patches, patchCount * sizeof (PatchedByte));
+            if (newPatches == NULL)
+            {
+              if (patches != NULL)
+                free(patches);
+              free(origChunk);
+              free(patchedChunk);
+              printf("\nOut of memory (tried to allocated %d bytes)\n",
+                     patchCount * sizeof (PatchedByte));
+              return -1;
+            }
+            patches = newPatches;
+         }
+         
+         /* Fill in patch info */
+         patches[patchCount - 1].offset = i;
+         patches[patchCount - 1].expected = origChunk[i];
+         patches[patchCount - 1].patched = patchedChunk[i];
+      }
+      if ((i % (origSize / 40)) == 0)
+         printf(".");
+   }
+   printf(" %d changed bytes found.\n", patchCount);
+   
+   /* Unload the files */
+   free(origChunk);
+   free(patchedChunk);
+   
+   /* Save patch info */
+   patchedFile->fileSize = patchedSize;
+   patchedFile->patchCount = patchCount;
+   patchedFile->patches = patches;
+   
+   return 0;
+}
+
+
+static int
+outputPatch(const char *outputFileName)
+{
+   unsigned char *patchExe, *patchBuffer;
+   int i, size, patchExeSize, patchSize, stringSize, stringOffset, patchOffset;
+   Patch *patch;
+   PatchedFile *files;
+   
+   printf("Putting patch into %s...\n", outputFileName);
+   
+   /* Calculate size of the patch */
+   patchSize = sizeof (Patch) + sizeof (PatchedFile) * m_patch.fileCount;
+   stringSize = strlen(m_patch.name) + 1;
+   for (i = 0; i < m_patch.fileCount; i++)
+   {
+      stringSize += strlen(m_patch.files[i].name) + 1;
+      patchSize += sizeof (PatchedByte) * m_patch.files[i].patchCount;
+   }
+   if ((stringSize + patchSize) > PATCH_BUFFER_SIZE)
+   {
+      printf("Patch is too big - %d bytes maximum, %d bytes needed\n",
+             PATCH_BUFFER_SIZE, stringSize + patchSize);
+      return -1;
+   }
+
+   /* Load patch.exe file into memory... */
+   patchExe = loadFile(m_argv[0], &patchExeSize);
+   if (patchExe == NULL)
+   {
+      return -1;
+   }
+   
+   /* Try to find the magic mark for the patch buffer */
+   for (i = 0; i < (patchExeSize - SIZEOF_PATCH_BUFFER_MAGIC); i++)
+   {
+      if (memcmp(patchExe + i, m_patchBuffer, SIZEOF_PATCH_BUFFER_MAGIC) == 0)
+      {
+         patchBuffer = patchExe + i + SIZEOF_PATCH_BUFFER_MAGIC;
+         
+         break;
+      }
+   }
+   if (!(i < (patchExeSize - SIZEOF_PATCH_BUFFER_MAGIC)))
+   {
+      free(patchExe);
+      printf("Couldn't find patch buffer magic in file %s - this shouldn't happen!!!\n", m_argv[0]);
+      return -1;
+   }
+   
+   /* Pack patch together and replace string pointers by offsets */
+   patch = (Patch *)patchBuffer;
+   files = (PatchedFile *)(patchBuffer + sizeof (Patch));
+   patchOffset = sizeof (Patch) + sizeof (PatchedFile) * m_patch.fileCount;
+   stringOffset = patchSize;
+   
+   patch->fileCount = m_patch.fileCount;
+   patch->files = (PatchedFile *)sizeof (Patch);
+
+   patch->name = (const char *)stringOffset;
+   strcpy(patchBuffer + stringOffset, m_patch.name);
+   stringOffset += strlen(m_patch.name) + 1;
+   
+   for (i = 0; i < m_patch.fileCount; i++)
+   {
+      files[i].fileSize = m_patch.files[i].fileSize;
+      files[i].patchCount = m_patch.files[i].patchCount;
+      
+      files[i].name = (const char *)stringOffset;
+      strcpy(patchBuffer + stringOffset, m_patch.files[i].name);
+      stringOffset += strlen(m_patch.files[i].name) + 1;
+      
+      size = files[i].patchCount * sizeof (PatchedByte);
+      files[i].patches = (PatchedByte *)patchOffset;
+      memcpy(patchBuffer + patchOffset, m_patch.files[i].patches, size);
+      patchOffset += size;
+   }
+   size = patchSize + stringSize;
+   memset(patchBuffer + size, 0, PATCH_BUFFER_SIZE - size);
+
+   /* Save file */
+   if (saveFile(outputFileName, patchExe, patchExeSize) < 0)
+   {
+      free(patchExe);
+      return -1;
+   }
+   free(patchExe);
+
+   printf("Patch saved!\n");
+   return 0;
+}
+
+
+static int
+loadPatch()
+{
+   char *p;
+   Patch *patch;
+   int i;
+   
+   p = m_patchBuffer + SIZEOF_PATCH_BUFFER_MAGIC;
+   patch = (Patch *)p;
+   
+   if (patch->name == NULL)
+   {
+      return -1;
+   }
+   
+   m_patch.name = p + (int)patch->name;
+   m_patch.fileCount = patch->fileCount;
+   m_patch.files = (PatchedFile *)(p + (int)patch->files);
+
+   for (i = 0; i < m_patch.fileCount; i++)
+   {
+      m_patch.files[i].name = p + (int)m_patch.files[i].name;
+      m_patch.files[i].patches = (PatchedByte *)(p + (int)m_patch.files[i].patches);
+   }
+   
+   printf("Patch %s loaded...\n", m_patch.name);
+   return 0;
+}
+
+
+/** MAIN FUNCTIONS ************************************************************/
+
+static int
+createPatch()
+{
+   int i, status;
+   const char *outputFileName;
+
+   /* Check argument count */
+   if (m_argc < 6 || (m_argc % 2) != 0)
+   {
+      printUsage();
+      return -1;
+   }
+
+   outputFileName = m_argv[3];
+   m_patch.name = m_argv[2];
+
+   /* Allocate PatchedFiles array */
+   m_patch.fileCount = (m_argc - 4) / 2;
+   m_patch.files = malloc(m_patch.fileCount * sizeof (PatchedFile));
+   if (m_patch.files == NULL)
+   {
+      printf("Out of memory!\n");
+      return -1;
+   }
+   memset(m_patch.files, 0, m_patch.fileCount * sizeof (PatchedFile));
+
+   /* Compare original to patched files and fill m_patch.files array */
+   for (i = 0; i < m_patch.fileCount; i++)
+   {
+      m_patch.files[i].name = m_argv[4 + (i * 2) + 1];
+      status = compareFiles(m_patch.files + i, m_argv[4 + (i * 2) + 0]);
+      if (status < 0)
+      {
+         for (i = 0; i < m_patch.fileCount; i++)
+         {
+            if (m_patch.files[i].patches != NULL)
+               free(m_patch.files[i].patches);
+         }
+         free(m_patch.files);
+         m_patch.files = NULL;
+         m_patch.fileCount = 0;
+         return status;
+      }
+   }
+   
+   /* Output patch */
+   return outputPatch(outputFileName);
+}
+
+
+static int
+applyPatch()
+{
+   int c, i, j, fileSize, makeBackup;
+   unsigned char *file;
+   char *p;
+   const char *fileName;
+   char buffer[MAX_PATH];
+   
+
+   if (m_argc > 1 && strcmp(m_argv[1], "-d") != 0)
+   {
+      printUsage();
+      return -1;
+   }
+
+   /* Load patch */
+   if (loadPatch() < 0)
+   {
+      printf("This executable doesn't contain a patch, use -c to create one.\n");
+      return -1;
+   }
+
+   if (m_argc > 1)
+   {
+      /* Dump patch */
+      printf("Patch name: %s\n", m_patch.name);
+      printf("File count: %d\n", m_patch.fileCount);
+      for (i = 0; i < m_patch.fileCount; i++)
+      {
+         printf("----------------------\n"
+                "File name:   %s\n"
+                "File size:   %d bytes\n",
+                m_patch.files[i].name, m_patch.files[i].fileSize);
+         printf("Patch count: %d\n", m_patch.files[i].patchCount);
+         for (j = 0; j < m_patch.files[i].patchCount; j++)
+         {
+            printf("  Offset 0x%x   0x%02x -> 0x%02x\n",
+                   m_patch.files[i].patches[j].offset,
+                   m_patch.files[i].patches[j].expected,
+                   m_patch.files[i].patches[j].patched);
+         }
+      }
+   }
+   else
+   {
+      /* Apply patch */
+      printf("Applying patch...\n");
+      for (i = 0; i < m_patch.fileCount; i++)
+      {
+         /* Load original file */
+         fileName = m_patch.files[i].name;
+applyPatch_retry_file:
+         file = loadFile(fileName, &fileSize);
+         if (file == NULL)
+         {
+            printf("File %s not found! ", fileName);
+applyPatch_file_open_error:
+            printf("(S)kip, (R)etry, (A)bort, (M)anually enter filename");
+            do
+            {
+               c = getch();
+            }
+            while (c != 's' && c != 'r' && c != 'a' && c != 'm');
+            printf("\n");
+            if (c == 's')
+            {
+               continue;
+            }
+            else if (c == 'r')
+            {
+               goto applyPatch_retry_file;
+            }
+            else if (c == 'a')
+            {
+               return 0;
+            }
+            else if (c == 'm')
+            {
+               if (fgets(buffer, sizeof (buffer), stdin) == NULL)
+               {
+                  printf("fgets() failed!\n");
+                  return -1;
+               }
+               p = strchr(buffer, '\r');
+               if (p != NULL)
+                  *p = '\0';
+               p = strchr(buffer, '\n');
+               if (p != NULL)
+                  *p = '\0';
+
+               fileName = buffer;
+               goto applyPatch_retry_file;
+            }
+         }
+
+         /* Check file size */
+         if (fileSize != m_patch.files[i].fileSize)
+         {
+            free(file);
+            printf("File %s has unexpected filesize of %d bytes (%d bytes expected)\n",
+                   fileName, fileSize, m_patch.files[i].fileSize);
+            if (fileName != m_patch.files[i].name) /* manually entered filename */
+            {
+               goto applyPatch_file_open_error;
+            }
+            return -1;
+         }
+         
+         /* Ask for backup */
+         printf("Do you want to make a backup of %s? (Y)es, (N)o, (A)bort", fileName);
+         do
+         {
+            c = getch();
+         }
+         while (c != 'y' && c != 'n' && c != 'a');
+         printf("\n");
+         if (c == 'y')
+         {
+            char buffer[MAX_PATH];
+            snprintf(buffer, MAX_PATH, "%s.bak", fileName);
+            buffer[MAX_PATH-1] = '\0';
+            makeBackup = 1;
+            if (access(buffer, 0) >= 0) /* file exists */
+            {
+               printf("File %s already exists, overwrite? (Y)es, (N)o, (A)bort", buffer);
+               do
+               {
+                  c = getch();
+               }
+               while (c != 'y' && c != 'n' && c != 'a');
+               printf("\n");
+               if (c == 'n')
+                  makeBackup = 0;
+               else if (c == 'a')
+               {
+                  free(file);
+                  return 0;
+               }
+            }
+            if (makeBackup && saveFile(buffer, file, fileSize) < 0)
+            {
+               free(file);
+               return -1;
+            }
+         }
+         else if (c == 'a')
+         {
+            free(file);
+            return 0;
+         }
+         
+         /* Patch file */
+         for (j = 0; j < m_patch.files[i].patchCount; j++)
+         {
+            int offset = m_patch.files[i].patches[j].offset;
+            if (file[offset] != m_patch.files[i].patches[j].expected)
+            {
+               printf("Unexpected value in file %s at offset 0x%x: expected = 0x%02x, found = 0x%02x\n",
+                      fileName, offset, m_patch.files[i].patches[j].expected, file[offset]);
+               free(file);
+               return -1;
+            }
+            file[offset] = m_patch.files[i].patches[j].patched;
+         }
+         
+         /* Save file */
+         if (saveFile(fileName, file, fileSize) < 0)
+         {
+            free(file);
+            return -1;
+         }
+         free(file);
+      }
+      
+      printf("Patch applied sucessfully!\n");
+   }
+
+   return 0;
+}
+
+
+static void
+printUsage()
+{
+   printf("Usage:\n"
+          "%s -c     - Create patch\n"
+          "%s -d     - Dump patch\n"
+          "%s        - Apply patch\n"
+          "\n"
+          "A patch can be created like this:\n"
+          "%s -c \"patch name\" output.exe file1.orig file1.patched[ file2.orig file2.patched[ ...]]\n",
+          m_argv[0], m_argv[0], m_argv[0], m_argv[0]);
+}
+
+
+int
+main(
+   int argc,
+   char *argv[])
+{
+   m_argc = argc;
+   m_argv = argv;
+
+   if (argc >= 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0))
+   {
+      printUsage();
+      return 0;
+   }
+   else if (argc >= 2 && argv[1][0] == '-')
+   {
+      if (strcmp(argv[1], "-c") == 0)
+      {
+         return createPatch();
+      }
+      else if (strcmp(argv[1], "-d") == 0)
+      {
+         return applyPatch();
+      }
+      else
+      {
+         printf("Unknown option: %s\n"
+                "Use -h for help.\n",
+                argv[1]);
+         return -1;
+      }
+   }
+   
+   return applyPatch();
+}
+

apps/utils/cat/cat.c

@@ -0,0 +1,26 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+int main(int argc, char* argv[])
+{
+   int i;
+   FILE* in;
+   char ch;
+   
+   for (i=1; i<argc; i++)
+     {
+	in = fopen(argv[i],"r");
+	if (in == NULL)
+	  {
+	     printf("Failed to open file %s\n", argv[i]);
+	     return(0);
+	  }
+	
+	while ((ch = fgetc(in)) != EOF)
+	  {
+	     putchar(ch);
+	  }
+	fclose(in);
+     }
+   return 0;
+}

apps/utils/cat/makefile

@@ -0,0 +1,21 @@
+# $Id$
+
+PATH_TO_TOP = ../../..
+
+TARGET_NORC = yes
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = cat
+
+TARGET_OBJECTS = $(TARGET_NAME).o
+
+TARGET_CFLAGS = -Wall -Werror
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk
+
+# EOF

apps/utils/driver/load/load.c

@@ -0,0 +1,32 @@
+/*
+ * Load a device driver
+ */ 
+#include <windows.h>
+#include <ntos/zw.h>
+
+int
+main(int argc, char *argv[])
+{
+   NTSTATUS Status;
+   UNICODE_STRING ServiceName;
+
+   if (argc != 2)
+   {
+      printf("Usage: load <ServiceName>\n");
+      return 0;
+   }
+   ServiceName.Length = (strlen(argv[1]) + 52) * sizeof(WCHAR);
+   ServiceName.Buffer = (LPWSTR)malloc(ServiceName.Length + sizeof(UNICODE_NULL));
+   wsprintf(ServiceName.Buffer,
+      L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\%S",
+      argv[1]);
+   wprintf(L"%s %d %d\n", ServiceName.Buffer, ServiceName.Length, wcslen(ServiceName.Buffer));
+   Status = NtLoadDriver(&ServiceName);
+   free(ServiceName.Buffer);
+   if (!NT_SUCCESS(Status))
+   {
+      printf("Failed: %X\n", Status);
+      return 1;
+   }
+   return 0;
+}

apps/utils/driver/load/makefile

@@ -0,0 +1,21 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_NORC = yes
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = load
+
+TARGET_CFLAGS = -DUNICODE -D_UNICODE
+
+TARGET_SDKLIBS = ntdll.a
+
+TARGET_OBJECTS = $(TARGET_NAME).o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk
+
+# EOF

apps/utils/driver/unload/makefile

@@ -0,0 +1,21 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_NORC = yes
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = unload
+
+TARGET_CFLAGS = -DUNICODE -D_UNICODE
+
+TARGET_SDKLIBS = ntdll.a
+
+TARGET_OBJECTS = $(TARGET_NAME).o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk
+
+# EOF

apps/utils/driver/unload/unload.c

@@ -0,0 +1,32 @@
+/*
+ * Unload a device driver
+ */ 
+#include <windows.h>
+#include <ntos/zw.h>
+
+int
+main(int argc, char *argv[])
+{
+   NTSTATUS Status;
+   UNICODE_STRING ServiceName;
+
+   if (argc != 2)
+   {
+      printf("Usage: unload <ServiceName>\n");
+      return 0;
+   }
+   ServiceName.Length = (strlen(argv[1]) + 52) * sizeof(WCHAR);
+   ServiceName.Buffer = (LPWSTR)malloc(ServiceName.Length + sizeof(UNICODE_NULL));
+   wsprintf(ServiceName.Buffer,
+      L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\%S",
+      argv[1]);
+   wprintf(L"%s %d %d\n", ServiceName.Buffer, ServiceName.Length, wcslen(ServiceName.Buffer));
+   Status = NtUnloadDriver(&ServiceName);
+   free(ServiceName.Buffer);
+   if (!NT_SUCCESS(Status))
+   {
+      printf("Failed: %X\n", Status);
+      return 1;
+   }
+   return 0;
+}

apps/utils/infinst/makefile

@@ -0,0 +1,21 @@
+PATH_TO_TOP = ../../..
+
+TARGET_NORC = yes
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = windows
+
+TARGET_NAME = infinst
+
+TARGET_SDKLIBS = comdlg32.a setupapi.a
+
+TARGET_OBJECTS = infinst.o
+
+TARGET_CFLAGS = -Wall -Werror
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk
+
+# EOF

apps/utils/net/arp/arp.c

@@ -0,0 +1,99 @@
+/*
+ * arp - display ARP cache from the IP stack parameters.
+ *
+ * This source code is in the PUBLIC DOMAIN and has NO WARRANTY.
+ *
+ * Robert Dickenson <robd@reactos.org>, August 15, 2002.
+ */
+#include <stdio.h>
+#include <windows.h>
+#include <tchar.h>
+#include <time.h>
+
+#include <iptypes.h>
+#include <ipexport.h>
+#include <iphlpapi.h>
+#include <snmp.h>
+
+#include "trace.h"
+
+
+VOID SNMP_FUNC_TYPE SnmpSvcInitUptime();
+DWORD SNMP_FUNC_TYPE SnmpSvcGetUptime();
+
+////////////////////////////////////////////////////////////////////////////////
+
+const char szUsage[] = { "\n" \
+    "Displays and modifies the IP Protocol to physical address translation tables\n" \
+    "used by address resolution protocol (ARP).\n" \
+    "\n" \
+    "ARP -s inet_addr eth_addr [if_addr]\n" \
+    "ARP -d inet_addr [if_addr]\n" \
+    "ARP -a [inet_addr] [-N if_addr]\n" \
+    "\n" \
+    "  -a            Displays the active ARP table by querying the current protocol\n" \
+    "                data. If inet_addr is specified, the IP and physical addresses\n" \
+    "                for the specified address are displayed. If more than one\n" \
+    "                network interface is using ARP, each interfaces ARP table is\n" \
+    "                displayed.\n" \
+    "  -g            Indentical to -a.\n" \
+    "  inet_addr     Specifies the IP address.\n" \
+    "  -N if_addr    Displays the ARP table for the specified interface only\n" \
+    "  -d            Deletes the host entry specified by inet_addr. inet_addr may be\n" \
+    "                wildcarded with * to delete all host entries in the ARP table.\n" \
+    "  -s            Adds the host and associates the IP address inet_addr with the\n" \
+    "                physical address eth_addr. The physical address must be specified\n" \
+    "                as 6 hexadecimal characters delimited by hyphens. The new entry\n" \
+    "                will become permanent in the ARP table.\n" \
+    "  eth_addr      Specifies the interface physical address.\n" \
+    "  if_addr       If present, this specifies the IP address of the interface whose\n" \
+    "                address translation table should be modified. If not present, the\n" \
+    "                first applicable interface will be used.\n" \
+    "Example:\n" \
+    "  > arp -s 192.168.0.12   55-AA-55-01-02-03   .... Static entry creation.\n" \
+    "  > arp -a                                    .... ARP table display.\n" \
+    "  > arp -d *                                  .... Delete all ARP table entries.\n"
+};
+
+void usage(void)
+{
+//	fprintf(stderr,"USAGE:\n");
+	fputs(szUsage, stderr);
+}
+
+int main(int argc, char *argv[])
+{
+    TCHAR szComputerName[50];
+    DWORD dwSize = 50;
+
+    int nBytes = 500;
+    BYTE* pCache;
+
+    if (argc > 1) {
+        usage();
+        return 1;
+    }
+
+    SnmpSvcInitUptime();
+
+    GetComputerName(szComputerName, &dwSize);
+    _tprintf(_T("ReactOS ARP cache on Computer Name: %s\n"), szComputerName);
+
+    pCache = (BYTE*)SnmpUtilMemAlloc(nBytes);
+
+        Sleep(2500);
+
+    if (pCache != NULL) {
+
+        DWORD dwUptime = SnmpSvcGetUptime();
+
+        _tprintf(_T("SNMP uptime: %d\n"), dwUptime);
+
+        SnmpUtilMemFree(pCache);
+    } else {
+        _tprintf(_T("ERROR: call to SnmpUtilMemAlloc() failed\n"));
+        return 1;
+    }
+	return 0;
+}
+

apps/utils/net/arp/arp.rc

@@ -0,0 +1,6 @@
+/* $Id$ */
+
+#define REACTOS_STR_FILE_DESCRIPTION	"ReactOS TCP/IPv4 Win32 arp\0"
+#define REACTOS_STR_INTERNAL_NAME	"arp\0"
+#define REACTOS_STR_ORIGINAL_FILENAME	"arp.exe\0"
+#include <reactos/version.rc>

apps/utils/net/arp/makefile

@@ -0,0 +1,19 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = arp
+
+TARGET_INSTALLDIR = system32
+
+TARGET_CFLAGS = -D__USE_W32API
+
+TARGET_SDKLIBS = user32.a snmpapi.a
+
+TARGET_OBJECTS = $(TARGET_NAME).o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk

apps/utils/net/arp/trace.c

@@ -0,0 +1,53 @@
+/////////////////////////////////////////////////////////////////////////////
+// Diagnostic Trace
+//
+#include <stdio.h> 
+#include <stdarg.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <tchar.h>
+#include "trace.h"
+
+
+#ifdef _DEBUG
+
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+
+void _DebugBreak(void)
+{
+    DebugBreak();
+}
+
+void Trace(TCHAR* lpszFormat, ...)
+{
+    va_list args;
+    int nBuf;
+    TCHAR szBuffer[512];
+
+    va_start(args, lpszFormat);
+    nBuf = _vsntprintf(szBuffer, sizeof(szBuffer)/sizeof(TCHAR), lpszFormat, args);
+    OutputDebugString(szBuffer);
+    // was there an error? was the expanded string too long?
+    //ASSERT(nBuf >= 0);
+    va_end(args);
+}
+
+void Assert(void* assert, TCHAR* file, int line, void* msg)
+{
+    if (msg == NULL) {
+        printf("ASSERT -- %s occured on line %u of file %s.\n",
+               assert, line, file);
+    } else {
+        printf("ASSERT -- %s occured on line %u of file %s: Message = %s.\n",
+               assert, line, file, msg);
+    }
+}
+
+#else
+
+void Trace(TCHAR* lpszFormat, ...) { };
+void Assert(void* assert, TCHAR* file, int line, void* msg) { };
+
+#endif //_DEBUG
+/////////////////////////////////////////////////////////////////////////////

apps/utils/net/finger/finger.c

@@ -41,6 +41,16 @@
  *          Had to remove local handling.	 Otherwise, same as whois.
  */
 
+#ifndef lint
+static char copyright[] =
+"@(#) Copyright (c) 1989, 1993\n\
+	The Regents of the University of California.  All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)finger.c	8.5 (Berkeley) 5/4/95";
+#endif /* not lint */
+
 /*
  * Finger prints out information about users.  It is not portable since
  * certain fields (e.g. the full user name, office, and phone numbers) are
@@ -62,6 +72,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
+#include "unistd.h"
 
 #include "various.h"
 #include "getopt.h"
@@ -73,6 +84,7 @@ int lflag, mflag, pplan, sflag;
 
 static void userlist(int, char **);
 void usage();
+void netfinger(char *);
 
 int
 main(int argc, char **argv)
@@ -129,8 +141,8 @@ userlist(int argc, char **argv)
 	int iErr;
 
 
-	if ((nargv = (char**) malloc((argc+1) * sizeof(char *))) == NULL ||
-	    (used = (int*) calloc(argc, sizeof(int))) == NULL)
+	if ((nargv = malloc((argc+1) * sizeof(char *))) == NULL ||
+	    (used = calloc(argc, sizeof(int))) == NULL)
 		err(1, NULL);
 
 	/* Pull out all network requests into nargv. */
@@ -149,10 +161,10 @@ userlist(int argc, char **argv)
 		fprintf(stderr, "Warning: Can't do local finger\n");
 	}
 
-	/* Start winsock */
+	/* Start winsock */ 
 	wVersionRequested = MAKEWORD( 1, 1 );
 	iErr = WSAStartup( wVersionRequested, &wsaData );
-	if ( iErr != 0 )
+	if ( iErr != 0 ) 
 	{
 		/* Tell the user that we couldn't find a usable */
 		/* WinSock DLL.                                  */

apps/utils/net/finger/getopt.c

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 1987 Regents of the University of California.
+ * All rights reserved.
+ *
+ * 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
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	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 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
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * Fri Jun 13 10:39:00 1997, tfelix@fred.net:
+ *     Ported to Win32, changed index/rindex to strchr/strrchr
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)getopt.c	4.13 (Berkeley) 2/23/91";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * get option letter from argument vector
+ */
+int	opterr = 1,		/* if error message should be printed */
+	optind = 1,		/* index into parent argv vector */
+	optopt;			/* character checked for validity */
+char	*optarg;		/* argument associated with option */
+
+#define	BADCH	(int)'?'
+#define	EMSG	""
+
+int
+getopt(int nargc, char * const *nargv, const char *ostr)
+{
+	static char *place = EMSG;		/* option letter processing */
+	register char *oli;			/* option letter list index */
+	char *p;
+
+	if (!*place) {				/* update scanning pointer */
+		if (optind >= nargc || *(place = nargv[optind]) != '-') {
+			place = EMSG;
+			return(EOF);
+		}
+		if (place[1] && *++place == '-') {	/* found "--" */
+			++optind;
+			place = EMSG;
+			return(EOF);
+		}
+	}					/* option letter okay? */
+	if ((optopt = (int)*place++) == (int)':' ||
+	    !(oli = strchr(ostr, optopt))) {
+		/*
+		 * if the user didn't specify '-' as an option,
+		 * assume it means EOF.
+		 */
+		if (optopt == (int)'-')
+			return(EOF);
+		if (!*place)
+			++optind;
+		if (opterr) {
+			if (!(p = strrchr(*nargv, '/')))
+				p = *nargv;
+			else
+				++p;
+			(void)fprintf(stderr, "%s: illegal option -- %c\n",
+			    p, optopt);
+		}
+		return(BADCH);
+	}
+	if (*++oli != ':') {			/* don't need argument */
+		optarg = NULL;
+		if (!*place)
+			++optind;
+	}
+	else {					/* need an argument */
+		if (*place)			/* no white space */
+			optarg = place;
+		else if (nargc <= ++optind) {	/* no arg */
+			place = EMSG;
+			if (!(p = strrchr(*nargv, '/')))
+				p = *nargv;
+			else
+				++p;
+			if (opterr)
+				(void)fprintf(stderr,
+				    "%s: option requires an argument -- %c\n",
+				    p, optopt);
+			return(BADCH);
+		}
+	 	else				/* white space */
+			optarg = nargv[optind];
+		place = EMSG;
+		++optind;
+	}
+	return(optopt);				/* dump back option letter */
+}

apps/utils/net/finger/getopt.h

@@ -0,0 +1,7 @@
+/* getopt.h */
+
+extern char *optarg;
+extern int optind;
+
+int
+getopt(int nargc, char * const *nargv, const char *ostr);

apps/utils/net/finger/makefile

@@ -0,0 +1,24 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = finger
+
+TARGET_SDKLIBS = ws2_32.a
+
+TARGET_INSTALLDIR = system32
+
+TARGET_CFLAGS = -D__USE_W32_SOCKETS
+
+TARGET_OBJECTS = $(TARGET_NAME).o \
+  err.o \
+  getopt.o \
+  net.o 
+
+TARGET_GCCLIBS = iberty
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk

apps/utils/net/finger/net.c

@@ -34,7 +34,13 @@
  * SUCH DAMAGE.
  */
 
+#ifndef lint
+static char sccsid[] = "@(#)net.c	8.4 (Berkeley) 4/28/95";
+#endif /* not lint */
+
+#include <sys/types.h>
 #include <winsock2.h>
+#include "unistd.h"
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
@@ -50,15 +56,15 @@ netfinger(char *name)
 	struct hostent *hp, def;
 	struct servent *sp;
 	struct sockaddr_in sin;
-	SOCKET s;
+	int s;
 	char *alist[1], *host;
 
 	/* If this is a local request */
 	if (!(host = rindex(name, '@')))
 		return;
 
-	*host++ = '\0';
-	if (isdigit(*host) && (defaddr.s_addr = inet_addr(host)) != (unsigned long)-1) {
+	*host++ = NULL;
+	if (isdigit(*host) && (defaddr.s_addr = inet_addr(host)) != -1) {
 		def.h_name = host;
 		def.h_addr_list = alist;
 		def.h_addr = (char *)&defaddr;
@@ -78,7 +84,7 @@ netfinger(char *name)
 	sin.sin_family = hp->h_addrtype;
 	bcopy(hp->h_addr, (char *)&sin.sin_addr, hp->h_length);
 	sin.sin_port = sp->s_port;
-	if ((s = socket(hp->h_addrtype, SOCK_STREAM, 0)) == INVALID_SOCKET) {
+	if ((s = socket(hp->h_addrtype, SOCK_STREAM, 0)) < 0) {
 		perror("finger: socket");
 		return;
 	}
@@ -87,7 +93,7 @@ netfinger(char *name)
 	(void)printf("[%s]\n", hp->h_name);
 	if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
 		fprintf(stderr, "finger: connect rc = %d", WSAGetLastError());
-		(void)closesocket(s);
+		(void)close(s);
 		return;
 	}
 
@@ -109,7 +115,7 @@ netfinger(char *name)
 	 * Otherwise, all high bits are stripped; if it isn't printable and
 	 * it isn't a space, we can simply set the 7th bit.  Every ASCII
 	 * character with bit 7 set is printable.
-	 */
+	 */ 
 	lastc = 0;
 	while (recv(s, &c, 1, 0) == 1) {
 		c &= 0x7f;

apps/utils/net/finger/various.h

@@ -0,0 +1,34 @@
+// Various things you need when porting BSD and GNU utilities to
+// Win32.
+
+#ifndef VARIOUS_H
+#define VARIOUS_H
+
+
+typedef float f4byte_t;
+typedef double f8byte_t;
+typedef long uid_t;  // SunOS 5.5
+
+#define __P(x) x
+
+/* utmp.h */
+#define UT_LINESIZE 8
+#define UT_HOSTSIZE 16
+
+/* stat.h */
+#define  S_ISREG(mode)   (((mode)&0xF000) == 0x8000)
+#define  S_ISDIR(mode)   (((mode)&0xF000) == 0x4000)
+
+#undef MIN //take care of windows default
+#undef MAX //take care of windows default
+#define MIN(a, b) ((a) <= (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+#define bcopy(s1, s2, n)  memmove(s2, s1, n)
+#define bcmp(s1, s2, n)  (memcmp(s1, s2, n) != 0)
+#define bzero(s, n)  memset(s, 0, n)
+
+#define index(s, c)  strchr(s, c)
+#define rindex(s, c)  strrchr(s, c)
+
+#endif

apps/utils/net/ftp/cmdtab.c

@@ -24,6 +24,20 @@ static char sccsid[] = "@(#)cmdtab.c	5.9 (Berkeley) 3/21/89";
 /*
  * User FTP -- Command Tables.
  */
+int	setascii(), setbell(), setbinary(), setdebug(), setform();
+int	setglob(), sethash(), setmode(), setpeer(), setpassive(), setport();
+int	setprompt(), setstruct();
+int	settenex(), settrace(), settype(), setverbose();
+int	disconnect(), restart(), reget(), syst();
+int	cd(), lcd(), delete(), mdelete(), user();
+int	ls(), mls(), get(), mget(), help(), append(), put(), mput();
+int	quit(), renamefile(), status();
+int	quote(), rmthelp(), shell(), site();
+int	pwd(), makedir(), removedir(), setcr();
+int	account(), doproxy(), reset(), setcase(), setntrans(), setnmap();
+int	setsunique(), setrunique(), cdup(), macdef(), domacro();
+int	sizecmd(), modtime(), newer(), rmtstatus();
+int	do_chmod(), do_umask(), idle();
 
 char	accounthelp[] =	"send account command to remote server";
 char	appendhelp[] =	"append to a file";
@@ -126,7 +140,7 @@ struct cmd cmdtab[] = {
 	{ "mget",	mgethelp,	1,	1,	1,	mget },
 	{ "mkdir",	mkdirhelp,	0,	1,	1,	makedir },
 	{ "mls",	mlshelp,	1,	1,	1,	mls },
-	{ "mode",	modehelp,	0,	1,	1,	fsetmode },
+	{ "mode",	modehelp,	0,	1,	1,	setmode },
 	{ "modtime",	modtimehelp,	0,	1,	1,	modtime },
 	{ "mput",	mputhelp,	1,	1,	1,	mput },
 	{ "newer",	newerhelp,	1,	1,	1,	newer },

apps/utils/net/ftp/domacro.c

@@ -30,14 +30,15 @@ static char sccsid[] = "@(#)domacro.c	1.6 (Berkeley) 2/28/89";
 
 void domacro(argc, argv)
 	int argc;
-	const char *argv[];
+	char *argv[];
 {
-	int i, j;
-	const char *cp1;
-    char *cp2;
+	register int i, j;
+	register char *cp1, *cp2;
 	int count = 2, loopflg = 0;
 	char line2[200];
+	extern char **glob(), *globerr;
 	struct cmd *getcmd(), *c;
+	extern struct cmd cmdtab[];
 
 	if (argc < 2) {
 		(void) strcat(line, " ");

apps/utils/net/ftp/fake.c

@@ -1,7 +1,6 @@
 #include <stdio.h>
 #include <time.h>
 #include <winsock.h>
-#include "fake.h"
 #include "prototypes.h"
 
 #define MAX_ASCII 100
@@ -35,11 +34,12 @@ void blkfree(char **av0)
 		free(*av++);
 }
 
-char **glob(register char *v)
+char *glob(register char *v)
 {
    return NULL;
 }
 
+
 int sleep(int time)
 {
    return time;
@@ -49,8 +49,8 @@ int herror(char *string)
 {
    return 0;
 }
-
 #if 0
+
 int gettimeofday(struct timeval *timenow,
 				 struct timezone *zone)
 {
@@ -92,14 +92,14 @@ int fgetcSocket(int s)
 {
    static int index = 0;
    static int total = 0;
-   static char buffer[4096];
+   static unsigned char buffer[4096];
 
    if (index == total)
      {
        index = 0;
        total = recv(s, buffer, sizeof(buffer), 0);
 
-       if (total == SOCKET_ERROR)
+       if (total == INVALID_SOCKET)
 	 {
 	   total = 0;
 	   return ERROR;
@@ -113,7 +113,7 @@ int fgetcSocket(int s)
 
 #endif
 
-const char *fprintfSocket(int s, const char *format, ...)
+char *fprintfSocket(int s, char *format, ...)
 {
    va_list argptr;
    char buffer[10009];
@@ -127,7 +127,7 @@ const char *fprintfSocket(int s, const char *format, ...)
    return NULL;
 }
 
-const char *fputsSocket(const char *format, int s)
+char *fputsSocket(char *format, int s)
 {
    send(s, format, strlen(format), 0);
 
@@ -142,7 +142,7 @@ int fputcSocket(int s, char putChar)
    buffer[1] = '\0';
 
    if(SOCKET_ERROR==send(s, buffer, 1, 0)) {
-	   int iret=WSAGetLastError ();
+	   int iret=WSAGetLastError (); 
 	   fprintf(stdout,"fputcSocket: %d\n",iret);
 	   return 0;
    }
@@ -154,9 +154,9 @@ int fputSocket(int s, char *buffer, int len)
 {
 	int iret;
 	while(len) {
-		if(SOCKET_ERROR==(iret=send(s, buffer, len, 0)))
+		if(SOCKET_ERROR==(iret=send(s, buffer, len, 0))) 
 		{
-			iret=WSAGetLastError ();
+			iret=WSAGetLastError (); 
 			fprintf(stdout,"fputcSocket: %d\n",iret);
 			return 0;
 		}
@@ -187,7 +187,7 @@ char *fgetsSocket(int s, char *string)
       if (count == 1)
       {
 	 string[i] = buffer[0];
-
+	 
 	 if (i == MAX_ASCII - 3)
 	 {
 	    count = 0;
@@ -235,7 +235,7 @@ char *getpass (const char * prompt)
   static char input[256];
   HANDLE in;
   HANDLE err;
-  DWORD    count;
+  int    count;
 
   in = GetStdHandle (STD_INPUT_HANDLE);
   err = GetStdHandle (STD_ERROR_HANDLE);
@@ -293,13 +293,11 @@ char *getpass (const char * prompt)
   return NULL;
 }
 
-#if 0
 // Stubbed out here. Should be changed in Source code...
 int access(const char *filename, int accessmethod)
 {
    return 0;
 }
-#endif
 
 #ifndef __GNUC__
 #define EPOCHFILETIME (116444736000000000i64)
@@ -307,7 +305,12 @@ int access(const char *filename, int accessmethod)
 #define EPOCHFILETIME (116444736000000000LL)
 #endif
 
-int gettimeofday(struct timeval *tv, struct timezone *tz)
+struct timezone {
+    int tz_minuteswest; /* minutes W of Greenwich */
+    int tz_dsttime;     /* type of dst correction */
+};
+
+__inline int gettimeofday(struct timeval *tv, struct timezone *tz)
 {
     FILETIME        ft;
     LARGE_INTEGER   li;
@@ -317,8 +320,8 @@ int gettimeofday(struct timeval *tv, struct timezone *tz)
     if (tv)
     {
         GetSystemTimeAsFileTime(&ft);
-        li.LowPart  = ft.dwLowDateTime;
-        li.HighPart = ft.dwHighDateTime;
+        //li.LowPart  = ft.dwLowDateTime;
+        //li.HighPart = ft.dwHighDateTime;
         t  = li.QuadPart;       /* In 100-nanosecond intervals */
         t -= EPOCHFILETIME;     /* Offset to the Epoch time */
         t /= 10;                /* In microseconds */

apps/utils/net/ftp/fake.h

@@ -0,0 +1,10 @@
+#define bcopy(s,d,l) memcpy((d),(s),(l))
+#define bzero(cp,l) memset((cp),0,(l))
+
+#define rindex strrchr
+#define index strchr
+
+#define getwd getcwd
+
+#define strcasecmp strcmp
+#define strncasecmp strnicmp

apps/utils/net/ftp/ftp.mak

@@ -0,0 +1,372 @@
+# Microsoft Developer Studio Generated NMAKE File, Based on ftp.dsp
+!IF "$(CFG)" == ""
+CFG=ftp - Win32 Debug
+!MESSAGE No configuration specified. Defaulting to ftp - Win32 Debug.
+!ENDIF
+
+!IF "$(CFG)" != "ftp - Win32 Release" && "$(CFG)" != "ftp - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "ftp.mak" CFG="ftp - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "ftp - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "ftp - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+!ERROR An invalid configuration is specified.
+!ENDIF
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE
+NULL=nul
+!ENDIF
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+OUTDIR=.\Release
+INTDIR=.\Release
+# Begin Custom Macros
+OutDir=.\Release
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0"
+
+ALL : "$(OUTDIR)\ftp.exe"
+
+!ELSE
+
+ALL : "$(OUTDIR)\ftp.exe"
+
+!ENDIF
+
+CLEAN :
+	-@erase "$(INTDIR)\cmds.obj"
+	-@erase "$(INTDIR)\cmdtab.obj"
+	-@erase "$(INTDIR)\domacro.obj"
+	-@erase "$(INTDIR)\fake.obj"
+	-@erase "$(INTDIR)\ftp.obj"
+	-@erase "$(INTDIR)\main.obj"
+	-@erase "$(INTDIR)\ruserpass.obj"
+	-@erase "$(INTDIR)\vc*.idb"
+	-@erase "$(OUTDIR)\ftp.exe"
+	-@erase "$(OUTDIR)\ftp.pch"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /ML /W3 /GX /O2  /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" \
+ /D "HAVE_TIMEVAL" /Fp"$(INTDIR)\ftp.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD\
+ /c
+CPP_OBJS=.\Release/
+CPP_SBRS=.
+
+.c{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cpp{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cxx{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.c{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cpp{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cxx{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+RSC=rc.exe
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\ftp.bsc"
+BSC32_SBRS= \
+
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib wsock32.lib /nologo /subsystem:console /incremental:no\
+ /pdb:"$(OUTDIR)\ftp.pdb" /machine:I386 /out:"$(OUTDIR)\ftp.exe"
+LINK32_OBJS= \
+	"$(INTDIR)\cmds.obj" \
+	"$(INTDIR)\cmdtab.obj" \
+	"$(INTDIR)\domacro.obj" \
+	"$(INTDIR)\fake.obj" \
+	"$(INTDIR)\ftp.obj" \
+	"$(INTDIR)\main.obj" \
+	"$(INTDIR)\ruserpass.obj"
+
+"$(OUTDIR)\ftp.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Release\ftp.exe
+InputPath=.\Release\ftp.exe
+SOURCE=$(InputPath)
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+OUTDIR=.\Debug
+INTDIR=.\Debug
+# Begin Custom Macros
+OutDir=.\Debug
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0"
+
+ALL : "$(OUTDIR)\ftp.exe"
+
+!ELSE
+
+ALL : "$(OUTDIR)\ftp.exe"
+
+!ENDIF
+
+CLEAN :
+	-@erase "$(INTDIR)\cmds.obj"
+	-@erase "$(INTDIR)\cmdtab.obj"
+	-@erase "$(INTDIR)\domacro.obj"
+	-@erase "$(INTDIR)\fake.obj"
+	-@erase "$(INTDIR)\ftp.obj"
+	-@erase "$(INTDIR)\main.obj"
+	-@erase "$(INTDIR)\ruserpass.obj"
+	-@erase "$(INTDIR)\vc*.idb"
+	-@erase "$(INTDIR)\vc*.pdb"
+	-@erase "$(OUTDIR)\ftp.exe"
+	-@erase "$(OUTDIR)\ftp.ilk"
+	-@erase "$(OUTDIR)\ftp.pdb"
+	-@erase "$(OUTDIR)\ftp.pch"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /MLd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS"\
+ /Fp"$(INTDIR)\ftp.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c
+CPP_OBJS=.\Debug/
+CPP_SBRS=.
+
+.c{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cpp{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cxx{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.c{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cpp{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cxx{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+RSC=rc.exe
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\ftp.bsc"
+BSC32_SBRS= \
+
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib wsock32.lib /nologo /subsystem:console /incremental:yes\
+ /pdb:"$(OUTDIR)\ftp.pdb" /debug /machine:I386 /out:"$(OUTDIR)\ftp.exe"\
+ /pdbtype:sept
+LINK32_OBJS= \
+	"$(INTDIR)\cmds.obj" \
+	"$(INTDIR)\cmdtab.obj" \
+	"$(INTDIR)\domacro.obj" \
+	"$(INTDIR)\fake.obj" \
+	"$(INTDIR)\ftp.obj" \
+	"$(INTDIR)\main.obj" \
+	"$(INTDIR)\ruserpass.obj"
+
+"$(OUTDIR)\ftp.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Debug\ftp.exe
+InputPath=.\Debug\ftp.exe
+SOURCE=$(InputPath)
+
+!ENDIF
+
+
+!IF "$(CFG)" == "ftp - Win32 Release" || "$(CFG)" == "ftp - Win32 Debug"
+SOURCE=.\cmds.c
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+DEP_CPP_CMDS_=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\pathnames.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\cmds.obj" : $(SOURCE) $(DEP_CPP_CMDS_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+DEP_CPP_CMDS_=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\pathnames.h"\
+	".\prototypes.h"\
+	{$(INCLUDE)}"sys\stat.h"\
+	{$(INCLUDE)}"sys\types.h"\
+
+
+"$(INTDIR)\cmds.obj" : $(SOURCE) $(DEP_CPP_CMDS_) "$(INTDIR)"
+
+
+!ENDIF
+
+SOURCE=.\cmdtab.c
+DEP_CPP_CMDTA=\
+	".\fake.h"\
+	".\ftp_var.h"\
+
+
+"$(INTDIR)\cmdtab.obj" : $(SOURCE) $(DEP_CPP_CMDTA) "$(INTDIR)"
+
+
+SOURCE=.\domacro.c
+DEP_CPP_DOMAC=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\domacro.obj" : $(SOURCE) $(DEP_CPP_DOMAC) "$(INTDIR)"
+
+
+SOURCE=.\fake.c
+DEP_CPP_FAKE_=\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\fake.obj" : $(SOURCE) $(DEP_CPP_FAKE_) "$(INTDIR)"
+
+
+SOURCE=.\ftp.c
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+DEP_CPP_FTP_C=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\ftp.obj" : $(SOURCE) $(DEP_CPP_FTP_C) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+DEP_CPP_FTP_C=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+	{$(INCLUDE)}"sys\stat.h"\
+	{$(INCLUDE)}"sys\types.h"\
+
+
+"$(INTDIR)\ftp.obj" : $(SOURCE) $(DEP_CPP_FTP_C) "$(INTDIR)"
+
+
+!ENDIF
+
+SOURCE=.\main.c
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+DEP_CPP_MAIN_=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+DEP_CPP_MAIN_=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+	{$(INCLUDE)}"sys\types.h"\
+
+
+"$(INTDIR)\main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ENDIF
+
+SOURCE=.\ruserpass.c
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+DEP_CPP_RUSER=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\ruserpass.obj" : $(SOURCE) $(DEP_CPP_RUSER) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+DEP_CPP_RUSER=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+	{$(INCLUDE)}"sys\stat.h"\
+	{$(INCLUDE)}"sys\types.h"\
+
+
+"$(INTDIR)\ruserpass.obj" : $(SOURCE) $(DEP_CPP_RUSER) "$(INTDIR)"
+
+
+!ENDIF
+
+
+!ENDIF

apps/utils/net/ftp/ftp.mak.orig

@@ -0,0 +1,400 @@
+# Microsoft Developer Studio Generated NMAKE File, Based on ftp.dsp
+!IF "$(CFG)" == ""
+CFG=ftp - Win32 Debug
+!MESSAGE No configuration specified. Defaulting to ftp - Win32 Debug.
+!ENDIF
+
+!IF "$(CFG)" != "ftp - Win32 Release" && "$(CFG)" != "ftp - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "ftp.mak" CFG="ftp - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "ftp - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "ftp - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+!ERROR An invalid configuration is specified.
+!ENDIF
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE
+NULL=nul
+!ENDIF
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+OUTDIR=.\Release
+INTDIR=.\Release
+# Begin Custom Macros
+OutDir=.\Release
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0"
+
+ALL : "$(OUTDIR)\ftp.exe" "\emacs-19.34\bin\ftp.exe"
+
+!ELSE
+
+ALL : "$(OUTDIR)\ftp.exe" "\emacs-19.34\bin\ftp.exe"
+
+!ENDIF
+
+CLEAN :
+	-@erase "$(INTDIR)\cmds.obj"
+	-@erase "$(INTDIR)\cmdtab.obj"
+	-@erase "$(INTDIR)\domacro.obj"
+	-@erase "$(INTDIR)\fake.obj"
+	-@erase "$(INTDIR)\ftp.obj"
+	-@erase "$(INTDIR)\main.obj"
+	-@erase "$(INTDIR)\ruserpass.obj"
+	-@erase "$(INTDIR)\vc50.idb"
+	-@erase "$(OUTDIR)\ftp.exe"
+	-@erase "\emacs-19.34\bin\ftp.exe"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /ML /W3 /GX /O2 /I "C:\emacs-19.34\nt\inc" /I\
+ "C:\emacs-19.34\src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D\
+ "HAVE_TIMEVAL" /Fp"$(INTDIR)\ftp.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD\
+ /c
+CPP_OBJS=.\Release/
+CPP_SBRS=.
+
+.c{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cpp{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cxx{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.c{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cpp{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cxx{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+RSC=rc.exe
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\ftp.bsc"
+BSC32_SBRS= \
+
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:console /incremental:no\
+ /pdb:"$(OUTDIR)\ftp.pdb" /machine:I386 /out:"$(OUTDIR)\ftp.exe"
+LINK32_OBJS= \
+	"$(INTDIR)\cmds.obj" \
+	"$(INTDIR)\cmdtab.obj" \
+	"$(INTDIR)\domacro.obj" \
+	"$(INTDIR)\fake.obj" \
+	"$(INTDIR)\ftp.obj" \
+	"$(INTDIR)\main.obj" \
+	"$(INTDIR)\ruserpass.obj" \
+	"d:\Program Files\DevStudio\VC\lib\WSOCK32.LIB"
+
+"$(OUTDIR)\ftp.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Release\ftp.exe
+InputPath=.\Release\ftp.exe
+SOURCE=$(InputPath)
+
+"\emacs-19.34\bin\ftp.exe"	 : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+#	copy $(TargetPath) \emacs-19.34\bin
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+OUTDIR=.\Debug
+INTDIR=.\Debug
+# Begin Custom Macros
+OutDir=.\Debug
+# End Custom Macros
+
+!IF "$(RECURSE)" == "0"
+
+ALL : "$(OUTDIR)\ftp.exe" "\emacs-19.34\bin\ftp.exe"
+
+!ELSE
+
+ALL : "$(OUTDIR)\ftp.exe" "\emacs-19.34\bin\ftp.exe"
+
+!ENDIF
+
+CLEAN :
+	-@erase "$(INTDIR)\cmds.obj"
+	-@erase "$(INTDIR)\cmdtab.obj"
+	-@erase "$(INTDIR)\domacro.obj"
+	-@erase "$(INTDIR)\fake.obj"
+	-@erase "$(INTDIR)\ftp.obj"
+	-@erase "$(INTDIR)\main.obj"
+	-@erase "$(INTDIR)\ruserpass.obj"
+	-@erase "$(INTDIR)\vc50.idb"
+	-@erase "$(INTDIR)\vc50.pdb"
+	-@erase "$(OUTDIR)\ftp.exe"
+	-@erase "$(OUTDIR)\ftp.ilk"
+	-@erase "$(OUTDIR)\ftp.pdb"
+	-@erase "\emacs-19.34\bin\ftp.exe"
+
+"$(OUTDIR)" :
+    if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
+
+CPP=cl.exe
+CPP_PROJ=/nologo /MLd /W3 /Gm /GX /Zi /Od /I "C:\emacs-19.34\nt\inc" /I\
+ "C:\emacs-19.34\src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS"\
+ /Fp"$(INTDIR)\ftp.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c
+CPP_OBJS=.\Debug/
+CPP_SBRS=.
+
+.c{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cpp{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cxx{$(CPP_OBJS)}.obj::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.c{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cpp{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+.cxx{$(CPP_SBRS)}.sbr::
+   $(CPP) @<<
+   $(CPP_PROJ) $<
+<<
+
+RSC=rc.exe
+BSC32=bscmake.exe
+BSC32_FLAGS=/nologo /o"$(OUTDIR)\ftp.bsc"
+BSC32_SBRS= \
+
+LINK32=link.exe
+LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
+ advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib\
+ odbccp32.lib /nologo /subsystem:console /incremental:yes\
+ /pdb:"$(OUTDIR)\ftp.pdb" /debug /machine:I386 /out:"$(OUTDIR)\ftp.exe"\
+ /pdbtype:sept
+LINK32_OBJS= \
+	"$(INTDIR)\cmds.obj" \
+	"$(INTDIR)\cmdtab.obj" \
+	"$(INTDIR)\domacro.obj" \
+	"$(INTDIR)\fake.obj" \
+	"$(INTDIR)\ftp.obj" \
+	"$(INTDIR)\main.obj" \
+	"$(INTDIR)\ruserpass.obj" \
+	"d:\Program Files\DevStudio\VC\lib\WSOCK32.LIB"
+
+"$(OUTDIR)\ftp.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+    $(LINK32) @<<
+  $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+TargetPath=.\Debug\ftp.exe
+InputPath=.\Debug\ftp.exe
+SOURCE=$(InputPath)
+
+"\emacs-19.34\bin\ftp.exe"	 : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+#	copy $(TargetPath) \emacs-19.34\bin
+
+!ENDIF
+
+
+!IF "$(CFG)" == "ftp - Win32 Release" || "$(CFG)" == "ftp - Win32 Debug"
+SOURCE=.\cmds.c
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+DEP_CPP_CMDS_=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\pathnames.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\cmds.obj" : $(SOURCE) $(DEP_CPP_CMDS_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+DEP_CPP_CMDS_=\
+	"..\..\..\emacs-19.34\nt\inc\netdb.h"\
+	"..\..\..\emacs-19.34\nt\inc\netinet\in.h"\
+	"..\..\..\emacs-19.34\nt\inc\sys\socket.h"\
+	"..\..\..\emacs-19.34\src\nt.h"\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\pathnames.h"\
+	".\prototypes.h"\
+	{$(INCLUDE)}"sys\stat.h"\
+	{$(INCLUDE)}"sys\types.h"\
+
+
+"$(INTDIR)\cmds.obj" : $(SOURCE) $(DEP_CPP_CMDS_) "$(INTDIR)"
+
+
+!ENDIF
+
+SOURCE=.\cmdtab.c
+DEP_CPP_CMDTA=\
+	".\fake.h"\
+	".\ftp_var.h"\
+
+
+"$(INTDIR)\cmdtab.obj" : $(SOURCE) $(DEP_CPP_CMDTA) "$(INTDIR)"
+
+
+SOURCE=.\domacro.c
+DEP_CPP_DOMAC=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\domacro.obj" : $(SOURCE) $(DEP_CPP_DOMAC) "$(INTDIR)"
+
+
+SOURCE=.\fake.c
+DEP_CPP_FAKE_=\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\fake.obj" : $(SOURCE) $(DEP_CPP_FAKE_) "$(INTDIR)"
+
+
+SOURCE=.\ftp.c
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+DEP_CPP_FTP_C=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\ftp.obj" : $(SOURCE) $(DEP_CPP_FTP_C) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+DEP_CPP_FTP_C=\
+	"..\..\..\emacs-19.34\nt\inc\netdb.h"\
+	"..\..\..\emacs-19.34\nt\inc\netinet\in.h"\
+	"..\..\..\emacs-19.34\nt\inc\pwd.h"\
+	"..\..\..\emacs-19.34\nt\inc\sys\file.h"\
+	"..\..\..\emacs-19.34\nt\inc\sys\ioctl.h"\
+	"..\..\..\emacs-19.34\nt\inc\sys\param.h"\
+	"..\..\..\emacs-19.34\nt\inc\sys\socket.h"\
+	"..\..\..\emacs-19.34\nt\inc\sys\time.h"\
+	"..\..\..\emacs-19.34\src\nt.h"\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+	{$(INCLUDE)}"sys\stat.h"\
+	{$(INCLUDE)}"sys\types.h"\
+
+
+"$(INTDIR)\ftp.obj" : $(SOURCE) $(DEP_CPP_FTP_C) "$(INTDIR)"
+
+
+!ENDIF
+
+SOURCE=.\main.c
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+DEP_CPP_MAIN_=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+DEP_CPP_MAIN_=\
+	"..\..\..\emacs-19.34\nt\inc\netdb.h"\
+	"..\..\..\emacs-19.34\nt\inc\pwd.h"\
+	"..\..\..\emacs-19.34\nt\inc\sys\ioctl.h"\
+	"..\..\..\emacs-19.34\nt\inc\sys\socket.h"\
+	"..\..\..\emacs-19.34\src\nt.h"\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+	{$(INCLUDE)}"sys\types.h"\
+
+
+"$(INTDIR)\main.obj" : $(SOURCE) $(DEP_CPP_MAIN_) "$(INTDIR)"
+
+
+!ENDIF
+
+SOURCE=.\ruserpass.c
+
+!IF  "$(CFG)" == "ftp - Win32 Release"
+
+DEP_CPP_RUSER=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+
+
+"$(INTDIR)\ruserpass.obj" : $(SOURCE) $(DEP_CPP_RUSER) "$(INTDIR)"
+
+
+!ELSEIF  "$(CFG)" == "ftp - Win32 Debug"
+
+DEP_CPP_RUSER=\
+	".\fake.h"\
+	".\ftp_var.h"\
+	".\prototypes.h"\
+	{$(INCLUDE)}"sys\stat.h"\
+	{$(INCLUDE)}"sys\types.h"\
+
+
+"$(INTDIR)\ruserpass.obj" : $(SOURCE) $(DEP_CPP_RUSER) "$(INTDIR)"
+
+
+!ENDIF
+
+
+!ENDIF

apps/utils/net/ftp/ftp_var.h

@@ -1,10 +1,18 @@
-#include <winsock.h>
 #include "fake.h"
-#include "prototypes.h"
+#include <winsock.h>
 #include <setjmp.h>
 
 //typedef void (*Sig_t)(int);
 
+int fgetcSocket(int s);
+char *fputsSocket(char *format, int s);
+
+char *fprintfSocket(int s, char *format, ...);
+
+int fputcSocket(int s, char putChar);
+int fputSocket(int s, char *putChar, int len);
+char *fgetsSocket(int s, char *string);
+
 /* The following defines are from ftp.h and telnet.h from bsd.h */
 /* All relevent copyrights below apply.                         */
 
@@ -130,7 +138,7 @@ extern char	*stringbase;		/* current scan point in line buffer */
 extern char	argbuf[200];		/* argument storage buffer */
 extern char	*argbase;		/* current storage point in arg buffer */
 extern int	margc;			/* count of arguments on input line */
-extern const char	*margv[20];		/* args parsed from input line */
+extern char	*margv[20];		/* args parsed from input line */
 extern int     cpend;                  /* flag: if != 0, then pending server reply */
 extern int	mflag;			/* flag: if != 0, then active multi command */
 
@@ -140,12 +148,12 @@ extern int	options;		/* used during socket creation */
  * Format of command table.
  */
 struct cmd {
-	const char	*c_name;	/* name of command */
-	const char	*c_help;	/* help string */
+	char	*c_name;	/* name of command */
+	char	*c_help;	/* help string */
 	char	c_bell;		/* give bell when command completes */
 	char	c_conn;		/* must be connected to use command */
 	char	c_proxy;	/* proxy server may execute */
-	void	(*c_handler)();	/* function to call */
+	int	(*c_handler)();	/* function to call */
 };
 
 struct macel {
@@ -158,6 +166,11 @@ int macnum;			/* number of defined macros */
 struct macel macros[16];
 char macbuf[4096];
 
+extern	char *tail();
+extern	char *remglob();
+extern	int errno;
+extern	char *mktemp();
+
 #if	defined(__ANSI__) || defined(sparc)
 typedef void sig_t;
 #else
@@ -165,4 +178,4 @@ typedef int sig_t;
 #endif
 
 typedef int uid_t;
-
+int herror(char *s);

apps/utils/net/ftp/main.c

@@ -0,0 +1,602 @@
+/*
+ * Copyright (c) 1985, 1989 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1985, 1989 Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)main.c	based on 5.13 (Berkeley) 3/14/89";
+#endif /* not lint */
+
+/*
+ * FTP User Program -- Command Interface.
+ */
+#if !defined(WIN32)
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <arpa/ftp.h>
+#include <errno.h>
+#include <pwd.h>
+#endif
+#include "ftp_var.h"
+#include "prototypes.h"
+#include <sys/types.h>
+
+#include <io.h>
+#include <fcntl.h>
+
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+
+#if defined(sun) && !defined(FD_SET)
+typedef int uid_t;
+#endif
+
+uid_t	getuid();
+void	intr();
+void	lostpeer();
+char	*getlogin();
+
+short   portnum;
+
+char     home[128];
+char	*globerr;
+int     autologin;
+
+
+
+/* Lot's of options... */
+/*
+ * Options and other state info.
+ */
+int	trace;			/* trace packets exchanged */
+int	hash;			/* print # for each buffer transferred */
+int	sendport;		/* use PORT cmd for each data connection */
+int	verbose;		/* print messages coming back from server */
+int	connected;		/* connected to server */
+int	fromatty;		/* input is from a terminal */
+int	interactive;		/* interactively prompt on m* cmds */
+int	debug;			/* debugging level */
+int	bell;			/* ring bell on cmd completion */
+int	doglob;			/* glob local file names */
+int	proxy;			/* proxy server connection active */
+int passivemode;
+int	proxflag;		/* proxy connection exists */
+int	sunique;		/* store files on server with unique name */
+int	runique;		/* store local files with unique name */
+int	mcase;			/* map upper to lower case for mget names */
+int	ntflag;			/* use ntin ntout tables for name translation */
+int	mapflag;		/* use mapin mapout templates on file names */
+int	code;			/* return/reply code for ftp command */
+int	crflag;			/* if 1, strip car. rets. on ascii gets */
+char	pasv[64];		/* passive port for proxy data connection */
+char	*altarg;		/* argv[1] with no shell-like preprocessing  */
+char	ntin[17];		/* input translation table */
+char	ntout[17];		/* output translation table */
+// #include <sys/param.h>
+char	mapin[MAXPATHLEN];	/* input map template */
+char	mapout[MAXPATHLEN];	/* output map template */
+char	typename[32];		/* name of file transfer type */
+int	type;			/* file transfer type */
+char	structname[32];		/* name of file transfer structure */
+int	stru;			/* file transfer structure */
+char	formname[32];		/* name of file transfer format */
+int	form;			/* file transfer format */
+char	modename[32];		/* name of file transfer mode */
+int	mode;			/* file transfer mode */
+char	bytename[32];		/* local byte size in ascii */
+int	bytesize;		/* local byte size in binary */
+
+jmp_buf	toplevel;		/* non-local goto stuff for cmd scanner */
+
+char	line[200];		/* input line buffer */
+char	*stringbase;		/* current scan point in line buffer */
+char	argbuf[200];		/* argument storage buffer */
+char	*argbase;		/* current storage point in arg buffer */
+int	margc;			/* count of arguments on input line */
+char	*margv[20];		/* args parsed from input line */
+int     cpend;                  /* flag: if != 0, then pending server reply */
+int	mflag;			/* flag: if != 0, then active multi command */
+
+int	options;		/* used during socket creation */
+
+
+
+int main(int argc, char *argv[])
+{
+	register char *cp;
+	int top;
+	struct passwd *pw = NULL;
+#if 0
+	char homedir[MAXPATHLEN];
+#endif
+
+        int err;
+        WORD wVerReq;
+
+        WSADATA WSAData;
+        struct	servent *sp;		/* service spec for tcp/ftp */
+
+	/* Disable output buffering, for the benefit of Emacs.  */
+	//setbuf(stdout, NULL);
+
+        _fmode = O_BINARY; // This causes an error somewhere.
+
+        wVerReq = MAKEWORD(1,1);
+
+        err = WSAStartup(wVerReq, &WSAData);
+        if (err != 0)
+        {
+           fprintf(stderr, "Could not initialize Windows socket interface.");
+           exit(1);
+        }
+
+	sp = getservbyname("ftp", "tcp");
+	if (sp == 0) {
+		fprintf(stderr, "ftp: ftp/tcp: unknown service\n");
+		exit(1);
+	}
+
+        portnum = sp->s_port;
+
+
+	doglob = 1;
+	interactive = 1;
+	autologin = 1;
+	argc--, argv++;
+	while (argc > 0 && **argv == '-') {
+		for (cp = *argv + 1; *cp; cp++)
+			switch (*cp) {
+
+			case 'd':
+				options |= SO_DEBUG;
+				debug++;
+				break;
+
+			case 'v':
+				verbose++;
+				break;
+
+			case 't':
+				trace++;
+				break;
+
+			case 'i':
+				interactive = 0;
+				break;
+
+			case 'n':
+				autologin = 0;
+				break;
+
+			case 'g':
+				doglob = 0;
+				break;
+
+			default:
+				fprintf(stdout,
+				  "ftp: %c: unknown option\n", *cp);
+				exit(1);
+			}
+		argc--, argv++;
+	}
+//	fromatty = isatty(fileno(stdin));
+        fromatty = 1; // Strengthen this test
+	/*
+	 * Set up defaults for FTP.
+	 */
+	(void) strcpy(typename, "ascii"), type = TYPE_A;
+	(void) strcpy(formname, "non-print"), form = FORM_N;
+	(void) strcpy(modename, "stream"), mode = MODE_S;
+	(void) strcpy(structname, "file"), stru = STRU_F;
+	(void) strcpy(bytename, "8"), bytesize = 8;
+	if (fromatty)
+		verbose++;
+	cpend = 0;           /* no pending replies */
+	proxy = 0;	/* proxy not active */
+    passivemode = 1; /* passive mode *is* active */
+	crflag = 1;    /* strip c.r. on ascii gets */
+	/*
+	 * Set up the home directory in case we're globbing.
+	 */
+#if 0
+	cp = getlogin();
+	if (cp != NULL) {
+		pw = getpwnam(cp);
+	}
+	if (pw == NULL)
+		pw = getpwuid(getuid());
+	if (pw != NULL) {
+		home = homedir;
+		(void) strcpy(home, pw->pw_dir);
+	}
+#endif
+        strcpy(home, "C:/");
+	if (argc > 0) {
+		if (setjmp(toplevel))
+			exit(0);
+//		(void) signal(SIGINT, intr);
+//		(void) signal(SIGPIPE, lostpeer);
+		setpeer(argc + 1, argv - 1);
+	}
+	top = setjmp(toplevel) == 0;
+	if (top) {
+//		(void) signal(SIGINT, intr);
+//		(void) signal(SIGPIPE, lostpeer);
+	}
+	for (;;) {
+		cmdscanner(top);
+		top = 1;
+	}
+}
+
+void
+intr()
+{
+
+	longjmp(toplevel, 1);
+}
+
+void lostpeer(void)
+{
+   extern int cout;
+   extern int data;
+
+   if (connected) {
+      if (cout != (int) NULL) {
+         closesocket(cout);
+         cout = (int) NULL;
+      }
+      if (data >= 0) {
+         (void) shutdown(data, 1+1);
+         (void) close(data);
+         data = -1;
+      }
+      connected = 0;
+   }
+   pswitch(1);
+   if (connected) {
+      if (cout != (int)NULL) {
+						closesocket(cout);
+         cout = (int) NULL;
+      }
+      connected = 0;
+   }
+   proxflag = 0;
+   pswitch(0);
+}
+
+/*char *
+tail(filename)
+	char *filename;
+{
+	register char *s;
+
+	while (*filename) {
+		s = rindex(filename, '/');
+		if (s == NULL)
+			break;
+		if (s[1])
+			return (s + 1);
+		*s = '\0';
+	}
+	return (filename);
+}
+*/
+/*
+ * Command parser.
+ */
+void cmdscanner(top)
+	int top;
+{
+	register struct cmd *c;
+	struct cmd *getcmd();
+	extern int help();
+
+	if (!top)
+		(void) putchar('\n');
+	for (;;) {
+		(void) fflush(stdout);
+		if (fromatty) {
+			printf("ftp> ");
+			(void) fflush(stdout);
+		}
+		if (gets(line) == 0) {
+			if (feof(stdin) || ferror(stdin))
+				quit();
+			break;
+		}
+		if (line[0] == 0)
+			break;
+		makeargv();
+		if (margc == 0) {
+			continue;
+		}
+		c = getcmd(margv[0]);
+		if (c == (struct cmd *)-1) {
+			printf("?Ambiguous command\n");
+			continue;
+		}
+		if (c == 0) {
+			printf("?Invalid command\n");
+			continue;
+		}
+		if (c->c_conn && !connected) {
+			printf ("Not connected.\n");
+			continue;
+		}
+		(*c->c_handler)(margc, margv);
+		if (bell && c->c_bell)
+			(void) putchar('\007');
+		if (c->c_handler != help)
+			break;
+	}
+	(void) fflush(stdout);
+//	(void) signal(SIGINT, intr);
+//	(void) signal(SIGPIPE, lostpeer);
+}
+
+struct cmd *
+getcmd(name)
+	register char *name;
+{
+	extern struct cmd cmdtab[];
+	register char *p, *q;
+	register struct cmd *c, *found;
+	register int nmatches, longest;
+
+	longest = 0;
+	nmatches = 0;
+	found = 0;
+	for (c = cmdtab; p = c->c_name; c++) {
+		for (q = name; *q == *p++; q++)
+			if (*q == 0)		/* exact match? */
+				return (c);
+		if (!*q) {			/* the name was a prefix */
+			if (q - name > longest) {
+				longest = q - name;
+				nmatches = 1;
+				found = c;
+			} else if (q - name == longest)
+				nmatches++;
+		}
+	}
+	if (nmatches > 1)
+		return ((struct cmd *)-1);
+	return (found);
+}
+
+/*
+ * Slice a string up into argc/argv.
+ */
+
+int slrflag;
+
+void makeargv()
+{
+	char **argp;
+	char *slurpstring();
+
+	margc = 0;
+	argp = margv;
+	stringbase = line;		/* scan from first of buffer */
+	argbase = argbuf;		/* store from first of buffer */
+	slrflag = 0;
+	while (*argp++ = slurpstring())
+		margc++;
+}
+
+/*
+ * Parse string into argbuf;
+ * implemented with FSM to
+ * handle quoting and strings
+ */
+char *
+slurpstring()
+{
+	int got_one = 0;
+	register char *sb = stringbase;
+	register char *ap = argbase;
+	char *tmp = argbase;		/* will return this if token found */
+
+	if (*sb == '!' || *sb == '$') {	/* recognize ! as a token for shell */
+		switch (slrflag) {	/* and $ as token for macro invoke */
+			case 0:
+				slrflag++;
+				stringbase++;
+				return ((*sb == '!') ? "!" : "$");
+				/* NOTREACHED */
+			case 1:
+				slrflag++;
+				altarg = stringbase;
+				break;
+			default:
+				break;
+		}
+	}
+
+S0:
+	switch (*sb) {
+
+	case '\0':
+		goto OUT1;
+
+	case ' ':
+	case '\t':
+		sb++; goto S0;
+
+	default:
+		switch (slrflag) {
+			case 0:
+				slrflag++;
+				break;
+			case 1:
+				slrflag++;
+				altarg = sb;
+				break;
+			default:
+				break;
+		}
+		goto S1;
+	}
+
+S1:
+	switch (*sb) {
+
+	case ' ':
+	case '\t':
+	case '\0':
+		goto OUT1;	/* end of token */
+
+	case '\\':
+		sb++; goto S2;	/* slurp next character */
+
+	case '"':
+		sb++; goto S3;	/* slurp quoted string */
+
+	default:
+		*ap++ = *sb++;	/* add character to token */
+		got_one = 1;
+		goto S1;
+	}
+
+S2:
+	switch (*sb) {
+
+	case '\0':
+		goto OUT1;
+
+	default:
+		*ap++ = *sb++;
+		got_one = 1;
+		goto S1;
+	}
+
+S3:
+	switch (*sb) {
+
+	case '\0':
+		goto OUT1;
+
+	case '"':
+		sb++; goto S1;
+
+	default:
+		*ap++ = *sb++;
+		got_one = 1;
+		goto S3;
+	}
+
+OUT1:
+	if (got_one)
+		*ap++ = '\0';
+	argbase = ap;			/* update storage pointer */
+	stringbase = sb;		/* update scan pointer */
+	if (got_one) {
+		return(tmp);
+	}
+	switch (slrflag) {
+		case 0:
+			slrflag++;
+			break;
+		case 1:
+			slrflag++;
+			altarg = (char *) 0;
+			break;
+		default:
+			break;
+	}
+	return((char *)0);
+}
+
+#define HELPINDENT (sizeof ("directory"))
+
+/*
+ * Help command.
+ * Call each command handler with argc == 0 and argv[0] == name.
+ */
+int help(argc, argv)
+	int argc;
+	char *argv[];
+{
+	extern struct cmd cmdtab[];
+	register struct cmd *c;
+
+	if (argc == 1) {
+		register int i, j, w, k;
+		int columns, width = 0, lines;
+		extern int NCMDS;
+
+		printf("Commands may be abbreviated.  Commands are:\n\n");
+		for (c = cmdtab; c < &cmdtab[NCMDS]; c++) {
+			int len = strlen(c->c_name);
+
+			if (len > width)
+				width = len;
+		}
+		width = (width + 8) &~ 7;
+		columns = 80 / width;
+		if (columns == 0)
+			columns = 1;
+		lines = (NCMDS + columns - 1) / columns;
+		for (i = 0; i < lines; i++) {
+			for (j = 0; j < columns; j++) {
+				c = cmdtab + j * lines + i;
+				if (c->c_name && (!proxy || c->c_proxy)) {
+					printf("%s", c->c_name);
+				}
+				else if (c->c_name) {
+					for (k=0; k < (int) strlen(c->c_name); k++) {
+						(void) putchar(' ');
+					}
+				}
+				if (c + lines >= &cmdtab[NCMDS]) {
+					printf("\n");
+					break;
+				}
+				w = strlen(c->c_name);
+				while (w < width) {
+					w = (w + 8) &~ 7;
+					(void) putchar('\t');
+				}
+			}
+		}
+		(void) fflush(stdout);
+		return 0;
+	}
+	while (--argc > 0) {
+		register char *arg;
+		arg = *++argv;
+		c = getcmd(arg);
+		if (c == (struct cmd *)-1)
+			printf("?Ambiguous help command %s\n", arg);
+		else if (c == (struct cmd *)0)
+			printf("?Invalid help command %s\n", arg);
+		else
+			printf("%-*s\t%s\n", HELPINDENT,
+				c->c_name, c->c_help);
+	}
+	(void) fflush(stdout);
+	return 0;
+}

apps/utils/net/ftp/makefile

@@ -0,0 +1,27 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = ftp
+
+TARGET_INSTALLDIR = system32
+
+TARGET_SDKLIBS = ws2_32.a iphlpapi.a
+# ntdll.a
+
+TARGET_OBJECTS = \
+	cmds.o \
+	cmdtab.o \
+	domacro.o \
+	fake.o \
+	ftp.o \
+	main.o \
+	ruserpass.o
+
+TARGET_GCCLIBS = 
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk

apps/utils/net/ftp/prototypes.h

@@ -0,0 +1,32 @@
+
+int getreply(int expecteof);
+int ruserpass(char *host, char **aname, char **apass, char **aacct);
+char *getpass(const char *prompt);
+void makeargv(void);
+void domacro(int argc, char *argv[]);
+void proxtrans(char *cmd, char *local, char *remote);
+int null(void);
+int initconn(void);
+void disconnect(void);
+void ptransfer(char *direction, long bytes, struct timeval *t0, struct timeval *t1);
+void setascii(void);
+void setbinary(void);
+void setebcdic(void);
+void settenex(void);
+void tvsub(struct timeval *tdiff, struct timeval *t1, struct timeval *t0);
+void setpassive(int argc, char *argv[]);
+void setpeer(int argc, char *argv[]);
+void cmdscanner(int top);
+void pswitch(int flag);
+void quit(void);
+int login(char *host);
+int command(char *fmt, ...);
+int globulize(char **cpp);
+void sendrequest(char *cmd, char *local, char *remote, int printnames);
+void recvrequest(char *cmd, char *local, char *remote, char *mode,
+                int printnames);
+int confirm(char *cmd, char *file);
+void blkfree(char **av0);
+int getit(int argc, char *argv[], int restartit, char *mode);
+static int token(void);
+int sleep(int time);

apps/utils/net/ftp/ruserpass.c

@@ -50,27 +50,25 @@ static	FILE *cfile;
 static char tokval[100];
 
 static struct toktab {
-	const char *tokstr;
+	char *tokstr;
 	int tval;
 } toktab[]= {
-	{"default",	DEFAULT},
-	{"login",	LOGIN},
-	{"password",	PASSWD},
-	{"passwd",	PASSWD},
-	{"account",	ACCOUNT},
-	{"machine",	MACH},
-	{"macdef",	MACDEF},
-	{0,		0}
+	"default",	DEFAULT,
+	"login",	LOGIN,
+	"password",	PASSWD,
+	"passwd",	PASSWD,
+	"account",	ACCOUNT,
+	"machine",	MACH,
+	"macdef",	MACDEF,
+	0,		0
 };
 
 extern char *hostname;
-static int token(void);
 
-int ruserpass(const char *host, char **aname, char **apass, char **aacct)
+int ruserpass(char *host, char **aname, char **apass, char **aacct)
 {
-	const char *hdir, *mydomain;
-    char buf[BUFSIZ], *tmp;
-	char myname[MAXHOSTNAMELEN];
+	char *hdir, buf[BUFSIZ], *tmp;
+	char myname[MAXHOSTNAMELEN], *mydomain;
 	int t, i, c, usedefault = 0;
 	struct stat stb;
 	extern int errno;
@@ -127,15 +125,14 @@ next:
 		while ((t = token()) && t != MACH && t != DEFAULT) switch(t) {
 
 		case LOGIN:
-			if (token()) {
-				if (*aname == 0) {
+			if (token())
+				if (*aname == 0) { 
 					*aname = malloc((unsigned) strlen(tokval) + 1);
 					(void) strcpy(*aname, tokval);
 				} else {
 					if (strcmp(*aname, tokval))
 						goto next;
 				}
-			}
 			break;
 		case PASSWD:
 			if (strcmp(*aname, "anonymous") &&
@@ -167,7 +164,7 @@ next:
 				(void) fclose(cfile);
 				return(0);
 			}
-			while ((c=getc(cfile)) != EOF && (c == ' ' || c == '\t'));
+			while ((c=getc(cfile)) != EOF && c == ' ' || c == '\t');
 			if (c == EOF || c == '\n') {
 				printf("Missing macdef name argument.\n");
 				goto bad;
@@ -240,7 +237,7 @@ static int token(void)
    char *cp;
    int c;
    struct toktab *t;
-
+   
    if (feof(cfile))
       return (0);
    while ((c = getc(cfile)) != EOF &&

apps/utils/net/ipconfig/ipconfig.c

@@ -0,0 +1,299 @@
+/*
+ * ipconfig - display IP stack parameters.
+ *
+ * This source code is in the PUBLIC DOMAIN and has NO WARRANTY.
+ *
+ * Robert Dickenson <robd@reactos.org>, August 15, 2002.
+ */
+#include <stdio.h>
+#include <windows.h>
+#include <tchar.h>
+#include <time.h>
+
+#include <iptypes.h>
+#include <ipexport.h>
+#include <iphlpapi.h>
+
+#ifdef _DEBUG
+#include "trace.h"
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+/* imported from iphlpapi.dll
+
+GetAdapterOrderMap
+GetInterfaceInfo
+GetIpStatsFromStack
+NhGetInterfaceNameFromGuid
+NhpAllocateAndGetInterfaceInfoFromStack
+
+ */
+
+static TCHAR* GetNodeTypeName(int nNodeType)
+{
+    switch (nNodeType) {
+    case 0:  return _T("zero");
+    case 1:  return _T("one");
+    case 2:  return _T("two");
+    case 3:  return _T("three");
+    case 4:  return _T("mixed");
+    default: return _T("unknown");
+    }
+}
+
+static void ShowNetworkFixedInfo()
+{
+    FIXED_INFO* pFixedInfo = NULL;
+    ULONG OutBufLen = 0;
+    DWORD result;
+
+    result = GetNetworkParams(NULL, &OutBufLen);
+    if (result == ERROR_BUFFER_OVERFLOW) {
+        pFixedInfo = (FIXED_INFO*)malloc(OutBufLen);
+        if (!pFixedInfo) {
+            _tprintf(_T("ERROR: failed to allocate 0x%08X bytes of memory\n"), OutBufLen);
+            return;
+        }
+    } else {
+        _tprintf(_T("ERROR: GetNetworkParams() failed to report required buffer size.\n"));
+        return;
+    }
+
+    result = GetNetworkParams(pFixedInfo, &OutBufLen);
+    if (result == ERROR_SUCCESS) {
+        IP_ADDR_STRING* pIPAddr;
+
+             printf("\tHostName. . . . . . . . . . . : %s\n",  pFixedInfo->HostName);
+             printf("\tDomainName. . . . . . . . . . : %s\n",  pFixedInfo->DomainName);
+//
+             printf("\tDNS Servers . . . . . . . . . : %s\n",  pFixedInfo->DnsServerList.IpAddress.String);
+             pIPAddr = pFixedInfo->DnsServerList.Next;
+             while (pIPAddr) {
+                 printf("\t\t\t\t      : %s\n",  pIPAddr->IpAddress.String);
+                 pIPAddr = pIPAddr->Next;
+             }
+//
+        _tprintf(_T("\tNodeType. . . . . . . . . . . : %d (%s)\n"), pFixedInfo->NodeType, GetNodeTypeName(pFixedInfo->NodeType));
+             printf("\tScopeId . . . . . . . . . . . : %s\n",  pFixedInfo->ScopeId);
+        _tprintf(_T("\tEnableRouting . . . . . . . . : %s\n"), pFixedInfo->EnableRouting ? _T("yes") : _T("no"));
+        _tprintf(_T("\tEnableProxy . . . . . . . . . : %s\n"), pFixedInfo->EnableProxy ? _T("yes") : _T("no"));
+        _tprintf(_T("\tEnableDns . . . . . . . . . . : %s\n"), pFixedInfo->EnableDns ? _T("yes") : _T("no"));
+        _tprintf(_T("\n"));
+        //_tprintf(_T("\n"),);
+        //_tprintf(_T("GetNetworkParams() returned with %d\n"), pIfTable->NumAdapters);
+
+//      _tprintf(_T("\tConnection specific DNS suffix: %s\n"), pFixedInfo->EnableDns ? _T("yes") : _T("no"));
+
+    } else {
+        switch (result) {
+        case ERROR_BUFFER_OVERFLOW:
+            _tprintf(_T("The buffer size indicated by the pOutBufLen parameter is too small to hold the adapter information. The pOutBufLen parameter points to the required size\n"));
+            break;
+        case ERROR_INVALID_PARAMETER:
+            _tprintf(_T("The pOutBufLen parameter is NULL, or the calling process does not have read/write access to the memory pointed to by pOutBufLen, or the calling process does not have write access to the memory pointed to by the pAdapterInfo parameter\n"));
+            break;
+        case ERROR_NO_DATA:
+            _tprintf(_T("No adapter information exists for the local computer\n"));
+            break;
+        case ERROR_NOT_SUPPORTED:
+            _tprintf(_T("This function is not supported on the operating system in use on the local system\n"));
+            break;
+        default:
+            _tprintf(_T("0x%08X - Use FormatMessage to obtain the message string for the returned error\n"), result);
+            break;
+        }
+    }
+}
+
+static void ShowNetworkInterfaces()
+{
+    IP_INTERFACE_INFO* pIfTable = NULL;
+    DWORD result;
+    DWORD dwNumIf;
+    DWORD dwOutBufLen = 0;
+
+    if ((result = GetNumberOfInterfaces(&dwNumIf)) != NO_ERROR) {
+        _tprintf(_T("GetNumberOfInterfaces() failed with code 0x%08X - Use FormatMessage to obtain the message string for the returned error\n"), result);
+        return;
+    } else {
+        _tprintf(_T("GetNumberOfInterfaces() returned %d\n"), dwNumIf);
+    }
+
+    result = GetInterfaceInfo(pIfTable, &dwOutBufLen);
+//    dwOutBufLen = sizeof(IP_INTERFACE_INFO) + dwNumIf * sizeof(IP_ADAPTER_INDEX_MAP);
+//    _tprintf(_T("GetNumberOfInterfaces() returned %d, dwOutBufLen %d\n"), dwNumIf, dwOutBufLen);
+//    _tprintf(_T("sizeof(IP_INTERFACE_INFO) %d, sizeof(IP_ADAPTER_INDEX_MAP) %d\n"), sizeof(IP_INTERFACE_INFO), sizeof(IP_ADAPTER_INDEX_MAP));
+
+    pIfTable = (IP_INTERFACE_INFO*)malloc(dwOutBufLen);
+    if (!pIfTable) {
+        _tprintf(_T("ERROR: failed to allocate 0x%08X bytes of memory\n"), dwOutBufLen);
+        return;
+    }
+/*
+typedef struct _IP_ADAPTER_INDEX_MAP {
+  ULONG Index;                     // adapter index 
+  WCHAR Name[MAX_ADAPTER_NAME];    // name of the adapter 
+} IP_ADAPTER_INDEX_MAP, * PIP_ADAPTER_INDEX_MAP;
+
+typedef struct _IP_INTERFACE_INFO {
+  LONG NumAdapters;                 // number of adapters in array 
+  IP_ADAPTER_INDEX_MAP Adapter[1];  // adapter indices and names 
+} IP_INTERFACE_INFO,*PIP_INTERFACE_INFO;
+ */
+    result = GetInterfaceInfo(pIfTable, &dwOutBufLen);
+    if (result == NO_ERROR) {
+        int i;
+        _tprintf(_T("GetInterfaceInfo() returned with %d adaptor entries\n"), pIfTable->NumAdapters);
+        for (i = 0; i < pIfTable->NumAdapters; i++) {
+           wprintf(L"[%d] %s\n", i + 1, pIfTable->Adapter[i].Name);
+           //wprintf(L"[%d] %s\n", pIfTable->Adapter[i].Index, pIfTable->Adapter[i].Name);
+
+//  \DEVICE\TCPIP_{DB0E61C1-3498-4C5F-B599-59CDE8A1E357}
+//  \DEVICE\TCPIP_{BD445697-0945-4591-AE7F-2AB0F383CA87}
+//  \DEVICE\TCPIP_{6D87DC08-6BC5-4E78-AB5F-18CAB785CFFE}
+
+//HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\NetBT\Parameters\Interfaces\Tcpip_{DB0E61C1-3498-4C5F-B599-59CDE8A1E357}
+        }
+    } else {
+        switch (result) {
+        case ERROR_INVALID_PARAMETER:
+            _tprintf(_T("The dwOutBufLen parameter is NULL, or GetInterfaceInterface is unable to write to the memory pointed to by the dwOutBufLen parameter\n"));
+            break;
+        case ERROR_INSUFFICIENT_BUFFER:
+            _tprintf(_T("The buffer pointed to by the pIfTable parameter is not large enough. The required size is returned in the DWORD variable pointed to by the dwOutBufLen parameter\n"));
+            _tprintf(_T("\tdwOutBufLen: %d\n"), dwOutBufLen);
+            break;
+        case ERROR_NOT_SUPPORTED:
+            _tprintf(_T("This function is not supported on the operating system in use on the local system\n"));
+            break;
+        default:
+            _tprintf(_T("0x%08X - Use FormatMessage to obtain the message string for the returned error\n"), result);
+            break;
+        }
+    }
+    free(pIfTable);
+}
+
+/*
+typedef struct _IP_ADAPTER_INFO {
+  struct _IP_ADAPTER_INFO* Next;
+  DWORD ComboIndex;
+  char AdapterName[MAX_ADAPTER_NAME_LENGTH + 4];
+1  char Description[MAX_ADAPTER_DESCRIPTION_LENGTH + 4];
+  UINT AddressLength;
+2  BYTE Address[MAX_ADAPTER_ADDRESS_LENGTH];
+  DWORD Index;
+  UINT Type;
+3  UINT DhcpEnabled;
+5  PIP_ADDR_STRING CurrentIpAddress;
+  IP_ADDR_STRING IpAddressList;
+7  IP_ADDR_STRING GatewayList;
+8  IP_ADDR_STRING DhcpServer;
+  BOOL HaveWins;
+  IP_ADDR_STRING PrimaryWinsServer;
+  IP_ADDR_STRING SecondaryWinsServer;
+a  time_t LeaseObtained;
+b  time_t LeaseExpires; 
+} IP_ADAPTER_INFO, *PIP_ADAPTER_INFO;
+ */
+/*
+Ethernet adapter VMware Virtual Ethernet Adapter (Network Address Translation (NAT) for VMnet8):
+
+        Connection-specific DNS Suffix  . :
+1        Description . . . . . . . . . . . : VMware Virtual Ethernet Adapter (Network Address Translation (NAT) for VMnet8)
+2        Physical Address. . . . . . . . . : 00-50-56-C0-00-08
+3        DHCP Enabled. . . . . . . . . . . : Yes
+        Autoconfiguration Enabled . . . . : Yes
+5        IP Address. . . . . . . . . . . . : 192.168.136.1
+        Subnet Mask . . . . . . . . . . . : 255.255.255.0
+7        Default Gateway . . . . . . . . . :
+8        DHCP Server . . . . . . . . . . . : 192.168.136.254
+        DNS Servers . . . . . . . . . . . :
+a        Lease Obtained. . . . . . . . . . : Monday, 30 December 2002 5:56:53 PM
+b        Lease Expires . . . . . . . . . . : Monday, 30 December 2002 6:26:53 PM
+ */
+static void ShowAdapterInfo()
+{
+    IP_ADAPTER_INFO* pAdaptorInfo;
+    ULONG ulOutBufLen;
+    DWORD dwRetVal;
+
+    _tprintf(_T("\nAdaptor Information\t\n"));
+    pAdaptorInfo = (IP_ADAPTER_INFO*)GlobalAlloc(GPTR, sizeof(IP_ADAPTER_INFO));
+    ulOutBufLen = sizeof(IP_ADAPTER_INFO);
+
+    if (ERROR_BUFFER_OVERFLOW == GetAdaptersInfo(pAdaptorInfo, &ulOutBufLen)) {
+        GlobalFree(pAdaptorInfo);
+        pAdaptorInfo = (IP_ADAPTER_INFO*)GlobalAlloc(GPTR, ulOutBufLen);
+    }
+    if (dwRetVal = GetAdaptersInfo(pAdaptorInfo, &ulOutBufLen)) {
+        _tprintf(_T("Call to GetAdaptersInfo failed. Return Value: %08x\n"), dwRetVal);
+    } else {
+        while (pAdaptorInfo) {
+            printf("  AdapterName: %s\n", pAdaptorInfo->AdapterName);
+            printf("  Description: %s\n", pAdaptorInfo->Description);
+            pAdaptorInfo = pAdaptorInfo->Next;
+        }
+    }
+}
+
+const char szUsage[] = { "USAGE:\n" \
+    "   ipconfig [/? | /all | /release [adapter] | /renew [adapter]\n" \
+    "            | /flushdns | /registerdns\n" \
+    "            | /showclassid adapter\n" \
+    "            | /showclassid adapter\n" \
+    "            | /setclassid adapter [classidtoset] ]\n" \
+    "\n" \
+    "adapter    Full name or pattern with '*' and '?' to 'match',\n" \
+    "           * matches any character, ? matches one character.\n" \
+    "   Options\n" \
+    "       /?           Display this help message.\n" \
+    "       /all         Display full configuration information.\n" \
+    "       /release     Release the IP address for the specified adapter.\n" \
+    "       /renew       Renew the IP address for the specified adapter.\n" \
+    "       /flushdns    Purges the DNS Resolver cache.\n" \
+    "       /registerdns Refreshes all DHCP leases and re-registers DNS names\n" \
+    "       /displaydns  Display the contents of the DNS Resolver Cache.\n" \
+    "       /showclassid Displays all the dhcp class IDs allowed for adapter.\n" \
+    "       /setclassid  Modifies the dhcp class id.\n" \
+    "\n" \
+    "The default is to display only the IP address, subnet mask and\n" \
+    "default gateway for each adapter bound to TCP/IP.\n"
+};
+/*
+    "\n" \
+    "For Release and Renew, if no adapter name is specified, then the IP address\n" \
+    "leases for all adapters bound to TCP/IP will be released or renewed.\n" \
+    "\n" \
+    "For SetClassID, if no class id is specified, then the classid is removed.\n" \
+    "\n" \
+    "Examples:\n" \
+    "    > ipconfig                       ... Show information.\n" \
+    "    > ipconfig /all                  ... Show detailed information\n" \
+    "    > ipconfig /renew                ... renew all adapaters\n" \
+    "    > ipconfig /renew EL*            ... renew adapters named EL....\n" \
+    "    > ipconfig /release *ELINK?21*   ... release all matching adapters,\n" \
+                                         eg. ELINK-21, myELELINKi21adapter.\n"
+ */
+
+static void usage(void)
+{
+	fputs(szUsage, stderr);
+}
+
+
+int main(int argc, char *argv[])
+{
+    // 10.0.0.100    // As of build 0.0.20 this is hardcoded in the ip stack
+
+    if (argc > 1) {
+        usage();
+        return 1;
+    }
+    _tprintf(_T("ReactOS IP Configuration\n"));
+    ShowNetworkFixedInfo();
+    ShowNetworkInterfaces();
+    ShowAdapterInfo();
+	return 0;
+}

apps/utils/net/ipconfig/ipconfig.rc

@@ -0,0 +1,6 @@
+/* $Id$ */
+
+#define REACTOS_STR_FILE_DESCRIPTION	"ReactOS TCP/IPv4 Win32 ipconfig\0"
+#define REACTOS_STR_INTERNAL_NAME	"ipconfig\0"
+#define REACTOS_STR_ORIGINAL_FILENAME	"ipconfig.exe\0"
+#include <reactos/version.rc>

apps/utils/net/ipconfig/makefile

@@ -0,0 +1,19 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = ipconfig
+
+TARGET_INSTALLDIR = system32
+
+TARGET_CFLAGS = -D__USE_W32API
+
+TARGET_SDKLIBS = user32.a iphlpapi.a
+
+TARGET_OBJECTS = $(TARGET_NAME).o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk

apps/utils/net/ipconfig/trace.c

@@ -0,0 +1,53 @@
+/////////////////////////////////////////////////////////////////////////////
+// Diagnostic Trace
+//
+#include <stdio.h> 
+#include <stdarg.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <tchar.h>
+#include "trace.h"
+
+
+#ifdef _DEBUG
+
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+
+void _DebugBreak(void)
+{
+    DebugBreak();
+}
+
+void Trace(TCHAR* lpszFormat, ...)
+{
+    va_list args;
+    int nBuf;
+    TCHAR szBuffer[512];
+
+    va_start(args, lpszFormat);
+    nBuf = _vsntprintf(szBuffer, sizeof(szBuffer)/sizeof(TCHAR), lpszFormat, args);
+    OutputDebugString(szBuffer);
+    // was there an error? was the expanded string too long?
+    //ASSERT(nBuf >= 0);
+    va_end(args);
+}
+
+void Assert(void* assert, TCHAR* file, int line, void* msg)
+{
+    if (msg == NULL) {
+        printf("ASSERT -- %s occured on line %u of file %s.\n",
+               assert, line, file);
+    } else {
+        printf("ASSERT -- %s occured on line %u of file %s: Message = %s.\n",
+               assert, line, file, msg);
+    }
+}
+
+#else
+
+void Trace(TCHAR* lpszFormat, ...) { };
+void Assert(void* assert, TCHAR* file, int line, void* msg) { };
+
+#endif //_DEBUG
+/////////////////////////////////////////////////////////////////////////////

apps/utils/net/ipconfig/trace.h

@@ -0,0 +1,61 @@
+/////////////////////////////////////////////////////////////////////////////
+// Diagnostic Trace
+//
+#ifndef __TRACE_H__
+#define __TRACE_H__
+
+#ifdef _DEBUG
+
+#ifdef _X86_
+#define BreakPoint()        _asm { int 3h }
+#else
+#define BreakPoint()        _DebugBreak()
+#endif
+
+#ifndef ASSERT
+#define ASSERT(exp)                                 \
+{                                                   \
+    if (!(exp)) {                                   \
+        Assert(#exp, __FILE__, __LINE__, NULL);     \
+        BreakPoint();                               \
+    }                                               \
+}                                                   \
+
+#define ASSERTMSG(exp, msg)                         \
+{                                                   \
+    if (!(exp)) {                                   \
+        Assert(#exp, __FILE__, __LINE__, msg);      \
+        BreakPoint();                               \
+    }                                               \
+}
+#endif
+
+//=============================================================================
+//  MACRO: TRACE()
+//=============================================================================
+
+#define TRACE  Trace
+
+
+#else   // _DEBUG
+
+//=============================================================================
+//  Define away MACRO's ASSERT() and TRACE() in non debug builds
+//=============================================================================
+
+#ifndef ASSERT
+#define ASSERT(exp)
+#define ASSERTMSG(exp, msg)
+#endif
+
+#define TRACE 0 ? (void)0 : Trace
+
+#endif // !_DEBUG
+
+
+void Assert(void* assert, TCHAR* file, int line, void* msg);
+void Trace(TCHAR* lpszFormat, ...);
+
+
+#endif // __TRACE_H__
+/////////////////////////////////////////////////////////////////////////////

apps/utils/net/netstat/makefile

@@ -0,0 +1,22 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = netstat
+
+TARGET_INSTALLDIR = system32
+
+TARGET_CFLAGS = \
+	-D__USE_W32API \
+	-D_WIN32_IE=0x600 \
+	-D_WIN32_WINNT=0x501 
+
+TARGET_SDKLIBS = user32.a snmpapi.a iphlpapi.a ws2_32.a
+
+TARGET_OBJECTS = $(TARGET_NAME).o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk

apps/utils/net/netstat/netstat.c

@@ -0,0 +1,518 @@
+/*
+ * netstat - display IP stack statistics.
+ *
+ * This source code is in the PUBLIC DOMAIN and has NO WARRANTY.
+ *
+ * Robert Dickenson <robd@reactos.org>, August 15, 2002.
+ */
+
+// Extensive reference made and use of source to netstatp by:
+// Copyright (C) 1998-2002 Mark Russinovich
+// www.sysinternals.com
+
+#define ANY_SIZE 1
+
+#include <windows.h>
+#include <winsock.h>
+#include <tchar.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <iptypes.h>
+#include <ipexport.h>
+#include <tlhelp32.h>
+#include <iphlpapi.h>
+#include <snmp.h>
+
+#include "trace.h"
+#include "resource.h"
+
+
+#define MAX_RESLEN 4000
+
+//
+// Possible TCP endpoint states
+//
+static char TcpState[][32] = {
+	"???",
+	"CLOSED",
+	"LISTENING",
+	"SYN_SENT",
+	"SYN_RCVD",
+	"ESTABLISHED",
+	"FIN_WAIT1",
+	"FIN_WAIT2",
+	"CLOSE_WAIT",
+	"CLOSING",
+	"LAST_ACK",
+	"TIME_WAIT",
+	"DELETE_TCB"
+};
+
+VOID PrintError(DWORD ErrorCode)
+{
+	LPVOID lpMsgBuf;
+ 
+	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+				  NULL, ErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+				  (LPTSTR)&lpMsgBuf, 0, NULL);
+	printf("%s\n", lpMsgBuf);
+	LocalFree(lpMsgBuf);
+}
+
+static void ShowTcpStatistics()
+{
+    MIB_TCPSTATS TcpStatsMIB;
+    GetTcpStatistics(&TcpStatsMIB);
+
+    _tprintf(_T("TCP/IP Statistics\t\n"));
+    _tprintf(_T("  time-out algorithm:\t\t%d\n"), TcpStatsMIB.dwRtoAlgorithm);    
+    _tprintf(_T("  minimum time-out:\t\t%d\n"), TcpStatsMIB.dwRtoMin);         
+    _tprintf(_T("  maximum time-out:\t\t%d\n"), TcpStatsMIB.dwRtoMax);         
+    _tprintf(_T("  maximum connections:\t\t%d\n"), TcpStatsMIB.dwMaxConn);        
+    _tprintf(_T("  active opens:\t\t\t%d\n"), TcpStatsMIB.dwActiveOpens);    
+    _tprintf(_T("  passive opens:\t\t\t%d\n"), TcpStatsMIB.dwPassiveOpens);   
+    _tprintf(_T("  failed attempts:\t\t%d\n"), TcpStatsMIB.dwAttemptFails);   
+    _tprintf(_T("  established connections reset:\t%d\n"), TcpStatsMIB.dwEstabResets);    
+    _tprintf(_T("  established connections:\t%d\n"), TcpStatsMIB.dwCurrEstab);      
+    _tprintf(_T("  segments received:\t\t%d\n"), TcpStatsMIB.dwInSegs);         
+    _tprintf(_T("  segment sent:\t\t\t%d\n"), TcpStatsMIB.dwOutSegs);        
+    _tprintf(_T("  segments retransmitted:\t\t%d\n"), TcpStatsMIB.dwRetransSegs);    
+    _tprintf(_T("  incoming errors:\t\t%d\n"), TcpStatsMIB.dwInErrs);         
+    _tprintf(_T("  outgoing resets:\t\t%d\n"), TcpStatsMIB.dwOutRsts);        
+    _tprintf(_T("  cumulative connections:\t\t%d\n"), TcpStatsMIB.dwNumConns);       
+}
+
+static void ShowUdpStatistics()
+{
+    MIB_UDPSTATS UDPStatsMIB;
+    GetUdpStatistics(&UDPStatsMIB);
+
+    _tprintf(_T("UDP Statistics\t\n"));
+    _tprintf(_T("  received datagrams:\t\t\t%d\n"), UDPStatsMIB.dwInDatagrams);
+    _tprintf(_T("  datagrams for which no port exists:\t%d\n"), UDPStatsMIB.dwNoPorts); 
+    _tprintf(_T("  errors on received datagrams:\t\t%d\n"), UDPStatsMIB.dwInErrors);
+    _tprintf(_T("  sent datagrams:\t\t\t\t%d\n"), UDPStatsMIB.dwOutDatagrams);
+    _tprintf(_T("  number of entries in listener table:\t%d\n"), UDPStatsMIB.dwNumAddrs);
+}
+
+static void ShowIpStatistics()
+{
+    MIB_IPSTATS IPStatsMIB;
+    GetIpStatistics(&IPStatsMIB);
+
+    _tprintf(_T("IP Statistics\t\n"));
+    _tprintf(_T("  IP forwarding enabled or disabled:\t%d\n"), IPStatsMIB.dwForwarding);      
+    _tprintf(_T("  default time-to-live:\t\t\t%d\n"), IPStatsMIB.dwDefaultTTL);      
+    _tprintf(_T("  datagrams received:\t\t\t%d\n"), IPStatsMIB.dwInReceives);      
+    _tprintf(_T("  received header errors:\t\t\t%d\n"), IPStatsMIB.dwInHdrErrors);     
+    _tprintf(_T("  received address errors:\t\t%d\n"), IPStatsMIB.dwInAddrErrors);    
+    _tprintf(_T("  datagrams forwarded:\t\t\t%d\n"), IPStatsMIB.dwForwDatagrams);   
+    _tprintf(_T("  datagrams with unknown protocol:\t%d\n"), IPStatsMIB.dwInUnknownProtos); 
+    _tprintf(_T("  received datagrams discarded:\t\t%d\n"), IPStatsMIB.dwInDiscards);      
+    _tprintf(_T("  received datagrams delivered:\t\t%d\n"), IPStatsMIB.dwInDelivers);      
+    _tprintf(_T("  sent datagrams discarded:\t\t%d\n"), IPStatsMIB.dwOutDiscards);     
+    _tprintf(_T("  datagrams for which no route exists:\t%d\n"), IPStatsMIB.dwOutNoRoutes);     
+    _tprintf(_T("  datagrams for which frags didn't arrive:%d\n"), IPStatsMIB.dwReasmTimeout);    
+    _tprintf(_T("  datagrams requiring reassembly:\t\t%d\n"), IPStatsMIB.dwReasmReqds);      
+    _tprintf(_T("  successful reassemblies:\t\t%d\n"), IPStatsMIB.dwReasmOks);        
+    _tprintf(_T("  failed reassemblies:\t\t\t%d\n"), IPStatsMIB.dwReasmFails);      
+    _tprintf(_T("  successful fragmentations:\t\t%d\n"), IPStatsMIB.dwFragOks);         
+    _tprintf(_T("  failed fragmentations:\t\t\t%d\n"), IPStatsMIB.dwFragFails);       
+    _tprintf(_T("  datagrams fragmented:\t\t\t%d\n"), IPStatsMIB.dwFragCreates);     
+    _tprintf(_T("  number of interfaces on computer:\t%d\n"), IPStatsMIB.dwNumIf);           
+    _tprintf(_T("  number of IP address on computer:\t%d\n"), IPStatsMIB.dwNumAddr);         
+    _tprintf(_T("  number of routes in routing table:\t%d\n"), IPStatsMIB.dwNumRoutes);       
+}
+
+static void ShowNetworkParams()
+{
+    FIXED_INFO* FixedInfo;
+    IP_ADDR_STRING* pIPAddr;
+    ULONG ulOutBufLen;
+    DWORD dwRetVal;
+
+    _tprintf(_T("Network Parameters\t\n"));
+
+    FixedInfo = (FIXED_INFO*)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
+    ulOutBufLen = sizeof(FIXED_INFO);
+    if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &ulOutBufLen)) {
+        GlobalFree(FixedInfo);
+        FixedInfo =(FIXED_INFO*)GlobalAlloc(GPTR, ulOutBufLen);
+    }
+    if (dwRetVal = GetNetworkParams(FixedInfo, &ulOutBufLen)) {
+        _tprintf(_T("Call to GetNetworkParams failed. Return Value: %08x\n"), dwRetVal);
+    } else {
+        printf("  Host Name: %s", FixedInfo->HostName);
+        printf("\n  Domain Name: %s", FixedInfo->DomainName);
+        printf("\n  DNS Servers:\t%s\n", FixedInfo->DnsServerList.IpAddress.String);
+        pIPAddr = FixedInfo->DnsServerList.Next;
+        while (pIPAddr) {
+            printf("\t\t\t%s\n", pIPAddr->IpAddress.String);
+            pIPAddr = pIPAddr->Next;
+        }
+    }
+}
+
+static void ShowAdapterInfo()
+{
+    IP_ADAPTER_INFO* pAdaptorInfo;
+    ULONG ulOutBufLen;
+    DWORD dwRetVal;
+
+    _tprintf(_T("\nAdaptor Information\t\n"));
+    pAdaptorInfo = (IP_ADAPTER_INFO*)GlobalAlloc(GPTR, sizeof(IP_ADAPTER_INFO));
+    ulOutBufLen = sizeof(IP_ADAPTER_INFO);
+
+    if (ERROR_BUFFER_OVERFLOW == GetAdaptersInfo(pAdaptorInfo, &ulOutBufLen)) {
+        GlobalFree(pAdaptorInfo);
+        pAdaptorInfo = (IP_ADAPTER_INFO*)GlobalAlloc(GPTR, ulOutBufLen);
+    }
+    if (dwRetVal = GetAdaptersInfo(pAdaptorInfo, &ulOutBufLen)) {
+        _tprintf(_T("Call to GetAdaptersInfo failed. Return Value: %08x\n"), dwRetVal);
+    } else {
+        while (pAdaptorInfo) {
+            printf("  AdapterName: %s\n", pAdaptorInfo->AdapterName);
+            printf("  Description: %s\n", pAdaptorInfo->Description);
+            pAdaptorInfo = pAdaptorInfo->Next;
+        }
+    }
+}
+
+/*
+typedef struct {
+    UINT idLength;
+    UINT* ids;
+} AsnObjectIdentifier;
+
+VOID SnmpUtilPrintAsnAny(AsnAny* pAny);  // pointer to value to print
+VOID SnmpUtilPrintOid(AsnObjectIdentifier* Oid);  // object identifier to print
+
+ */
+void test_snmp(void)
+{
+    int nBytes = 500;
+    BYTE* pCache;
+
+    pCache = (BYTE*)SnmpUtilMemAlloc(nBytes);
+    if (pCache != NULL) {
+        AsnObjectIdentifier* pOidSrc = NULL;
+        AsnObjectIdentifier AsnObId;
+        if (SnmpUtilOidCpy(&AsnObId, pOidSrc)) {
+            //
+            //
+            //
+            SnmpUtilOidFree(&AsnObId);
+        }
+        SnmpUtilMemFree(pCache);
+    } else {
+        _tprintf(_T("ERROR: call to SnmpUtilMemAlloc() failed\n"));
+    }
+}
+
+// Maximum string lengths for ASCII ip address and port names
+//
+#define HOSTNAMELEN		256
+#define PORTNAMELEN		256
+#define ADDRESSLEN		HOSTNAMELEN+PORTNAMELEN
+
+//
+// Our option flags
+//
+#define FLAG_SHOW_ALL_ENDPOINTS    1
+#define FLAG_SHOW_ETH_STATS        2
+#define FLAG_SHOW_NUMBERS          3
+#define FLAG_SHOW_PROT_CONNECTIONS 4
+#define FLAG_SHOW_ROUTE_TABLE      5
+#define FLAG_SHOW_PROT_STATS       6
+#define FLAG_SHOW_INTERVAL         7
+
+
+// Undocumented extended information structures available only on XP and higher
+
+typedef struct {
+  DWORD dwState;        // state of the connection
+  DWORD dwLocalAddr;    // address on local computer
+  DWORD dwLocalPort;    // port number on local computer
+  DWORD dwRemoteAddr;   // address on remote computer
+  DWORD dwRemotePort;   // port number on remote computer
+  DWORD	dwProcessId;
+} MIB_TCPEXROW, *PMIB_TCPEXROW;
+
+typedef struct {
+	DWORD dwNumEntries;
+	MIB_TCPEXROW table[ANY_SIZE];
+} MIB_TCPEXTABLE, *PMIB_TCPEXTABLE;
+
+typedef struct {
+  DWORD   dwLocalAddr;    // address on local computer
+  DWORD   dwLocalPort;    // port number on local computer
+  DWORD	  dwProcessId;
+} MIB_UDPEXROW, *PMIB_UDPEXROW;
+
+typedef struct {
+	DWORD dwNumEntries;
+	MIB_UDPEXROW table[ANY_SIZE];
+} MIB_UDPEXTABLE, *PMIB_UDPEXTABLE;
+
+
+//
+// GetPortName
+//
+// Translate port numbers into their text equivalent if there is one
+//
+PCHAR
+GetPortName(DWORD Flags, UINT port, PCHAR proto, PCHAR name, int namelen) 
+{
+	struct servent *psrvent;
+
+	if (Flags & FLAG_SHOW_NUMBERS) {
+		sprintf(name, "%d", htons((WORD)port));
+		return name;
+	} 
+	// Try to translate to a name
+	if (psrvent = getservbyport(port, proto)) {
+		strcpy(name, psrvent->s_name );
+	} else {
+		sprintf(name, "%d", htons((WORD)port));
+	}		
+	return name;
+}
+
+
+//
+// GetIpHostName
+//
+// Translate IP addresses into their name-resolved form if possible.
+//
+PCHAR
+GetIpHostName(DWORD Flags, BOOL local, UINT ipaddr, PCHAR name, int namelen) 
+{
+//	struct hostent *phostent;
+	UINT nipaddr;
+
+	// Does the user want raw numbers?
+	nipaddr = htonl(ipaddr);
+	if (Flags & FLAG_SHOW_NUMBERS ) {
+		sprintf(name, "%d.%d.%d.%d", 
+			(nipaddr >> 24) & 0xFF,
+			(nipaddr >> 16) & 0xFF,
+			(nipaddr >> 8) & 0xFF,
+			(nipaddr) & 0xFF);
+		return name;
+	}
+
+   	name[0] = _T('\0');
+
+	// Try to translate to a name
+	if (!ipaddr) {
+		if (!local) {
+			sprintf(name, "%d.%d.%d.%d", 
+				(nipaddr >> 24) & 0xFF,
+				(nipaddr >> 16) & 0xFF,
+				(nipaddr >> 8) & 0xFF,
+				(nipaddr) & 0xFF);
+		} else {
+			//gethostname(name, namelen);
+		}
+	} else if (ipaddr == 0x0100007f) {
+		if (local) {
+			//gethostname(name, namelen);
+		} else {
+			strcpy(name, "localhost");
+		}
+//	} else if (phostent = gethostbyaddr((char*)&ipaddr, sizeof(nipaddr), PF_INET)) {
+//		strcpy(name, phostent->h_name);
+	} else {
+#if 0
+        int i1, i2, i3, i4;
+
+		i1 = (nipaddr >> 24) & 0x000000FF;
+		i2 = (nipaddr >> 16) & 0x000000FF;
+		i3 = (nipaddr >> 8) & 0x000000FF;
+		i4 = (nipaddr) & 0x000000FF;
+
+		i1 = 10;
+		i2 = 20;
+		i3 = 30;
+		i4 = 40;
+
+		sprintf(name, "%d.%d.%d.%d", i1,i2,i3,i4);
+#else
+		sprintf(name, "%d.%d.%d.%d", 
+			((nipaddr >> 24) & 0x000000FF),
+			((nipaddr >> 16) & 0x000000FF),
+			((nipaddr >> 8) & 0x000000FF),
+			((nipaddr) & 0x000000FF));
+#endif
+	}
+	return name;
+}
+
+BOOLEAN usage(void)
+{
+    TCHAR buffer[MAX_RESLEN];
+
+    int length = LoadString(GetModuleHandle(NULL), IDS_APP_USAGE, buffer, sizeof(buffer)/sizeof(buffer[0]));
+	_fputts(buffer, stderr);
+	return FALSE;
+}
+
+//
+// GetOptions
+// 
+// Parses the command line arguments.
+//
+BOOLEAN 
+GetOptions(int argc, char *argv[], PDWORD pFlags)
+{
+	int		i, j;
+	BOOLEAN	skipArgument;
+
+	*pFlags = 0;
+	for (i = 1; i < argc; i++) {
+		skipArgument = FALSE;
+		switch (argv[i][0]) {
+		case '-':
+		case '/':
+			j = 1;
+			while (argv[i][j]) {
+				switch (toupper(argv[i][j])) {
+				case 'A':
+					*pFlags |= FLAG_SHOW_ALL_ENDPOINTS;
+					break;
+				case 'E':
+					*pFlags |= FLAG_SHOW_ETH_STATS;
+					break;
+				case 'N':
+					*pFlags |= FLAG_SHOW_NUMBERS;
+					break;
+				case 'P':
+					*pFlags |= FLAG_SHOW_PROT_CONNECTIONS;
+					break;
+				case 'R':
+					*pFlags |= FLAG_SHOW_ROUTE_TABLE;
+					break;
+				case 'S':
+					*pFlags |= FLAG_SHOW_PROT_STATS;
+					break;
+				default:
+					return usage();
+				}
+				if (skipArgument) break;
+				j++;
+			}
+			break;
+		case 'i':
+			*pFlags |= FLAG_SHOW_INTERVAL;
+			break;
+		default:
+			return usage();
+		}
+	}
+	return TRUE;
+}
+
+#if 1
+
+	CHAR localname[HOSTNAMELEN], remotename[HOSTNAMELEN];
+	CHAR remoteport[PORTNAMELEN], localport[PORTNAMELEN];
+	CHAR localaddr[ADDRESSLEN], remoteaddr[ADDRESSLEN];
+
+int main(int argc, char *argv[])
+{
+	PMIB_TCPTABLE tcpTable;
+	PMIB_UDPTABLE udpTable;
+	DWORD error, dwSize;
+	DWORD i, flags;
+
+	// Get options
+	if (!GetOptions(argc, argv, &flags)) {
+		return -1;
+    } else {
+		// Get the table of TCP endpoints
+		dwSize = 0;
+		error = GetTcpTable(NULL, &dwSize, TRUE);
+		if (error != ERROR_INSUFFICIENT_BUFFER) {
+			printf("Failed to snapshot TCP endpoints.\n");
+			PrintError(error);
+			return -1;
+		}
+		tcpTable = (PMIB_TCPTABLE)malloc(dwSize);
+		error = GetTcpTable(tcpTable, &dwSize, TRUE );
+		if (error) {
+			printf("Failed to snapshot TCP endpoints table.\n");
+			PrintError(error);
+			return -1;
+		}
+
+		// Get the table of UDP endpoints
+		dwSize = 0;
+		error = GetUdpTable(NULL, &dwSize, TRUE);
+		if (error != ERROR_INSUFFICIENT_BUFFER) {
+			printf("Failed to snapshot UDP endpoints.\n");
+			PrintError(error);
+			return -1;
+		}
+		udpTable = (PMIB_UDPTABLE)malloc(dwSize);
+		error = GetUdpTable(udpTable, &dwSize, TRUE);
+		if (error) {
+			printf("Failed to snapshot UDP endpoints table.\n");
+			PrintError(error);
+			return -1;
+		}
+
+		// Dump the TCP table
+		for (i = 0; i < tcpTable->dwNumEntries; i++) {
+			if (flags & FLAG_SHOW_ALL_ENDPOINTS ||
+				tcpTable->table[i].dwState == MIB_TCP_STATE_ESTAB) {
+				sprintf(localaddr, "%s:%s", 
+					GetIpHostName(flags, TRUE, tcpTable->table[i].dwLocalAddr, localname, HOSTNAMELEN), 
+				    GetPortName(flags, tcpTable->table[i].dwLocalPort, "tcp", localport, PORTNAMELEN));
+				sprintf(remoteaddr, "%s:%s",
+					GetIpHostName(flags, FALSE, tcpTable->table[i].dwRemoteAddr, remotename, HOSTNAMELEN), 
+				    tcpTable->table[i].dwRemoteAddr ? 
+					GetPortName(flags, tcpTable->table[i].dwRemotePort, "tcp", remoteport, PORTNAMELEN):
+					"0");
+				printf("%4s\tState:   %s\n", "[TCP]", TcpState[tcpTable->table[i].dwState]);
+				printf("       Local:   %s\n       Remote:  %s\n", localaddr, remoteaddr);
+			}
+		}
+		// Dump the UDP table
+		if (flags & FLAG_SHOW_ALL_ENDPOINTS) {
+			for (i = 0; i < udpTable->dwNumEntries; i++) {
+				sprintf(localaddr, "%s:%s", 
+					GetIpHostName(flags, TRUE, udpTable->table[i].dwLocalAddr, localname, HOSTNAMELEN), 
+					GetPortName(flags, udpTable->table[i].dwLocalPort, "tcp", localport, PORTNAMELEN));
+				printf("%4s", "[UDP]");
+				printf("       Local:   %s\n       Remote:  %s\n", localaddr, "*.*.*.*:*");
+			}
+		}
+	}	
+	printf("\n");
+	return 0;
+}
+
+#else
+
+int main(int argc, char *argv[])
+{
+    if (argc > 1) {
+        usage();
+        return 1;
+    }
+
+    _tprintf(_T("\nActive Connections\n\n")\
+             _T("  Proto  Local Address          Foreign Address        State\n\n"));
+    test_snmp();
+
+    ShowTcpStatistics();
+    ShowUdpStatistics();
+    ShowIpStatistics();
+    ShowNetworkParams();
+    ShowAdapterInfo();
+
+	return 0;
+}
+
+#endif

apps/utils/net/netstat/netstat.rc

@@ -0,0 +1,40 @@
+/* $Id$ */
+
+#include <windows.h>
+#include "resource.h"
+
+#define REACTOS_STR_FILE_DESCRIPTION	"ReactOS TCP/IPv4 Win32 netstat\0"
+#define REACTOS_STR_INTERNAL_NAME	"netstat\0"
+#define REACTOS_STR_ORIGINAL_FILENAME	"netstat.exe\0"
+#include <reactos/version.rc>
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+#ifdef __GNUC__
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_APP_TITLE           "ReactOS netstat"
+    IDS_APP_USAGE           "\n"\
+                            "Displays current TCP/IP protocol statistics and network connections.\n\n"\
+                            "NETSTAT [-a] [-e] [-n] [-s] [-p proto] [-r] [interval]\n\n"\
+                            "  -a            Displays all connections and listening ports.\n"\
+                            "  -e            Displays Ethernet statistics. May be combined with -s\n"\
+                            "  -n            Displays address and port numbers in numeric form.\n"\
+                            "  -p proto      Shows connections for protocol 'proto' TCP or UDP.\n"\
+                            "                If used with the -s option to display\n"\
+                            "                per-protocol statistics, 'proto' may be TCP, UDP, or IP.\n"\
+                            "  -r            Displays the current routing table.\n"\
+                            "  -s            Displays per-protocol statistics. Statistics are shown for\n"\
+                            "                TCP, UDP and IP by default; use -p option to display\n"\
+                            "                information about a subset of the protocols only.\n"\
+                            "  interval      Redisplays selected statistics every 'interval' seconds.\n"\
+                            "                Press CTRL+C to stop redisplaying. By default netstat will\n"\
+                            "                print the current information only once.\n"
+END
+#endif
+

apps/utils/net/netstat/resource.h

@@ -0,0 +1,7 @@
+
+#define RES_FIRST_INDEX 1
+#define RES_LAST_INDEX  25
+
+#define IDS_APP_TITLE  100
+#define IDS_APP_USAGE  101
+

apps/utils/net/netstat/trace.c

@@ -0,0 +1,53 @@
+/////////////////////////////////////////////////////////////////////////////
+// Diagnostic Trace
+//
+#include <stdio.h> 
+#include <stdarg.h>
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <tchar.h>
+#include "trace.h"
+
+
+#ifdef _DEBUG
+
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+
+void _DebugBreak(void)
+{
+    DebugBreak();
+}
+
+void Trace(TCHAR* lpszFormat, ...)
+{
+    va_list args;
+    int nBuf;
+    TCHAR szBuffer[512];
+
+    va_start(args, lpszFormat);
+    nBuf = _vsntprintf(szBuffer, sizeof(szBuffer)/sizeof(TCHAR), lpszFormat, args);
+    OutputDebugString(szBuffer);
+    // was there an error? was the expanded string too long?
+    //ASSERT(nBuf >= 0);
+    va_end(args);
+}
+
+void Assert(void* assert, TCHAR* file, int line, void* msg)
+{
+    if (msg == NULL) {
+        printf("ASSERT -- %s occured on line %u of file %s.\n",
+               assert, line, file);
+    } else {
+        printf("ASSERT -- %s occured on line %u of file %s: Message = %s.\n",
+               assert, line, file, msg);
+    }
+}
+
+#else
+
+void Trace(TCHAR* lpszFormat, ...) { };
+void Assert(void* assert, TCHAR* file, int line, void* msg) { };
+
+#endif //_DEBUG
+/////////////////////////////////////////////////////////////////////////////

apps/utils/net/netstat/trace.h

@@ -0,0 +1,61 @@
+/////////////////////////////////////////////////////////////////////////////
+// Diagnostic Trace
+//
+#ifndef __TRACE_H__
+#define __TRACE_H__
+
+#ifdef _DEBUG
+
+#ifdef _X86_
+#define BreakPoint()        _asm { int 3h }
+#else
+#define BreakPoint()        _DebugBreak()
+#endif
+
+#ifndef ASSERT
+#define ASSERT(exp)                                 \
+{                                                   \
+    if (!(exp)) {                                   \
+        Assert(#exp, __FILE__, __LINE__, NULL);     \
+        BreakPoint();                               \
+    }                                               \
+}                                                   \
+
+#define ASSERTMSG(exp, msg)                         \
+{                                                   \
+    if (!(exp)) {                                   \
+        Assert(#exp, __FILE__, __LINE__, msg);      \
+        BreakPoint();                               \
+    }                                               \
+}
+#endif
+
+//=============================================================================
+//  MACRO: TRACE()
+//=============================================================================
+
+#define TRACE  Trace
+
+
+#else   // _DEBUG
+
+//=============================================================================
+//  Define away MACRO's ASSERT() and TRACE() in non debug builds
+//=============================================================================
+
+#ifndef ASSERT
+#define ASSERT(exp)
+#define ASSERTMSG(exp, msg)
+#endif
+
+#define TRACE 0 ? (void)0 : Trace
+
+#endif // !_DEBUG
+
+
+void Assert(void* assert, TCHAR* file, int line, void* msg);
+void Trace(TCHAR* lpszFormat, ...);
+
+
+#endif // __TRACE_H__
+/////////////////////////////////////////////////////////////////////////////

apps/utils/net/ping/makefile

@@ -0,0 +1,19 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = ping
+
+TARGET_INSTALLDIR = system32
+
+TARGET_CFLAGS = -D__USE_W32_SOCKETS
+
+TARGET_SDKLIBS = ws2_32.a
+
+TARGET_OBJECTS = $(TARGET_NAME).o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk

apps/utils/net/ping/ping.c

@@ -0,0 +1,631 @@
+/* $Id$
+ *
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS ping utility
+ * FILE:        apps/net/ping/ping.c
+ * PURPOSE:     Network test utility
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
+ * REVISIONS:
+ *   CSH  01/09/2000 Created
+ */
+//#include <windows.h>
+#include <winsock2.h>
+#include <tchar.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#ifndef _MSC_VER
+
+//#define DBG
+
+/* FIXME: Where should this be? */
+#ifdef CopyMemory
+#undef CopyMemory
+#endif
+#define CopyMemory(Destination, Source, Length) memcpy(Destination, Source, Length);
+
+/* Should be in the header files somewhere (exported by ntdll.dll) */
+long atol(const char *str);
+
+#ifndef __int64
+typedef long long __int64;
+#endif
+
+char * _i64toa(__int64 value, char *string, int radix);
+
+#endif
+
+
+/* General ICMP constants */
+#define ICMP_MINSIZE		8		/* Minimum ICMP packet size */
+#define ICMP_MAXSIZE		65535	/* Maximum ICMP packet size */
+
+/* ICMP message types */
+#define ICMPMSG_ECHOREQUEST	8		/* ICMP ECHO request message */
+#define ICMPMSG_ECHOREPLY	0		/* ICMP ECHO reply message */
+
+#pragma pack(4)
+
+/* IPv4 header structure */
+typedef struct _IPv4_HEADER {
+	unsigned char	IHL:4;
+	unsigned char	Version:4;
+	unsigned char	TOS;
+	unsigned short	Length;
+	unsigned short	Id;
+	unsigned short	FragFlags;
+	unsigned char	TTL;
+	unsigned char	Protocol;
+	unsigned short	Checksum;
+	unsigned int	SrcAddress;
+	unsigned int	DstAddress;
+} IPv4_HEADER, *PIPv4_HEADER;
+
+/* ICMP echo request/reply header structure */
+typedef struct _ICMP_HEADER {
+	unsigned char	Type;
+	unsigned char	Code;
+	unsigned short	Checksum;
+	unsigned short	Id;
+	unsigned short	SeqNum;
+} ICMP_HEADER, *PICMP_HEADER;
+
+typedef struct _ICMP_ECHO_PACKET {
+	ICMP_HEADER   Icmp;
+	LARGE_INTEGER Timestamp;
+} ICMP_ECHO_PACKET, *PICMP_ECHO_PACKET;
+
+#pragma pack(1)
+
+BOOL                InvalidOption;
+BOOL                NeverStop;
+BOOL                ResolveAddresses;
+UINT                PingCount;
+UINT                DataSize;   /* ICMP echo request data size */
+BOOL                DontFragment;
+ULONG               TTLValue;
+ULONG               TOSValue;
+ULONG               Timeout;
+CHAR                TargetName[256];
+SOCKET              IcmpSock;
+SOCKADDR_IN         Target;
+LPSTR               TargetIP;
+FD_SET              Fds;
+TIMEVAL             Timeval;
+UINT                CurrentSeqNum;
+UINT                SentCount;
+UINT                LostCount;
+BOOL                MinRTTSet;
+LARGE_INTEGER       MinRTT;     /* Minimum round trip time in microseconds */
+LARGE_INTEGER       MaxRTT;
+LARGE_INTEGER       SumRTT;
+LARGE_INTEGER       AvgRTT;
+LARGE_INTEGER       TicksPerMs; /* Ticks per millisecond */
+LARGE_INTEGER       TicksPerUs; /* Ticks per microsecond */
+BOOL                UsePerformanceCounter;
+
+
+/* Display the contents of a buffer */
+VOID DisplayBuffer(
+    PVOID Buffer,
+    DWORD Size)
+{
+    UINT i;
+    PCHAR p;
+
+    printf("Buffer (0x%X)  Size (0x%X).\n", Buffer, Size);
+
+    p = (PCHAR)Buffer;
+    for (i = 0; i < Size; i++) {
+      if (i % 16 == 0) {
+        printf("\n");
+      }
+      printf("%02X ", (p[i]) & 0xFF);
+    }
+}
+
+/* Display usage information on screen */
+VOID Usage(VOID)
+{
+	printf("\nUsage: ping [-t] [-n count] [-l size] [-w timeout] destination-host\n\n");
+	printf("Options:\n");
+	printf("    -t             Ping the specified host until stopped.\n");
+	printf("                   To stop - type Control-C.\n");
+	printf("    -n count       Number of echo requests to send.\n");
+	printf("    -l size        Send buffer size.\n");
+	printf("    -w timeout     Timeout in milliseconds to wait for each reply.\n\n");
+}
+
+/* Reset configuration to default values */
+VOID Reset(VOID)
+{
+    LARGE_INTEGER PerformanceCounterFrequency;
+
+    NeverStop             = FALSE;
+    ResolveAddresses      = FALSE;
+    PingCount             = 4;
+    DataSize              = 32;
+    DontFragment          = FALSE;
+    TTLValue              = 128;
+    TOSValue              = 0;
+    Timeout               = 1000;
+    UsePerformanceCounter = QueryPerformanceFrequency(&PerformanceCounterFrequency);
+
+    if (UsePerformanceCounter) {
+        /* Performance counters may return incorrect results on some multiprocessor
+           platforms so we restrict execution on the first processor. This may fail
+           on Windows NT so we fall back to GetCurrentTick() for timing */
+        if (SetThreadAffinityMask (GetCurrentThread(), 1) == 0) {
+            UsePerformanceCounter = FALSE;
+        }
+
+        /* Convert frequency to ticks per millisecond */
+        TicksPerMs.QuadPart = PerformanceCounterFrequency.QuadPart / 1000;
+        /* And to ticks per microsecond */
+        TicksPerUs.QuadPart = PerformanceCounterFrequency.QuadPart / 1000000;
+    }
+    if (!UsePerformanceCounter) {
+        /* 1 tick per millisecond for GetCurrentTick() */
+        TicksPerMs.QuadPart = 1;
+        /* GetCurrentTick() cannot handle microseconds */
+        TicksPerUs.QuadPart = 1;
+    }
+}
+
+/* Return ULONG in a string */
+ULONG GetULONG(LPSTR String)
+{
+    UINT i, Length;
+    ULONG Value;
+
+    i = 0;
+    Length = strlen(String);
+    while ((i < Length) && ((String[i] < '0') || (String[i] > '9'))) i++;
+    if ((i >= Length) || ((String[i] < '0') || (String[i] > '9'))) {
+        InvalidOption = TRUE;
+        return 0;
+    }
+    Value = (ULONG)atol(&String[i]);
+
+    return Value;
+}
+
+/* Return ULONG in a string. Try next paramter if not successful */
+ULONG GetULONG2(LPSTR String1, LPSTR String2, PINT i)
+{
+    ULONG Value;
+
+    Value = GetULONG(String1);
+    if (InvalidOption) {
+        InvalidOption = FALSE;
+        if (String2[0] != '-') {
+            Value = GetULONG(String2);
+            if (!InvalidOption)
+                *i += 1;
+        }
+    }
+
+    return Value;
+}
+
+/* Parse command line parameters */
+BOOL ParseCmdline(int argc, char* argv[])
+{
+    INT i;
+    BOOL ShowUsage;
+    BOOL FoundTarget;
+//#if 1
+//    lstrcpy(TargetName, "127.0.0.1");
+//    PingCount = 1;
+//    return TRUE;
+//#endif
+    if (argc < 2) {
+        ShowUsage = TRUE;
+    } else {
+        ShowUsage = FALSE;
+    }
+    FoundTarget = FALSE;
+    InvalidOption = FALSE;
+
+    for (i = 1; i < argc; i++) {
+        if (argv[i][0] == '-') {
+            switch (argv[i][1]) {
+            case 't': NeverStop = TRUE; break;
+            case 'a': ResolveAddresses = TRUE; break;
+            case 'n': PingCount = GetULONG2(&argv[i][2], argv[i + 1], &i); break;
+            case 'l':
+                DataSize = GetULONG2(&argv[i][2], argv[i + 1], &i);
+                if ((DataSize < 0) || (DataSize > ICMP_MAXSIZE - sizeof(ICMP_ECHO_PACKET))) {
+                    printf("Bad value for option -l, valid range is from 0 to %d.\n",
+                        ICMP_MAXSIZE - sizeof(ICMP_ECHO_PACKET));
+                    return FALSE;
+                }
+                break;
+            case 'f': DontFragment = TRUE; break;
+            case 'i': TTLValue = GetULONG2(&argv[i][2], argv[i + 1], &i); break;
+            case 'v': TOSValue = GetULONG2(&argv[i][2], argv[i + 1], &i); break;
+            case 'w': Timeout  = GetULONG2(&argv[i][2], argv[i + 1], &i); break;
+            default:
+                printf("Bad option %s.\n", argv[i]);
+                Usage();
+                return FALSE;
+            }
+            if (InvalidOption) {
+                printf("Bad option format %s.\n", argv[i]);
+                return FALSE;
+            }
+        } else {
+            if (FoundTarget) {
+                printf("Bad parameter %s.\n", argv[i]);
+                return FALSE;
+            } else {
+				lstrcpy(TargetName, argv[i]);
+                FoundTarget = TRUE;
+            }
+        }
+    }
+
+    if ((!ShowUsage) && (!FoundTarget)) {
+        printf("Name or IP address of destination host must be specified.\n");
+        return FALSE;
+    }
+
+    if (ShowUsage) {
+        Usage();
+        return FALSE;
+    }
+    return TRUE;
+}
+
+/* Calculate checksum of data */
+WORD Checksum(PUSHORT data, UINT size)
+{
+    ULONG sum = 0;
+
+    while (size > 1) {
+        sum  += *data++;
+        size -= sizeof(USHORT);
+    }
+
+    if (size)
+        sum += *(UCHAR*)data;
+
+    sum = (sum >> 16) + (sum & 0xFFFF);
+    sum += (sum >> 16);
+
+    return (USHORT)(~sum);
+}
+
+/* Prepare to ping target */
+BOOL Setup(VOID)
+{
+    WORD     wVersionRequested;
+    WSADATA  WsaData;
+    INT	     Status;
+    ULONG    Addr;
+    PHOSTENT phe;
+
+    wVersionRequested = MAKEWORD(2, 2);
+ 
+    Status = WSAStartup(wVersionRequested, &WsaData);
+    if (Status != 0) {
+        printf("Could not initialize winsock dll.\n");	
+        return FALSE;
+    }
+
+    IcmpSock = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, 0);
+    if (IcmpSock == INVALID_SOCKET) {
+        printf("Could not create socket (#%d).\n", WSAGetLastError());
+        return FALSE;
+    }
+
+    ZeroMemory(&Target, sizeof(Target));
+    phe = NULL;
+    Addr = inet_addr(TargetName);
+    if (Addr == INADDR_NONE) {
+        phe = gethostbyname(TargetName);
+        if (phe == NULL) {
+            printf("Unknown host %s.\n", TargetName);
+            return FALSE;
+        } 
+    }
+	
+    if (phe != NULL) {
+        CopyMemory(&Target.sin_addr, phe->h_addr, phe->h_length);
+    } else {
+        Target.sin_addr.s_addr = Addr;
+    }
+
+    if (phe != NULL) {
+		Target.sin_family = phe->h_addrtype;
+    } else {
+        Target.sin_family = AF_INET;
+    }
+	
+    TargetIP		= inet_ntoa(Target.sin_addr);
+    CurrentSeqNum	= 0;
+    SentCount		= 0;
+	LostCount		= 0;
+    MinRTT.QuadPart = 0;
+    MaxRTT.QuadPart = 0;
+    SumRTT.QuadPart = 0;
+    MinRTTSet       = FALSE;
+    return TRUE;
+}
+
+/* Close socket */
+VOID Cleanup(VOID)
+{
+    if (IcmpSock != INVALID_SOCKET)
+        closesocket(IcmpSock);
+
+    WSACleanup();
+}
+
+VOID QueryTime(PLARGE_INTEGER Time)
+{
+    if (UsePerformanceCounter) {
+        if (QueryPerformanceCounter(Time) == 0) {
+            /* This should not happen, but we fall
+               back to GetCurrentTick() if it does */
+            Time->u.LowPart  = (ULONG)GetTickCount();
+            Time->u.HighPart = 0;
+
+            /* 1 tick per millisecond for GetCurrentTick() */
+            TicksPerMs.QuadPart = 1;
+            /* GetCurrentTick() cannot handle microseconds */
+            TicksPerUs.QuadPart = 1;
+
+            UsePerformanceCounter = FALSE;
+        }
+    } else {
+        Time->u.LowPart  = (ULONG)GetTickCount();
+        Time->u.HighPart = 0;
+    }
+}
+
+VOID TimeToMsString(LPSTR String, LARGE_INTEGER Time)
+{
+    UINT          i, Length;
+    CHAR          Convstr[40];
+    LARGE_INTEGER LargeTime;
+
+    LargeTime.QuadPart = Time.QuadPart / TicksPerMs.QuadPart;
+ 
+    _i64toa(LargeTime.QuadPart, Convstr, 10);
+	strcpy(String, Convstr);
+    strcat(String, "ms");
+}
+
+/* Locate the ICMP data and print it. Returns TRUE if the packet was good,
+   FALSE if not */
+BOOL DecodeResponse(PCHAR buffer, UINT size, PSOCKADDR_IN from)
+{
+    PIPv4_HEADER      IpHeader;
+    PICMP_ECHO_PACKET Icmp;
+  	UINT              IphLength;
+    CHAR              Time[100];
+    LARGE_INTEGER     RelativeTime;
+    LARGE_INTEGER     LargeTime;
+    CHAR              Sign[1];
+
+    IpHeader = (PIPv4_HEADER)buffer;
+
+    IphLength = IpHeader->IHL * 4;
+
+    if (size  < IphLength + ICMP_MINSIZE) {
+#ifdef DBG
+        printf("Bad size (0x%X < 0x%X)\n", size, IphLength + ICMP_MINSIZE);
+#endif /* DBG */
+        return FALSE;
+    }
+
+    Icmp = (PICMP_ECHO_PACKET)(buffer + IphLength);
+
+    if (Icmp->Icmp.Type != ICMPMSG_ECHOREPLY) {
+#ifdef DBG
+        printf("Bad ICMP type (0x%X should be 0x%X)\n", Icmp->Icmp.Type, ICMPMSG_ECHOREPLY);
+#endif /* DBG */
+        return FALSE;
+    }
+
+    if (Icmp->Icmp.Id != (USHORT)GetCurrentProcessId()) {
+#ifdef DBG
+        printf("Bad ICMP id (0x%X should be 0x%X)\n", Icmp->Icmp.Id, (USHORT)GetCurrentProcessId());
+#endif /* DBG */
+        return FALSE;
+    }
+
+    QueryTime(&LargeTime);
+
+    RelativeTime.QuadPart = (LargeTime.QuadPart - Icmp->Timestamp.QuadPart);
+
+    if ((RelativeTime.QuadPart / TicksPerMs.QuadPart) < 1) {
+        strcpy(Sign, "<");
+        strcpy(Time, "1ms");
+    } else {
+        strcpy(Sign, "=");
+        TimeToMsString(Time, RelativeTime);
+    }
+
+
+    printf("Reply from %s: bytes=%d time%s%s TTL=%d\n", inet_ntoa(from->sin_addr), 
+      size - IphLength - sizeof(ICMP_ECHO_PACKET), Sign, Time, IpHeader->TTL);
+    if (RelativeTime.QuadPart < MinRTT.QuadPart) {
+		  MinRTT.QuadPart = RelativeTime.QuadPart;
+      MinRTTSet = TRUE;
+    }
+	  if (RelativeTime.QuadPart > MaxRTT.QuadPart)
+	      MaxRTT.QuadPart = RelativeTime.QuadPart;
+    SumRTT.QuadPart += RelativeTime.QuadPart;
+
+	return TRUE;
+}
+
+/* Send and receive one ping */
+BOOL Ping(VOID)
+{
+    INT                 Status;
+    SOCKADDR            From;
+    UINT                Length;
+    PVOID               Buffer;
+    UINT                Size;
+    PICMP_ECHO_PACKET   Packet;
+
+    /* Account for extra space for IP header when packet is received */
+    Size   = DataSize + 128;
+    Buffer = GlobalAlloc(0, Size);
+    if (!Buffer) {
+        printf("Not enough free resources available.\n");
+        return FALSE;
+    }
+
+    ZeroMemory(Buffer, Size);
+    Packet = (PICMP_ECHO_PACKET)Buffer;
+
+    /* Assemble ICMP echo request packet */
+    Packet->Icmp.Type     = ICMPMSG_ECHOREQUEST;
+    Packet->Icmp.Code     = 0;
+    Packet->Icmp.Id	      = (USHORT)GetCurrentProcessId();
+    Packet->Icmp.SeqNum   = (USHORT)CurrentSeqNum;
+    Packet->Icmp.Checksum = 0;
+
+    /* Timestamp is part of data area */
+    QueryTime(&Packet->Timestamp);
+
+    CopyMemory(Buffer, &Packet->Icmp, sizeof(ICMP_ECHO_PACKET) + DataSize);
+    /* Calculate checksum for ICMP header and data area */
+    Packet->Icmp.Checksum = Checksum((PUSHORT)&Packet->Icmp, sizeof(ICMP_ECHO_PACKET) + DataSize);
+
+    CurrentSeqNum++;
+
+	/* Send ICMP echo request */
+
+    FD_ZERO(&Fds);
+    FD_SET(IcmpSock, &Fds);
+    Timeval.tv_sec  = Timeout / 1000;
+    Timeval.tv_usec = Timeout % 1000;
+    Status = select(0, NULL, &Fds, NULL, &Timeval);
+    if ((Status != SOCKET_ERROR) && (Status != 0)) {
+
+#ifdef DBG
+        printf("Sending packet\n");
+        DisplayBuffer(Buffer, sizeof(ICMP_ECHO_PACKET) + DataSize);
+        printf("\n");
+#endif /* DBG */
+
+        Status = sendto(IcmpSock, Buffer, sizeof(ICMP_ECHO_PACKET) + DataSize,
+            0, (SOCKADDR*)&Target, sizeof(Target));
+        SentCount++;
+    }
+    if (Status == SOCKET_ERROR) {
+        if (WSAGetLastError() == WSAEHOSTUNREACH) {
+            printf("Destination host unreachable.\n");
+        } else {
+            printf("Could not transmit data (%d).\n", WSAGetLastError());
+        }
+        GlobalFree(Buffer);
+        return FALSE;
+    }
+
+    /* Expect to receive ICMP echo reply */
+    FD_ZERO(&Fds);
+    FD_SET(IcmpSock, &Fds);
+    Timeval.tv_sec  = Timeout / 1000;
+    Timeval.tv_usec = Timeout % 1000;
+
+    Status = select(0, &Fds, NULL, NULL, &Timeval);
+    if ((Status != SOCKET_ERROR) && (Status != 0)) {
+        Length = sizeof(From);
+        Status = recvfrom(IcmpSock, Buffer, Size, 0, &From, &Length);
+
+#ifdef DBG
+        printf("Received packet\n");
+        DisplayBuffer(Buffer, Status);
+        printf("\n");
+#endif /* DBG */
+    }
+    if (Status == SOCKET_ERROR) {
+        if (WSAGetLastError() != WSAETIMEDOUT) {
+            printf("Could not receive data (%d).\n", WSAGetLastError());
+            GlobalFree(Buffer);
+            return FALSE;
+        }
+        Status = 0;
+    }
+
+    if (Status == 0) {
+        printf("Request timed out.\n");
+        LostCount++;
+        GlobalFree(Buffer);
+        return TRUE;
+    }
+
+    if (!DecodeResponse(Buffer, Status, (PSOCKADDR_IN)&From)) {
+        /* FIXME: Wait again as it could be another ICMP message type */
+        printf("Request timed out (incomplete datagram received).\n");
+        LostCount++;
+    }
+
+    GlobalFree(Buffer);
+    return TRUE;
+}
+
+
+/* Program entry point */
+int main(int argc, char* argv[])
+{
+    UINT Count;
+    CHAR MinTime[20];
+    CHAR MaxTime[20];
+    CHAR AvgTime[20];
+
+    Reset();
+
+    if ((ParseCmdline(argc, argv)) && (Setup())) {
+
+        printf("\nPinging %s [%s] with %d bytes of data:\n\n",
+            TargetName, TargetIP, DataSize);
+		
+		Count = 0;
+		while ((NeverStop) || (Count < PingCount)) {
+			Ping();
+			Sleep(Timeout);
+			Count++;
+		};
+
+        Cleanup();
+
+		/* Calculate avarage round trip time */
+        if ((SentCount - LostCount) > 0) {
+            AvgRTT.QuadPart = SumRTT.QuadPart / (SentCount - LostCount);
+        } else {
+            AvgRTT.QuadPart = 0;
+        }
+
+        /* Calculate loss percent */
+        if (LostCount > 0) {
+            Count = (SentCount * 100) / LostCount;
+        } else {
+            Count = 0;
+        }
+
+        if (!MinRTTSet)
+            MinRTT = MaxRTT;
+
+        TimeToMsString(MinTime, MinRTT);
+        TimeToMsString(MaxTime, MaxRTT);
+        TimeToMsString(AvgTime, AvgRTT);
+
+        /* Print statistics */
+        printf("\nPing statistics for %s:\n", TargetIP);
+        printf("    Packets: Sent = %d, Received = %d, Lost = %d (%d%% loss),\n",
+            SentCount, SentCount - LostCount, LostCount, Count);
+        printf("Approximate round trip times in milli-seconds:\n");
+        printf("    Minimum = %s, Maximum = %s, Average = %s\n",
+            MinTime, MaxTime, AvgTime);
+    }
+	return 0;
+}
+
+/* EOF */

apps/utils/net/roshttpd/common/socket.cpp

@@ -7,9 +7,9 @@
  * REVISIONS:
  *   CSH  01/09/2000 Created
  */
-#include <socket.h>
 #include <string.h>
 #include <error.h>
+#include <socket.h>
 #include <iterator.h>
 
 // ***************************** CSocket *****************************
@@ -28,7 +28,7 @@ CSocket::CSocket()
     // Any address will do
     SockAddrIn.sin_addr.s_addr = INADDR_ANY;
 
-    // Convert to network ordering
+    // Convert to network ordering 
     SockAddrIn.sin_port = htons(0);
 }
 
@@ -48,7 +48,7 @@ VOID CSocket::SetSocket(SOCKET socket)
 {
 	Socket = socket;
 }
-
+	
 
 // Return socket address
 SOCKADDR_IN CSocket::GetSockAddrIn()
@@ -71,7 +71,7 @@ VOID CSocket::SetEvents(LONG lEvents)
 		if (Event == WSA_INVALID_EVENT)
 			throw ESocketOpen(TS("Unable to create event."));
 	}
-
+	
 	if (lEvents != Events) {
 		// Associate network events with socket
 		if (WSAEventSelect(Socket, Event, lEvents) == SOCKET_ERROR)
@@ -102,43 +102,43 @@ VOID CSocket::Close()
 // Constructor with serversocket as parameter
 CServerClientSocket::CServerClientSocket(LPCServerSocket lpServerSocket)
 {
-    ServerSocket = lpServerSocket;
+	ServerSocket = lpServerSocket;
 }
 
 // Transmit data to socket
-INT CServerClientSocket::Transmit( LPCSTR lpsBuffer, UINT nLength)
+INT CServerClientSocket::Transmit( LPSTR lpsBuffer, UINT nLength)
 {
     return send(Socket, lpsBuffer, nLength, 0);
 }
 
 // Send a string to socket
-INT CServerClientSocket::SendText( LPCSTR lpsText)
+INT CServerClientSocket::SendText( LPSTR lpsText)
 {
     static CHAR crlf[3] = {0x0D, 0x0A, 0x00};
-    INT nCount;
+	INT nCount;
 
     nCount = Transmit(lpsText, strlen(lpsText));
-    nCount += Transmit(crlf, strlen(crlf));
-    return nCount;
+	nCount += Transmit(crlf, strlen(crlf));
+	return nCount;
 }
 
 // Receive data from socket
 INT CServerClientSocket::Receive(LPSTR lpsBuffer, UINT nLength)
 {
-    return recv(Socket, lpsBuffer, nLength, 0);
+	return recv(Socket, lpsBuffer, nLength, 0);
 }
 
 // Process winsock messages if any
 VOID CServerClientSocket::MessageLoop()
 {
-    UINT nStatus;
+	UINT nStatus;
     WSANETWORKEVENTS NetworkEvents;
 
     nStatus = WSAWaitForMultipleEvents(1, &Event, FALSE, 0, FALSE);
     if ((nStatus == 0) && (WSAEnumNetworkEvents(Socket, Event, &NetworkEvents) != SOCKET_ERROR)) {
         if ((NetworkEvents.lNetworkEvents & FD_READ) != 0) {
 			OnRead();
-		}
+		} 
         if ((NetworkEvents.lNetworkEvents & FD_CLOSE) != 0) {
 			OnClose();
         }
@@ -165,7 +165,7 @@ CServerClientThread::~CServerClientThread()
 }
 
 
-// ************************** CServerSocket **************************
+// ************************** CServerSocket **************************	
 
 // Default constructor
 CServerSocket::CServerSocket()
@@ -183,8 +183,8 @@ CServerSocket::~CServerSocket()
 VOID CServerSocket::Open()
 {
 	assert(!Active);
-
-	// Convert to network ordering
+	
+	// Convert to network ordering 
 	SockAddrIn.sin_port = htons(Port);
 
 	if (Socket == INVALID_SOCKET) {
@@ -222,7 +222,7 @@ VOID CServerSocket::Close()
 			throw ESocketClose(TS("Unable to close socket event."));
 		Event = WSA_INVALID_EVENT;
 	}
-
+	
 	CIterator<LPCServerClientThread> *i = Connections.CreateIterator();
 
 	// Terminate and free all client threads
@@ -257,7 +257,7 @@ VOID CServerSocket::MessageLoop()
     WSANETWORKEVENTS NetworkEvents;
 	LPCServerClientSocket lpClient;
 	LPCServerClientThread lpThread;
-
+	
     nStatus = WSAWaitForMultipleEvents(1, &Event, FALSE, 0, FALSE);
     if ((nStatus == 0) && (WSAEnumNetworkEvents(Socket, Event, &NetworkEvents) != SOCKET_ERROR)) {
         if ((NetworkEvents.lNetworkEvents & FD_ACCEPT) != 0) {
@@ -322,13 +322,13 @@ VOID InitWinsock()
     WSADATA wsaData;
 
     wVersionRequested = MAKEWORD(2, 0);
-
+ 
     if (WSAStartup(wVersionRequested, &wsaData) != 0)
         // Return FALSE as we couldn't find a usable WinSock DLL
 		throw ESocketWinsock(TS("Unable to initialize winsock dll."));
-
+   
     /* Confirm that the WinSock DLL supports 2.0 */
-
+ 
     if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 0) {
         // We couldn't find a usable winsock dll
         WSACleanup();

apps/utils/net/roshttpd/config.cpp

@@ -42,7 +42,7 @@ void CConfig::Reset()
 void CConfig::Default()
 {
 	Clear();
-	MainBase = _wcsdup((LPWSTR)dcfgMainBase);
+	MainBase = (LPWSTR)_wcsdup(dcfgMainBase);
 	HttpBase = _strdup(dcfgHttpBase);
 
 	LPSTR lpsStr;

apps/utils/net/roshttpd/http.cpp

@@ -12,14 +12,14 @@
  *              - Implement more entity-header entries
  */
 #include <debug.h>
-#include <iostream>
+#include <iostream.h>
 #include <string.h>
 #include <http.h>
 
-CHAR MethodTable[NUMMETHODS][8] = {"OPTIONS", "GET", "HEAD", "POST", "PUT",
+CHAR MethodTable[NUMMETHODS][8] = {"OPTIONS", "GET", "HEAD", "POST", "PUT", 
     "DELETE", "TRACE"};
 
-CHAR GenerelTable[NUMGENERELS][18] = {"Cache-Control", "Connection", "Date", "Pragma",
+CHAR GenerelTable[NUMGENERELS][18] = {"Cache-Control", "Connection", "Date", "Pragma", 
     "Transfer-Encoding", "Upgrade", "Via"};
 
 CHAR RequestTable[NUMREQUESTS][20] = {"Accept", "Accept-Charset", "Accept-Encoding",
@@ -98,7 +98,7 @@ BOOL CHttpParser::ReadChar(LPSTR lpsStr)
 BOOL CHttpParser::PeekChar(LPSTR lpsStr)
 {
     UINT nFakeTail;
-
+    
     if (nTail == sizeof(sBuffer))
         nFakeTail = 0;
     else
@@ -117,10 +117,10 @@ BOOL CHttpParser::ReadString(LPSTR lpsStr, UINT nLength)
 {
     UINT i = 0;
     CHAR sTmp;
-
+    
     while (PeekChar(&sTmp)) {
         if (((sTmp >= 'A') && (sTmp <= 'Z')) || ((sTmp >= 'a') && (sTmp <= 'z')) ||
-            ((sTmp >= '0') && (sTmp <= '9')) || (sTmp == '-')) {
+            ((sTmp >= '0') && (sTmp <= '9')) || (sTmp == '-')) { 
             if (i >= (nLength - 1)) {
                 lpsStr[0] = 0;
                 return FALSE;
@@ -137,13 +137,13 @@ BOOL CHttpParser::ReadString(LPSTR lpsStr, UINT nLength)
     return FALSE;
 }
 
-// Read a string from buffer. Stop if SP or CR is found or when there are no more
+// Read a string from buffer. Stop if SP or CR is found or when there are no more 
 // characters
 BOOL CHttpParser::ReadSpecial(LPSTR lpsStr, UINT nLength)
 {
     UINT i = 0;
     CHAR sTmp;
-
+ 
     while (PeekChar(&sTmp) && (sTmp != ' ') && (sTmp != 13)) {
         if (i >= (nLength - 1)) {
             lpsStr[nLength - 1] = 0;
@@ -186,12 +186,15 @@ BOOL CHttpParser::ExpectCRLF()
     return (Expect(13) && Expect(10));
 }
 
-// Request = RequestLine | *( GenerelHeader | RequestHeader | EntityHeader )
+// Request = RequestLine | *( GenerelHeader | RequestHeader | EntityHeader ) 
 //           CRLF [ MessageBody ]
 BOOL CHttpParser::Parse()
 {
     BOOL bStatus;
 
+
+    CHAR ch;
+
     if (RequestLine()) {
         do {
             if (!ReadString(sHeader, sizeof(sHeader)))
@@ -217,10 +220,10 @@ BOOL CHttpParser::RequestLine()
 
     bUnknownMethod = FALSE;
 
-    // RFC 2068 states that servers SHOULD ignore any empty nine(s) received where a
+    // RFC 2068 states that servers SHOULD ignore any empty nine(s) received where a 
     // Request-Line is expected
     while (PeekChar(&sCh) && ((sCh == 13) || (sCh == 10)));
-
+    
     if (!ReadString(sMethod, sizeof(sMethod)))
         return FALSE;
 
@@ -248,7 +251,7 @@ BOOL CHttpParser::RequestLine()
     return FALSE;
 }
 
-// GenerelHeader = Cache-Control | Connection | Date | Pragma | Transfer-Encoding |
+// GenerelHeader = Cache-Control | Connection | Date | Pragma | Transfer-Encoding | 
 //                 Upgrade | Via
 BOOL CHttpParser::GenerelHeader()
 {
@@ -354,9 +357,9 @@ BOOL CHttpParser::EntityHeader()
     for (i = 0; i < NUMENTITIES; i++) {
         if (strcmp(EntityTable[i], sHeader) == 0) {
             switch (i) {
-                case 0:
+                case 0: 
                 default: {
-                    //cout << "<Entity-Header>: #" << i << endl;
+                    //cout << "<Entity-Header>: #" << i << endl; 
                     Expect(':');
                     Expect(' ');
                     Skip(13);

apps/utils/net/roshttpd/httpd.cpp

@@ -41,7 +41,7 @@ CHttpClient::CHttpClient(CServerSocket *serversocket)
 VOID CHttpClient::SplitUri(LPSTR lpsUri, LPSTR lpsHost, LPSTR lpsResource, LPSTR lpsParams)
 {
     LPSTR lpsPos;
-    LPSTR lpsStr;
+	LPSTR lpsStr;
     UINT i;
 
 	strcpy(lpsHost, "");
@@ -53,7 +53,7 @@ VOID CHttpClient::SplitUri(LPSTR lpsUri, LPSTR lpsHost, LPSTR lpsResource, LPSTR
         lpsStr = &lpsPos[3];
 	else
 		lpsStr = lpsUri;
-
+        
     lpsPos = strstr(lpsStr, "/");
     if (lpsPos != NULL) {
         strncat(lpsHost, lpsPos, lpsPos - lpsStr);
@@ -80,11 +80,11 @@ VOID CHttpClient::SplitUri(LPSTR lpsUri, LPSTR lpsHost, LPSTR lpsResource, LPSTR
 VOID CHttpClient::SplitResource(LPSTR lpsResource, LPSTR lpsPath, LPSTR lpsFilename, LPSTR lpsExtension)
 {
     INT i,len,fileptr,extptr;
-
+	
 	strcpy(lpsPath, "");
 	strcpy(lpsFilename, "");
 	strcpy(lpsExtension, "");
-
+	
 	len = strlen(lpsResource);
 	if (len != 0) {
 		if (lpsResource[len - 1] == '/') {
@@ -102,7 +102,7 @@ VOID CHttpClient::SplitResource(LPSTR lpsResource, LPSTR lpsPath, LPSTR lpsFilen
 				strncat(lpsPath, lpsResource, fileptr);
 			} else
 				fileptr = 1;
-
+			
 			// Get filename and possibly extension
 			if (extptr != 0) {
 				strncat(lpsFilename, &lpsResource[fileptr], extptr - fileptr);
@@ -118,7 +118,7 @@ VOID CHttpClient::SplitResource(LPSTR lpsResource, LPSTR lpsPath, LPSTR lpsFilen
 VOID CHttpClient::ProcessRequest()
 {
     CHAR sStr[255];
-    CHAR sHost[255];
+	CHAR sHost[255];
     CHAR sResource[255];
     CHAR sParams[255];
 
@@ -126,7 +126,7 @@ VOID CHttpClient::ProcessRequest()
     switch (Parser.nMethodNo) {
 		case hmGET: {
 			SplitUri(Parser.sUri, sHost, sResource, sParams);
-
+			
 			// Default resource?
 			if (strlen(sResource) == 0) {
 				CIterator<LPSTR> *i = pConfiguration->GetDefaultResources()->CreateIterator();
@@ -145,7 +145,7 @@ VOID CHttpClient::ProcessRequest()
 				}
 			}
 			strcpy(sStr, pConfiguration->GetHttpBase());
-			strcat(sStr, sResource);
+	        strcat(sStr, sResource);
 			SendFile(sStr);
 			break;
 		}
@@ -166,7 +166,7 @@ VOID CHttpClient::SendFile(LPSTR lpsFilename)
       unsigned long long Big;
         struct {
             DWORD Low;
-            DWORD High;
+            DWORD High; 
         } u;
     } nTotalBytes;
 	DWORD nBytesToRead;
@@ -175,16 +175,16 @@ VOID CHttpClient::SendFile(LPSTR lpsFilename)
 
 	// Try to open file
     hFile = CreateFileA(lpsFilename,
-        GENERIC_READ,               // Open for reading
-        FILE_SHARE_READ,            // Share for reading
-        NULL,                       // No security
-        OPEN_EXISTING,              // Existing file only
-        FILE_ATTRIBUTE_NORMAL,      // Normal file
-        NULL);                      // No attr. template
-    if (hFile == INVALID_HANDLE_VALUE) {
+        GENERIC_READ,               // Open for reading 
+        FILE_SHARE_READ,            // Share for reading 
+        NULL,                       // No security 
+        OPEN_EXISTING,              // Existing file only 
+        FILE_ATTRIBUTE_NORMAL,      // Normal file 
+        NULL);                      // No attr. template 
+    if (hFile == INVALID_HANDLE_VALUE) { 
         // File not found
         Report("404 Not Found", HttpMsg404);
-        return;
+        return; 
     }
     // Get file size
     nTotalBytes.u.Low = GetFileSize(hFile, &nTotalBytes.u.High);
@@ -212,7 +212,7 @@ VOID CHttpClient::SendFile(LPSTR lpsFilename)
 		return;
 	}
 
-    SendText("HTTP/1.1 200 OK");
+	SendText("HTTP/1.1 200 OK");
     SendText("Server: ROSHTTPD");
     SendText("MIME-version: 1.0");
     SendText("Content-Type: text/plain");
@@ -251,7 +251,7 @@ VOID CHttpClient::SendFile(LPSTR lpsFilename)
 		// We can't send an error message here as we are in the process of sending a file.
 		// We have to terminate the connection instead
 		Close();
-
+	
 	// Free allocated memory
 	free(lpsBuffer);
 
@@ -260,11 +260,11 @@ VOID CHttpClient::SendFile(LPSTR lpsFilename)
 }
 
 // Report something to client
-VOID CHttpClient::Report(LPCSTR lpsCode, LPSTR lpsStr)
+VOID CHttpClient::Report(LPSTR lpsCode, LPSTR lpsStr)
 {
     CHAR sTmp[128];
     CHAR sTmp2[16];
-
+	
     strcpy(sTmp, "HTTP/1.1 ");
     strcat(sTmp, lpsCode);
     SendText(sTmp);
@@ -407,9 +407,9 @@ BOOL CHttpDaemon::Start()
 	SetPort(pConfiguration->GetPort());
 
 	Open();
-
+	
 	State = hsRunning;
-
+	
     return TRUE;
 }
 
@@ -449,7 +449,7 @@ VOID CHttpDaemon::OnAccept(LPCServerClientThread lpThread)
 VOID CHttpDaemonThread::Execute()
 {
 	MSG Msg;
-
+	
 	try {
 		Daemon = NULL;
 		Daemon = new CHttpDaemon;

apps/utils/net/roshttpd/include/config.h

@@ -0,0 +1,49 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        include/config.h
+ */
+#ifndef __CONFIG_H
+#define __CONFIG_H
+
+#include <list.h>
+#include <httpd.h>
+
+// General constants
+#define APP_DESCRIPTION _T("ReactOS HTTP Daemon")
+
+// Default configuration
+#define dcfgDescription     _T("Default configuration")
+#define dcfgMainBase        _T("C:\\roshttpd\\")
+#define dcfgHttpBase        "C:\\roshttpd\\HttpBase\\"
+#define dcfgDefaultResource "index.html"
+#define dcfgDefaultPort     80
+
+class CConfig {
+public:
+	CConfig();
+	~CConfig();
+	VOID Default();
+	VOID Clear();
+	BOOL Load();
+	BOOL Save();
+	LPWSTR GetMainBase();
+	VOID SetMainBase(LPWSTR lpwsMainBase);
+	LPSTR GetHttpBase();
+	VOID SetHttpBase(LPSTR lpsHttpBase);
+	CList<LPSTR>* GetDefaultResources();
+    USHORT GetPort();
+    VOID SetPort(USHORT wPort);
+private:
+	VOID Reset();
+	LPWSTR MainBase;
+	LPSTR HttpBase;
+	CList<LPSTR> DefaultResources;
+    USHORT Port;
+};
+typedef CConfig* LPCConfig;
+
+extern LPCConfig pConfiguration;
+extern LPCHttpDaemonThread pDaemonThread;
+
+#endif /* __CONFIG_H */

apps/utils/net/roshttpd/include/debug.h

@@ -0,0 +1,17 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        include/debug.h
+ */
+#ifndef __DEBUG_H
+#define __DEBUG_H
+
+#include <stdio.h>
+
+#ifdef DBG
+#define DPRINT(x...)    printf(x)
+#else
+#define DPRINT(x...)
+#endif
+
+#endif /* __DEBUG_H */

apps/utils/net/roshttpd/include/httpd.h

@@ -6,8 +6,8 @@
 #ifndef __HTTPD_H
 #define __HTTPD_H
 
-#include <socket.h>
 #include <thread.h>
+#include <socket.h>
 #include <http.h>
 
 #define HTTPD_START     WM_USER + 1
@@ -37,7 +37,7 @@ public:
 	void SplitResource(const LPSTR lpsResource, LPSTR lpsPath, LPSTR lpsFilename, LPSTR lpsExtension);
     void ProcessRequest();
     void SendFile(const LPSTR lpsFilename);
-    void Report(LPCSTR lpsCode, const LPSTR lpsStr);
+    void Report(const LPSTR lpsCode, const LPSTR lpsStr);
 private:
 	BOOL bStop;
 	LPSTR lpsBuffer;

apps/utils/net/roshttpd/include/iterator.h

@@ -11,8 +11,6 @@
 template <class Item>
 class CIterator {
 public:
-	virtual ~CIterator()
-	{}
 	virtual VOID First() = 0;
 	virtual VOID Next() = 0;
 	virtual BOOL IsDone() const = 0;

apps/utils/net/roshttpd/include/list.h

@@ -0,0 +1,233 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS HTTP Daemon
+ * FILE:        include/list.h
+ */
+#ifndef __LIST_H
+#define __LIST_H
+
+#include <windows.h>
+#include <iterator.h>
+
+class CListNode {
+public:
+	CListNode();
+	CListNode(VOID *element, CListNode *next, CListNode *prev);
+	~CListNode() {};
+    void* operator new(/*size_t s*/ UINT s);
+    VOID  operator delete(void* p);
+
+	VOID SetElement(PVOID element);
+	VOID SetNext(CListNode *next);
+	VOID SetPrev(CListNode *prev);
+	PVOID GetElement();
+	CListNode *GetNext();
+	CListNode *GetPrev();
+private:
+	PVOID Element;
+	CListNode *Next; 
+	CListNode *Prev;
+    static HANDLE hHeap;
+    static INT nRef;
+};
+
+template <class Item> class CList {
+public:
+	//CList(CList&);
+	CList();
+	~CList();
+	CList& operator=(CList&);
+	
+	CIterator<Item> *CreateIterator() const;
+	LONG Count() const;
+	Item& Get(const LONG index) const;
+	// Can throw bad_alloc
+	VOID Insert(Item& element);
+	VOID Remove(Item& element);
+	VOID RemoveAll();
+	CListNode *GetHeader() const;
+	CListNode *GetTrailer() const;
+private:
+	CListNode *Search(Item& element) const;
+	LONG NodeCount;
+	CListNode *Header;
+	CListNode *Trailer;
+};
+
+template <class Item> class CListIterator : public CIterator<Item> {
+public:
+	CListIterator(const CList<Item> *list);
+	virtual VOID First();
+	virtual VOID Next();
+	virtual BOOL IsDone() const;
+	virtual Item CurrentItem() const;
+private:
+	const CList<Item> *List;
+	CListNode *Current;
+};
+
+// ****************************** CList ******************************
+
+// Default constructor
+template <class Item>
+CList<Item>::CList()
+{
+	// Create dummy nodes
+	Trailer = new CListNode;
+	Header = new CListNode;
+	Header->SetNext(Trailer);
+	Trailer->SetPrev(Header);
+}
+
+// Default destructor
+template <class Item>
+CList<Item>::~CList()
+{	
+	RemoveAll();
+	delete Trailer;
+	delete Header;
+}
+
+// Create an iterator for the list
+template <class Item>
+CIterator<Item> *CList<Item>::CreateIterator() const
+{
+	return new CListIterator<Item>((CList<Item> *) this);
+}
+
+// Return number of elements in list
+template <class Item>
+LONG CList<Item>::Count() const
+{
+	return NodeCount;
+}
+
+// Return element at index
+template <class Item>
+Item& CList<Item>::Get(const LONG index) const
+{
+	CListNode *node;
+
+	if ((index < 0) || (index >= NodeCount))
+		return NULL;
+
+	node = Header;
+	for (int i = 0; i <= index; i++)
+		node = node->GetNext();
+
+	return (Item *) node->GetElement();
+}
+
+// Insert an element into the list
+template <class Item>
+VOID CList<Item>::Insert(Item& element)
+{
+	CListNode *node;
+
+	node = new CListNode((PVOID)element, Trailer, Trailer->GetPrev());
+	Trailer->GetPrev()->SetNext(node);
+	Trailer->SetPrev(node);
+	NodeCount++;
+}
+
+// Remove an element from the list
+template <class Item>
+VOID CList<Item>::Remove(Item& element)
+{
+	CListNode *node;
+
+	node = Search(element);
+	if (node != NULL) {
+		node->GetPrev()->SetNext(node->GetNext());
+		node->GetNext()->SetPrev(node->GetPrev());
+		NodeCount--;
+		delete node;
+	}
+}
+
+// Remove all elements in list
+template <class Item>
+VOID CList<Item>::RemoveAll()
+{
+	CListNode *node;
+	CListNode *tmp;
+
+	node = Header->GetNext();
+	while (node != Trailer) {
+		tmp = node->GetNext();
+		delete node;
+		node = tmp;
+	} 
+	Header->SetNext(Trailer);
+	Trailer->SetPrev(Header);
+	NodeCount = 0;
+}
+
+// Return header node
+template <class Item>
+CListNode *CList<Item>::GetHeader() const
+{
+	return Header;
+}
+
+// Return trailer node
+template <class Item>
+CListNode *CList<Item>::GetTrailer() const
+{
+	return Trailer;
+}
+
+// Searches for a node that contains the element. Returns NULL if element is not found
+template <class Item>
+CListNode *CList<Item>::Search(Item& element) const
+{
+	CListNode *node;
+
+	node = Header;
+	while (((node = node->GetNext()) != Trailer) && (node->GetElement() != element));
+	if (node != Trailer)
+		return node;
+	else
+		return NULL;
+}
+
+
+// ************************** CListIterator **************************
+
+// Default constructor
+template <class Item>
+CListIterator<Item>::CListIterator(const CList<Item> *list) : List(list)
+{
+	First();
+}
+
+// Go to first element in list
+template <class Item>
+VOID CListIterator<Item>::First()
+{
+	Current = List->GetHeader()->GetNext();
+}
+
+// Go to next element in list
+template <class Item>
+VOID CListIterator<Item>::Next()
+{
+	if (!IsDone())
+		Current = Current->GetNext();
+}
+
+// Return FALSE when there are more elements in list and TRUE when there are no more
+template <class Item>
+BOOL CListIterator<Item>::IsDone() const
+{
+	return (Current == List->GetTrailer());
+}
+
+// Return current element
+template <class Item>
+Item CListIterator<Item>::CurrentItem() const
+{
+	return IsDone()? NULL : (Item) Current->GetElement();
+}
+
+#endif /* __LIST_H */

apps/utils/net/roshttpd/include/socket.h

@@ -5,7 +5,8 @@
  */
 #ifndef __SOCKET_H
 #define __SOCKET_H
-#include <stdio.h>
+#include <msvcrt/stdio.h>
+#include <windows.h>
 #include <winsock2.h>
 #include <thread.h>
 #include <list.h>
@@ -82,9 +83,9 @@ public:
     virtual VOID SetPort( UINT nPort) {};
 	virtual VOID Open();
 	virtual VOID Close();
-	virtual INT Transmit( LPCSTR lpsBuffer,  UINT nLength) { return 0; };
+	virtual INT Transmit( LPSTR lpsBuffer,  UINT nLength) { return 0; };
 	virtual INT Receive(LPSTR lpsBuffer,  UINT nLength) { return 0; };
-	virtual INT SendText( LPCSTR lpsStr) { return 0; };
+	virtual INT SendText( LPSTR lpsStr) { return 0; };
 protected:
 	SOCKET Socket;
 	SOCKADDR_IN SockAddrIn;
@@ -100,9 +101,9 @@ public:
 	CServerClientSocket() {};
 	CServerClientSocket(LPCServerSocket lpServerSocket);
 	CServerSocket *GetServerSocket();
-	virtual INT Transmit( LPCSTR lpsBuffer,  UINT nLength);
+	virtual INT Transmit( LPSTR lpsBuffer,  UINT nLength);
 	virtual INT Receive(LPSTR lpsBuffer,  UINT nLength);
-	virtual INT SendText( LPCSTR lpsText);
+	virtual INT SendText( LPSTR lpsText);
 	virtual VOID MessageLoop();
 	virtual VOID OnRead() {};
 	//virtual VOID OnWrite() {};

apps/utils/net/roshttpd/makefile

@@ -0,0 +1,31 @@
+# $Id$
+
+PATH_TO_TOP = ../../../..
+
+TARGET_PATH = common
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = roshttpd
+
+TARGET_CPPFLAGS = -I./include -DUNICODE -D_UNICODE -DDBG -D__USE_W32API -Wno-deprecated
+
+TARGET_GCCLIBS = stdc++
+
+TARGET_SDKLIBS = kernel32.a ws2_32.a user32.a
+
+MAIN_OBJECTS = roshttpd.o config.o error.o http.o httpd.o
+
+COMMON_OBJECTS = common/list.o common/socket.o common/thread.o
+
+TARGET_OBJECTS = $(MAIN_OBJECTS) $(COMMON_OBJECTS)
+
+TARGET_CLEAN = common/*.o
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk
+
+# EOF

apps/utils/net/route/makefile

@@ -0,0 +1,19 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = route
+
+TARGET_INSTALLDIR = system32
+
+TARGET_SDKLIBS = ws2_32.a iphlpapi.a ntdll.a
+
+TARGET_OBJECTS = $(TARGET_NAME).o
+
+TARGET_GCCLIBS = 
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk

apps/utils/net/route/route.c

@@ -0,0 +1,157 @@
+/* Poor man's route
+ *
+ * Supported commands:
+ *
+ * "print"
+ * "add" target ["mask" mask] gw ["metric" metric]
+ * "delete" target gw
+ *
+ * Goals:
+ *
+ * Flexible, simple
+ */
+
+#include <stdio.h>
+#include <windows.h>
+#include <iphlpapi.h>
+#include <winsock2.h>
+
+#define IPBUF 17
+#define IN_ADDR_OF(x) *((struct in_addr *)&(x))
+
+int usage() {
+    fprintf( stderr, 
+	     "route usage:\n"
+	     "route print\n"
+	     "  prints the route table\n"
+	     "route add <target> [mask <mask>] <gw> [metric <m>]\n"
+	     "  adds a route\n"
+	     "route delete <target> <gw>\n"
+	     "  deletes a route\n" );
+    return 1;
+}
+
+int print_routes() {
+    PMIB_IPFORWARDTABLE IpForwardTable;
+    DWORD Error;
+    ULONG Size = 0;
+    char Destination[IPBUF], Gateway[IPBUF], Netmask[IPBUF], 
+	Index[IPBUF], Metric[IPBUF];
+    int i;
+
+    if( (Error = GetIpForwardTable( NULL, &Size, TRUE )) ==
+    	ERROR_INSUFFICIENT_BUFFER ) {
+	IpForwardTable = malloc( Size );
+	Error = GetIpForwardTable( IpForwardTable, &Size, TRUE );
+    }
+
+    if( Error == ERROR_SUCCESS ) {
+	printf( "%-16s%-16s%-16s%-10s%-10s\n", 
+		"Destination",
+		"Netmask",
+		"Gateway",
+		"Index",
+		"Metric" );
+	for( i = 0; i < IpForwardTable->dwNumEntries; i++ ) {
+	    strcpy( Destination,
+		    inet_ntoa( IN_ADDR_OF(IpForwardTable->table[i].
+		    		dwForwardDest) ) );
+	    strcpy( Netmask,
+		    inet_ntoa( IN_ADDR_OF(IpForwardTable->table[i].
+		    		dwForwardMask) ) );
+	    strcpy( Gateway,
+		    inet_ntoa( IN_ADDR_OF(IpForwardTable->table[i].
+		    		dwForwardNextHop) ) );
+
+	    printf( "%-16s%-16s%-16s%-10d%-10d\n", 
+		    Destination,
+		    Netmask,
+		    Gateway,
+		    IpForwardTable->table[i].dwForwardIfIndex,
+		    IpForwardTable->table[i].dwForwardMetric1 );
+	}
+
+	free( IpForwardTable );
+
+	return ERROR_SUCCESS;
+    } else {
+	fprintf( stderr, "Route enumerate failed\n" );
+	return Error;
+    }
+}
+
+int convert_add_cmd_line( PMIB_IPFORWARDROW RowToAdd, 
+			  int argc, char **argv ) {
+    int i;
+
+    if( argc > 1 ) RowToAdd->dwForwardDest = inet_addr( argv[0] );
+    else return FALSE;
+    for( i = 1; i < argc; i++ ) {
+	if( !strcasecmp( argv[i], "mask" ) ) {
+	    i++; if( i >= argc ) return FALSE;
+	    RowToAdd->dwForwardMask = inet_addr( argv[i] );
+	} else if( !strcasecmp( argv[i], "metric" ) ) {
+	    i++; if( i >= argc ) return FALSE;
+	    RowToAdd->dwForwardMetric1 = atoi( argv[i] );
+	} else {
+	    RowToAdd->dwForwardNextHop = inet_addr( argv[i] );
+	}
+    }
+
+    return TRUE;
+}
+
+int add_route( int argc, char **argv ) {
+    MIB_IPFORWARDROW RowToAdd = { 0 };
+    DWORD Error;
+
+    if( argc < 2 || !convert_add_cmd_line( &RowToAdd, argc, argv ) ) {
+	fprintf( stderr, 
+		 "route add usage:\n"
+		 "route add <target> [mask <mask>] <gw> [metric <m>]\n"
+		 "  Adds a route to the IP route table.\n"
+		 "  <target> is the network or host to add a route to.\n"
+		 "  <mask>   is the netmask to use (autodetected if unspecified)\n"
+		 "  <gw>     is the gateway to use to access the network\n"
+		 "  <m>      is the metric to use (lower is preferred)\n" );
+	return 1;
+    }
+    
+    if( (Error = CreateIpForwardEntry( &RowToAdd )) == ERROR_SUCCESS ) 
+	return 0;
+    
+    fprintf( stderr, "Route addition failed\n" );
+    return Error;
+}
+
+int del_route( int argc, char **argv ) {
+    MIB_IPFORWARDROW RowToDel = { 0 };
+    DWORD Error;
+
+    if( argc < 2 || !convert_add_cmd_line( &RowToDel, argc, argv ) ) {
+	fprintf( stderr, 
+		 "route delete usage:\n"
+		 "route delete <target> <gw>\n"
+		 "  Removes a route from the IP route table.\n"
+		 "  <target> is the network or host to add a route to.\n"
+		 "  <gw>     is the gateway to remove the route from.\n" );
+	return 1;
+    }
+    
+    if( (Error = DeleteIpForwardEntry( &RowToDel )) == ERROR_SUCCESS ) 
+	return 0;
+    
+    fprintf( stderr, "Route addition failed\n" );
+    return Error;
+}
+
+int main( int argc, char **argv ) {
+    if( argc < 2 ) return usage();
+    else if( !strcasecmp( argv[1], "print" ) ) 
+	return print_routes();
+    else if( !strcasecmp( argv[1], "add" ) ) 
+	return add_route( argc-2, argv+2 );
+    else if( !strcasecmp( argv[1], "delete" ) ) 
+	return del_route( argc-2, argv+2 );
+    else return usage();
+}

apps/utils/net/telnet/Makefile

@@ -0,0 +1,41 @@
+PATH_TO_TOP = ../../../..
+
+TARGET_TYPE = program
+
+TARGET_APPTYPE = console
+
+TARGET_NAME = telnet
+
+TARGET_INSTALLDIR = system32
+
+TARGET_SDKLIBS = ws2_32.a
+
+TARGET_CPPFLAGS = -D__REACTOS__ -D__USE_W32API -Wall
+
+TARGET_GCCLIBS = stdc++
+
+TARGET_OBJECTS = \
+	src/ansiprsr.o \
+	src/keytrans.o \
+	src/tcharmap.o \
+	src/tconsole.o \
+	src/tkeydef.o \
+	src/tkeymap.o \
+	src/tmapldr.o \
+	src/tmouse.o \
+	src/tnclass.o \
+	src/tnclip.o \
+	src/tncon.o \
+	src/tnconfig.o \
+	src/tnerror.o \
+	src/tnetwork.o \
+	src/tnmain.o \
+	src/tnmisc.o \
+	src/tscript.o \
+	src/tscroll.o \
+	src/ttelhndl.o
+
+
+include $(PATH_TO_TOP)/rules.mak
+
+include $(TOOLS_PATH)/helper.mk