1. Unit OS C: Interoperability
C.2. Programming
Windows Operating System Internals - by David A. Solomon and Mark E. Russinovich with Andreas Polze

2. Copyright Notice © 2000-2005 David A. Solomon and Mark Russinovich
These materials are part of the Windows Operating System Internals Curriculum Development Kit, developed by David A. Solomon and Mark E. Russinovich with Andreas Polze
Microsoft has licensed these materials from David Solomon Expert Seminars, Inc. for distribution to academic organizations solely for use in academic environments (and not for commercial use)

3. Roadmap for Section C.2 UNIX Environments on Windows
Approaches to UNIX Programming on Windows
Interix - the POSIX Subsystem for Windows
Common Desktop, Filesystem, IPC
Interix in Action: /proc-fs, gcc, truss, ksh, csh
Integration scenarios: X11 on Windows
Cygwin Compatibility Library and tools
UWIN from ATT Research
MKS Compatibility Toolkit
A Windows compatibility library can be hosted on UNIX or a POSIX compatibility library can be hosted on top of the Windows subsystem. Several commercial products and open source projects do just this. Although Microsoft‘s Visual C++ development environment includes a limited compatibility library, we are focusing here on alternative approaches.
Microsoft provides a full POSIX subsystem for Windows OS under the product name Interix. Interix replaces the original POSIX subsystem on Windows It provides full network support for POSIX application and allows for interoperability between POSIX and Windows subsystems (CreateProcess()). The Interix subsystems is bundled with Windows implementations of many essential UNIX tools (including X11R6 clients).
In addition, we discuss Cygwin (Cygnus Solutions), UWIN (ATT Research), and the MKS toolkit (Mortice Kern Systems) compatibility solutions.

4. UNIX Programming on Windows
Interix - POSIX subsystem for Windows
Part of Services for UNIX 3.5
Applicable to Windows NT/2000/XP/2003
Compatibility libraries for Windows-API:
Applicable to all Windows variants
Visual Studio libraries for C/C++
Cygwin library and runtime
UWIN library and runtime
MKS toolkit (Mortice Kern Systems)
Virtual Machine Environments
VMware (Intel only), VirtualPC (Intel + PowerPC)

5. The Interix Subsystem as part of Windows Services for UNIX 3.5
A full POSIX subsystem for Windows
Interix replaces the original POSIX subsystem on Windows NT, Windows 2000, Windows XP, and Windows Server 2003
Full network support
Interoperability between POSIX and Windows subsystems (CreateProcess())
Bundled with many essential UNIX tools (including X11R6 clients)
From Windows Server 2003 R2 forward SFU does not apply and will be blocked from installing
Microsoft acquired Softway Systems, the makers of Interix on Sept. 17, 1999
Interix allows to run UNIX applications and scripts on Windows.
Interix is now shipped as part of Services for Unix 3.5
A little Softway history:
Softway Systems was started in September 1995 concurrent with a unique source license from MS that enabled Softway to take the MS POSIX subsystem (which was a GREAT proof-of-concept), and make it real in INTERIX.
When Softway were done they had shipped ~40,000 paid seats.
The product was originally shipped under the technology brand of “OpenNT”. It was rebranded as INTERIX in the Spring of 1998.
Softway had strategic relationships with Dell (every government workstation and server were bundled with Softway INTERIX Workstation-Lite) and UNISYS for certain government platforms.
“Run UNIX applications and scripts on Windows NT” means that one recompiles the source code of any programs as a native NT binary that behaves correctly (as if it was UNIX). This is not a binary emulation product.

6. Interix Features KornShell, C Shell and Bourne Shell
with full job control
Over 300 utilities,
including scripting tools such as awk, sed, perl, Tcl/Tk
Berkeley System Distribution (BSD)
sockets mapped to Winsock
Memory-mapped files
System V (SVID) interprocess communication (IPC):
semaphores, message queues and shared memory
UNIX Look and Feel:
Pseudo-terminal support
Color curses support
Ability to execute Windows applications from Interix
Full tty semantics mapped to console windows
File-link support and true case-sensitive file names

7. Interix Features (contd.)
Full integration with Windows security model, administration, file systems, networking and printers
Support for POSIX.1 (system services) and POSIX.2 (shell and utilities)
X11R6 + X11R5 runtime, including X clients:
xterm, twm, xrdb, and xlsclients
Support for daemons (inetd) running as Windows services
telnetd & rlogind services (multiuser login support)
Berkeley r-utilities (servers and clients)
cron, syslogd & other daemon/service support
Internet clients: ftp, telnet, ping, rsh
Integrated tape device support

8. Interix Software Development Kit
Development tools, including
make, RCS, lex, yacc, cc, c89, nm, ar, strip
ANSI C, POSIX.1 and POSIX.2 interfaces
Color curses library
BSD-style sockets library support
pthread implementation
X11R6 + X11R5 libraries and header files
gcc (GNU C) compiler (gcc 3.3)
g++ (GNU C++) compiler
g77 (GNU FORTRAN77) compiler
Support for Microsoft Visual C/C++

9. Interix - The POSIX Subsystem for Windows
Environment Subsystems
System
& Service Processes
User
Application
Subsystem DLL
Windows
POSIX
OS/2
User
Mode
Kernel
Windows
Executive
Windows NT 3.51 and Windows NT 4 shipped all three subsystems: Windows, OS/2, POSIX. Windows 2000 shipped the Windows and POSIX subsystems only. With Windows 2000, a much improved version of the POSIX subsystem became available as an add-on: Interix. Windows XP and Windows Server 2003 ship the Windows subsystem only. However, Interix got integrated with Services for Unix - this product now contains the POSIX subsystem for Windows XP/Server 2003 (I.e.; NT 5.2, 5.3).
Windows
User/GDI
Device
Driver
Device Drivers
Kernel
Hardware Abstraction Layer (HAL)

10. Interix/Windows API Integration
Common
Desktop
Interix
App
Win
App
Interix
App
Win
App
Pipes, sockets
Shared memory
Win32exec
COM
Interix
Subsystem
Windows
Subsystem
Windows Kernel
Common
File
Systems
INTERIX and Windows are well integrated across:
The desktop
IPC mechanisms (Pipes, sockets, shared memory).
Scripting and execution (Win32exec)
COM
File systems
CDFS
NTFS
FAT

11. Common Desktop
Interix shell appears in a console window with standard controls
Cut-and-paste support between Interix, Windows, & X11 applications
Launch Interix applications from a desktop icon or menu
Standard Windows tools apply
InstallShield, etc.

12. Common File System Interix supports NTFS, FAT, CDFS.
NTFS provides case sensitive filenames, group ownership, file modes (ACLs) and hard links
Windows groups to UNIX uid/gid mapping
NTFS I/O operation audit features are available to ported UNIX apps on Interix
% id
uid=197611(andreas) gid=197121(None) groups=197121(None), 65792(+Everyone), 1976
14(Debugger Users), (+Administrators), (+Users), 66820(+INTERACTIVE)
, 66827(+Authenticated Users), 4095(CurrentSession), 66048(+LOCAL) %
% who am I
andreas ttyn Dec 5 20:51
NTFS supports all the functionality of a UNIX file system (case sensitivity, hard links, etc.) but you can’t see that from the Windows subsystem. INTERIX exposes that properly. For example, UNIX file mode bits are nothing more than an interpretation of the ACEs in the file ACL. Security is maintained by the kernel for INTERIX just as for everything else. There is no container file system.

13. Common Execution Environment
Interix applications can fork/exec Windows applications
Can shell script Windows apps
ksh and csh are supported
Used in the product in lp and cc
Interix implements UNIX directory hierarchy
/usr, /bin, /sbin, /etc, /dev …
Mapping for drive letters: /dev/fs/C/…
/proc file system - statistics about Windows + Interix apps
Windows apps explicitly for the UNIX environment
When UNIX creates a new process (fork) it is a replica of the “parent” that created it, until typically a new program is overlaid (exec). INTERIX will happily exec Windows programs as well as other INTERIX programs. This means one can write shell scripts using Windows apps as well.
We do exactly this in INTERIX itself: why create a lot of non-standard UNIX-type printer interfaces in the INTERIX world when the “lp” command can be a simple shell script around the PRINT.EXE command.
Likewise, we did a similar thing with the “mt” command which is used in the UNIX world to manage tape drives. Instead of adding a lot of non-standard UNIX-type tape device interfaces to INTERIX we wrote the mt command as a Windows command line tool that uses the Windows tape drive interfaces, and looks like and behaves exactly like the UNIX command. Users never know which subsystem they’re running on.

14. /proc filesystem in action
Demo: list active processes via ksh-script
/proc/$pid/cmdline contains 0-terminated list of arguments for each process on the system $
$ for pid in `ls /proc`
> do
> echo "$pid\t\c"
> cat /proc/$pid/cmdline | \
tr "\000" "\n" | \
tail -n 1
> done
IdleProcess
C:\WINDOWS\system32\spoolsv.exe
C:\WINDOWS\VMADD\VMSRVC.EXE
C:\WINDOWS\system32\nfsclnt.exe
"C:\Program Files\Common Files\Microsoft Shared\VS7Debug\mdm.exe"
C:\SFU\common\rshsvc.exe sh
C:\WINDOWS\System32\VPCMap.exe
C:\WINDOWS\system32\PSXRUN.EXE
C:\WINDOWS\System32\alg.exe
C:\WINDOWS\system32\psxss.exe
C:\SFU\Mapper\mapsvc.exe
/usr/sbin/cron
C:\WINDOWS\system32\wscntfy.exe
C:\WINDOWS\System32\svchost.exe -k HTTPFilter
"C:\WINDOWS\system32\posix.exe" /u /c /bin/csh -l
/usr/sbin/init
\SystemRoot\System32\smss.exe …
The script’s output (shortened)

15. Interix with gcc and truss in action
% truss ./hello
tracing pid 3591
getdata() getdata returned 0
getrlimit() getrlimit returned 0
pthread_inform_signals() pthread_inform_signals returned 0
unixpath2win() unixpath2win returned 0
getids() getids returned 0
open("/usr/lib/libc.so.3.5", 0x1) open returned 3
read(3, 0x81EC18, 4096) read returned x1000
close(3) close returned 0
fstat(1, 0xC60710, 0x0) fstat ret: 0 dev: 0x0 ino: 0x
isatty(1) isatty returned 0
write(1, 0x124418, 14) Hello Interix
write returned 14 0xE
lseek(0, 1, 0) lseek returned 0
lseek(0, 0, 0) lseek returned 0
exit(14) process exited with status 14 %
% cat > hello.c
# include <stdio.h>
main () {
printf("Hello Interix\n"); }
^D%
% gcc hello.c -o hello
% file hello
hello: Windows NT PE format (EXE), dynamically linked executable not stripped In
tel Posix-CUI
% pwd
/dev/fs/C/Documents and Settings/andreas

16. Interprocess Communication
Applications can share data between subsystems via
Pipes
Sockets (Local and Remote)
Shared Memory (Windows mapped files to System V shared memory)
Same sort of magic here:
In a shell script I can pipe the output from a Windows command into an INTERIX UNIX command.
Sockets are used in multiple ways: An INTERIX X11 client like xterm uses sockets to talk to a Win32-based X11 server (local or remote) to display on the desktop. The INTERIX based port of the Apache web server uses sockets to talk to any Win32 client anywhere on the network.
Shared memory is a quick way to open up a megabit per second channel between applications running in the INTERIX and new apps in the Windows world.

17. INTERIX Integration with COM (Example App)
Existing X11
Graphical
Application
Existing UNIX
Character-based
Application
New Windows
Graphical
Application
xtide
UNIX X11 C
Application
tide
UNIX C
Application
TIDEWRAP.DLL
INTERIX COM
DLL Module
VBTIDE.EXE
TIDE.XLS
Visual Basic GUI
Or Excel Plug-in
This is a great example:
Directly port a UNIX app that embodies some key calculation. No need to understand how it works again. Write a Win32 COM DLL that understands how to invoke the ported app and capture it’s output. That COM DLL is now pluggable into all sorts of Windows things.
The example we demonstrate is a UNIX program called tide (and xtide for the X11 version) which calculates a week’s worth of ocean tide data for different points in its database. Tide and xtide simply port. The tidewrap.dll is a Win32 COM DLL that understands how to invoke the ported application.
We have a simple VB forms app that the tidewrap.dll plugs into as well as an Excel spreadsheet that then uses the tide data to produce a graph using the Excel graphing facility.
Customers
Preserve the use of their key business applications. Preserve the investment in the key application’s development. Gain the Windows TCO.
INTERIX Subsystem
Windows Subsystem
Windows Kernel

18. Virtual PC + Interix + X11

19. Local X server for SFU 3.5
Starnet Communications offers Free X Server Download
X-Win32 LX complements SFU 3.5 by enabling the display of local X Windows applications

20. UNIX Integration in Windows Server 2003 R2
New Subsystem for UNIX Applications (SUA)
An extensively upgraded subsystem derived from the Interix subsystem
Biggest change: SUA permits UNIX applications it hosts to also make Win32 API calls
OCI and ODBC connectivity
Visual Studio Debugger Extension
64-bit Application Support
This feature is supported and tested for accessing the Oracle oci.dll library and for accessing the Windows standard ODBC library
The functionality in SUA is similar to what Interix did in SFU. SUA allows you to compile and run native UNIX programs and scripts on Windows Server 2003 R2. The Interix subsystem was added to SFU in version 3.0 when it replaced the MKS derived Korn Shell and utilities. These earlier shell and utilities were simply emulation layers running on top of the Windows operating system.SUA is a fully new system which takes advantage of several performance improvements. Compared to past versions, SUA is considerably faster

21. SUA Architecture Full Subsystem, not an Emulator
UNIX
applications
Win32®
Complete UNIX subsystem on the Windows Kernel
Ability to access Win32 from SUA applications
The Windows operating system is architected so that any single program has available to it only the APIs from one "personality" of the platform at a time. That is, a single program can use either SUA APIs or Windows APIs but not both. But if you think about an application as a collection of one or more programs which work together to provide some service or benefit, it's possible for some application to use both Windows APIs and SUA APIs to do its job. To make that work, it has to be possible for these distinct programs to work together.
The SUA, Win32, and .NET Framework interfaces all provide access to functionality in the single Windows operating system kernel that supports them all. Any "kernel" functions, then, should be easily shared: files, process invocation, networking, and memory fall into this category. The SUA environment takes care of connecting Unix and Windows pipes together to allow data to be shared that way as well. Finally, with some creative use of "glue" software, it's possible to wrap entire SUA programs inside COM objects or expose them through XML-based Web Services. Through the use of these integration techniques, an application can be ported so that each component is implemented in the Windows environment most suited to it and to its future evolution.

22. UNIX Integration in Windows Server 2003 R2 (contd.)
Active Directory Services
NIS schema and Kerberos authentication extensions
Identity Management for UNIX
Administration Components
Password Synchronization
Server For NIS
Other Network File and Print Services
Microsoft Services for NFS
Mapping Server
NFS AdminUI + NFS client + NFS server
Portmap + RpcXdr
Server for NFS Authentication

23. Windows Server 2003 R2 UNIX SDKs and Tools
The following are available for download:
Utilities and SDK for UNIX-based Applications
Base Utilities
SVR-5 Utilities
Base SDK
GNU SDK
GNU Utilities
UNIX Perl
Visual Studio Debugger Add-in

24. Cygwin compatibility library – principles and problems
Cygwin DLL is loaded into an application's text segment
UNIX kernel emulation
Needs access to all processes running under it
First Cygwin DLL to run creates shared memory areas that other processes using separate instances of the DLL can access
Keeping track of open file descriptors and assisting fork/exec
Per-process structures for process id, user id, signal masks, etc.
Potential security hole - shared memory region writable to all processes
Cygwin is a full-featured Win32 porting layer for UNIX applications, compatible with all Win32 hosts (currently Microsoft Windows 2000/NT, and Windows 95/98/ME). It was invented in 1995 by Cygnus Solutions as part of the answer to the question of how to port the GNU development tools to the Win32 host.
The Win32-hosted GNUPro compiler tools that use the library are available for a variety of embedded processors as well as a native version for writing Win32 programs. By basing this technology on the GNU tools, Cygnus provides developers with a high-performance, feature-rich 32-bit code development environment, including a graphical source-level debugger.
Cygwin is a Dynamic-Linked Library (DLL) that provides a large subset of the system calls found in common UNIX implementations. The current release includes all POSIX.1/90 calls except for setuid() and mkfifo(), all ANSI C standard calls, and many common BSD and SVR4 services including Berkeley sockets.

25. Highlights of Cygwin Functionality
Supporting both Windows NT/2000/XP and 9x
Cygwin runs as Windows app; not a subsystem
Permissions and Security
maps Windows file ownership and permissions to the more standard, older UNIX model
File Access
Windows- and POSIX-style paths
Using either forward or back slashes as the directory delimiter
Symbolic links are emulated by files containing a magic cookie followed by the path to which the link points
Text Mode vs. Binary Mode
compatibility at the expense of violating the POSIX standard that states that text and binary mode will be identical

26. Cygwin features (contd.)
Process Creation
The fork call in Cygwin is particularly interesting because it does not map well on top of the Windows API
Cygwin fork is a non-copy-on-write implementation similar to what was present in early flavors of UNIX
Signals
When a Cygwin process starts, the library starts a secondary thread for use in signal handling
This thread waits for Windows events used to pass signals
When a process notices it has a signal, it scans its signal bitmask and handles the signal in the appropriate fashion
Most standard UNIX signals are provided
Job control works as expected

27. Cygwin features (contd.)
Sockets
Socket-related calls in Cygwin are mapped onto Winsock
Cygwin has to perform winsock initialization when appropriate
Child proc. initialize winsock if any inherited file descriptor is a socket
Select
The UNIX select function is another call that does not map cleanly on top of the Windows-API
Windows select in Winsock only works on socket handles
Cygwin select works for different types of file descriptors (sockets, pipes, handles, and a custom /dev/windows Windows messages pseudo-device)

28. Software, that has been ported to Cygwin
libstdc++-v
lynx-2.8.2r1
mc , tcltk-8.3.1
Open PTC for Windows
perl-5.6.0
Perl, gdbm, cvs, and cygipc
PGPlot 5.2
Python headers for mingw
RPM 3.04, Lynx 2.8.3
RXVT
screen-3.9.8, xchat-1.6.0
Screen Saver Library
TCL/Tk 8.1
UCD SNMP
X11R6.4 Archive and Zyacc
XChat-text 1.5.7
Apache and php-4.0b2,
CD Recording Software
Data Plotting Library DISLIN 7.3
Differential X Protocol Compressor 3.8.0
DirectX
FreeCIV 1.8.0
gcc
Gimp for Win32
groff
IBM's OpenDX
Icarus Verilog
Insight debugger, pine, wget, info, other ports
Kerberos V4 eBones Distribution v1.0.3
LAPACK Libraries
LessTif
Install Cygwin now    

29. UWIN The UWIN package contains the following three elements:
Libraries that provide the UNIX Application Programming Interface (API)
Include files and development tools such as cc, yacc, lex, and make.
Korn Shell and over 200 utilities such as ls, sed, cp, stty etc.
(free non-commercial license)
The library functions are implemented in a DLL (POSIX.DLL)
Programs linked with POSIX.DLL run under the Windows subsystem instead of the POSIX subsystem
A cc command is provided to compile and link programs for UWIN on Windows
CC calls the Visual C/C++ compiler to perform the actual compilation and linking
The UWIN package provides a mechanism for building and running UNIX applications on Windows NT/2000/XP/2003, and Windows 95/98/ME with few, if any, changes necessary.
The UWIN package contains the following three elements:
Libraries that provide the UNIX Application Programming Interface (API)
Include files and development tools such as cc, yacc, lex, and make.
Korn Shell and over 200 utilities such as ls, sed, cp, stty etc.
The library functions are implemented as functions exported in a DLL (POSIX.DLL). Programs linked with POSIX.DLL run under the WIN32 subsystem instead of the POSIX subsystem. Thus programs can make UNIX library calls or any other WIN32 call as required. A cc command is provided to compile and link programs for UWIN on Windows NT. The cc command calls a Microsoft C compiler to perform the actual compilation and linking. The GNU compiler and development tools are also available for download with UWIN.

30. UWIN features Process control and management:
UWIN includes a spawn() family of functions that combines the functionality of fork/exec for efficiency; vfork() support
With exec(), an existing process can be overlaid with another process
Each process has a unique process id and belongs to a process group
File descriptor semantics:
Open files, pipes, sockets, fifos, and character and block special devices files have file descriptors associated with them
They can be duped and inherited with UNIX semantics
UNIX signal semantics:
Nearly all of the UNIX signals are provided including job control signals so that ksh can stop and restart jobs
A process can catch, block or ignore signals
Signals can be sent to processes or to process group
-D_BSDCOMPAT compiler flag for UCB UNIX signal semantics

31. UWIN features (contd.) Support for devices
Character and block devices with major and minor numbers
Support for direct access to floppy drives (/dev/fd0), and SCSI tape drives (/dev/mt0), as well as ptys and ttys
Terminal interface for consoles, sockets, and serial lines:
The POSIX termios interface is supported for consoles with vt100 emulation
UWIN supports pseudo-ttys
Desktop integration for console windows:
Select text, copy/paste to the clipboard
The /dev/clipboard pseudo-device can be used to redirect command input and output to the clipboard
The /dev/windows pseudo-device can be used within select() to block until mouse or keyboard events are received

32. UWIN features (contd.) UCB sockets based on WINSOCK:
Sockets are file descriptors and obey file descriptor semantics
Internet domain protocol (AF_INET) and UNIX domain sockets are provided
The multicast socket protocol is supported
Pathname mapping from UNIX to Windows:
UNIX style naming for all files with / as the delimiter by creating mounts.
Each drive letter in Windows is mounted in a single letter directory name under / so that /a/file is the UWIN name for a:\file.
Implicitly mounted directories:
/sys on the system directory,
/win on the windows directory, and
/msdev on the directory containing the Microsoft tools
Character and block special devices are in /dev
UWIN also supports UNC names for files that begin with //

33. UWIN features (contd.) UNIX naming conventions:
The PATH variable is a : separated list rather than a ; separated list
The cc command generates files with a .o suffix by default, etc
Mapping UNIX ids/permissions to Windows permissions:
Windows subject identifiers are mapped to UNIX user ids and group ids.
UNIX permissions are mapped onto Windows Windows file ACLs.
chown() to change the owner and or group of a file.
File control locking:
UNIX file control advisory locking is supported with deadlock detection.
Memory mapping and shared memory and System V IPC:
mmap(), System V shared memory, semaphores, message passing API
Runtime linking of dynamically linked libraries:
The dlopen(), dlsym() interface from System V Release 4 is provided
Errors returned by Windows API functions are mapped into UNIX errnos.

34. UWIN features (contd.) i-node numbers: Hard links Symbolic links
An i-node number is returned when reading a file and when stating a file
Hard links
Hard links are supported on both NTFS and FAT file systems
Symbolic links
Symbolic links to files and directories can be created in UWIN and are implemented as Windows shortcuts
A .lnk suffix will be appended to these file names but will not appear when reading directories with UWIN
Shortcuts created by Windows 9x and Windows NT/2k/XP appear as symbolic links in UWIN but do not have the .lnk suffix removed.
Fifo's
Fifo's (UNIX named pipes) can be created with mkfifo() and opened as an ordinary file

35. UWIN features (contd.) Setuid and setgid programs
Use chmod() to turn on setuid permission for a program.
The program must be on an NTFS file system.
inet Daemons and commands
UWIN 4.0 comes with the UCB inetd daemon, the telnet daemon, the rlogin daemon, and the rsh daemon.
It also includes the telnet, ftp, rsh, and rlogin programs.
The ssh daemon and program can be built from the source
Access of Registry through the File System
UWIN treats the Windows registry as a file system with registry keys treated as files, and keys that have sub-keys treated as directories.
You can use UWIN tools directly on registry keys. The registry is automatically mounted under /reg during startup.
Cron daemon
UWIN comes with a cron daemon that is used for running at and cron jobs
The cron daemon is started by /etc/rc on Windows

36. MKS Interoperability Products
Mortice Kern Systems -

37. MKS Toolkit for Developers Features
Over 300 UNIX and Windows command-line utilities
(full POSIX.2 specification).
MKS Korn shell (ksh) and MKS C shell (csh)
Command-line build utilities including
ar, cc, make, grep, vi.
Tools and utilities for manipulating HTML content (htdiff, htsplit, url, mkurl).
Web CGI scripting, and active Perl scripting (web, mkscgi, PScript™)
File system commands (mount, umount) and symbolic link support.
smtpmail and mapimail.
Win32 file and user security utilities (chacl, lsacl, su).
Utilities for setting up users, groups, and permissions on Windows
userinfo, groupinfo, member
Tape and archive commands
tar, pax, cpio, mt
UNIX-compatible backups.

38. NuTCracker Packaging MKS Toolkit features (contd.):
Commands to manipulate
device drivers,
Windows domains, and
file associations (dev, domain, ftype).
Remote utilities:
rsh, rexec, rcp, rlogin
Packaging:
NuTCRACKER Workstation, NuTCRACKER Server, Power User Utilities
MKS Toolkit contains the SCO XVision Eclipse X Server.
Hummingbird 3D OpenGL X Server
an add-on to MKS Toolkit for Enterprise Developers

39. Further Reading Windows Services for UNIX 3.5
UNIX Integration in Windows Server 2003 R2
Cygwin - Cygnus Solutions
UWIN - ATT Research
MKS toolkit - Mortice Kern Systems