# Cygwin Utilities

Cygwin comes with a number of command-line utilities that are used to manage the UNIX emulation portion of the Cygwin environment. While many of these reflect their UNIX counterparts, each was written specifically for Cygwin.

## cygcheck

    Usage: cygcheck [-s] [-v] [-r] [-h] [program ...]
      -s = system information
      -v = verbose output (indented) (for -s or programs)
      -r = registry search (requires -s)
      -h = give help about the info
    You must at least give either -s or a program name

The `cygcheck` program is a diagnostic utility that examines your system and reports the information that is significant to the proper operation of Cygwin programs. It can give information about a specific program (or program) you are trying to run, general system information, or both. If you list one or more programs on the command line, it will diagnose the runtime environment of that program or programs. If you specify the `-s` option, it will give general system information. If you specify `-s` and list one or more programs on the command line, it reports on both.

The `cygcheck` program should be used to send information about your system to Cygnus for troubleshooting (if your support representative requests it). When asked to run this command, include all the options plus any commands you are having trouble with, and save the output so that you can mail it to Cygnus, like this:

    C:\Cygnus> cygcheck -s -v -r -h > tocygnus.txt

The `-v` option causes the output to be more verbose. What this means is that additional information will be reported which is usually not interesting, such as the internal version numbers of DLLs, additional information about recursive DLL usage, and if a file in one directory in the PATH also occurs in other directories on the PATH.

The `-r` option causes `cygcheck` to search your registry for information that is relevent to Cygnus programs. These registry entries are the ones that have "Cygnus" in the name. If you are paranoid about privacy, you may remove information from this report, but please keep in mind that doing so makes it harder for Cygnus to diagnose your problems.

The `-h` option prints additional helpful messages in the report, at the beginning of each section. It also adds table column headings. While this is useful information, it also adds some to the size of the report, so if you want a compact report or if you know what everything is already, just leave this out.

## cygpath

    Usage: cygpath [-p|--path] (-u|--unix)|(-w|--windows [-s|--short-name]) filename
           cygpath [-v|--version]
           cygpath [-W|--windir|-S|--sysdir]
      -u|--unix       print UNIX form of filename
      -w|--windows    print Windows form of filename
      -s|--short-name print Windows short form of filename
      -p|--path       filename argument is a path
      -v|--version    print program version
      -W|--windir     print Windows directory
      -S|--sysdir     print Windows system directory
      -i|--ignore     ignore missing filename argument

The `cygpath` program is a utility that converts Windows native filenames to Cygwin POSIX-style pathnames and back. It can be used when a Cygwin program needs to pass a file name to a native Windows program, or expects to get a file name from a native Windows program. You may use the long or short option names interchangeably, even though only the short ones are described here.

The `-u` and `-w` options indicate whether you want a conversion from Windows to UNIX (POSIX) format (`-u`) or a conversion from UNIX (POSIX) to Windows format (`-w`). You must give exactly one of these. To give neither or both is an error. Use the `-s` option in combination with the `-w` option to convert to Windows short form.

The `-p` option means that you want to convert a path-style string rather than a single filename. For example, the PATH environment variable is semicolon-delimited in Windows, but colon-delimited in UNIX. By giving `-p` you are instructing `cygpath` to convert between these formats.

The `-i` option supresses the print out of the usage message if no filename argument was given. It can be used in make file rules converting variables to a proper format that may be omitted.

### Example cygpath usage

    #!/bin/sh
    for i in `echo *.exe | sed 's/\.exe/cc/'`
    do
      notepad "`cygpath -w $i`"
    done

## kill

    Usage: kill [-sigN] pid1 [pid2 ...]

The `kill` program allows you to send arbitrary signals to other Cygwin programs. The usual purpose is to end a running program from some other window when ^C won't work, but you can also send program-specified signals such as SIGUSR1 to trigger actions within the program, like enabling debugging or re-opening log files. Each program defines the signals they understand.

Note that the "pid" values are the Cygwin pids, not the Windows pids. To get a list of running programs and their Cygwin pids, use the Cygwin `ps` program.

To send a specific signal, use the `-signN` option, either with a signal number or a signal name (minus the "SIG" part), like these examples:

### Specifying signals with the kill command

    $ kill 123
    $ kill -1 123
    $ kill -HUP 123

Here is a list of available signals, their numbers, and some commentary on them, from the file `<sys/signal.h>`, which should be considered the official source of this information.

    SIGHUP       1    hangup
    SIGINT       2    interrupt
    SIGQUIT      3    quit
    SIGILL       4    illegal instruction (not reset when caught)
    SIGTRAP      5    trace trap (not reset when caught)
    SIGABRT      6    used by abort
    SIGEMT       7    EMT instruction
    SIGFPE       8    floating point exception
    SIGKILL      9    kill (cannot be caught or ignored)
    SIGBUS      10    bus error
    SIGSEGV     11    segmentation violation
    SIGSYS      12    bad argument to system call
    SIGPIPE     13    write on a pipe with no one to read it
    SIGALRM     14    alarm clock
    SIGTERM     15    software termination signal from kill
    SIGURG      16    urgent condition on IO channel
    SIGSTOP     17    sendable stop signal not from tty
    SIGTSTP     18    stop signal from tty
    SIGCONT     19    continue a stopped process
    SIGCHLD     20    to parent on child stop or exit
    SIGCLD      20    System V name for SIGCHLD
    SIGTTIN     21    to readers pgrp upon background tty read
    SIGTTOU     22    like TTIN for output if (tp->t_local&LTOSTOP)
    SIGIO       23    input/output possible signal
    SIGPOLL     23    System V name for SIGIO
    SIGXCPU     24    exceeded CPU time limit
    SIGXFSZ     25    exceeded file size limit
    SIGVTALRM   26    virtual time alarm
    SIGPROF     27    profiling time alarm
    SIGWINCH    28    window changed
    SIGLOST     29    resource lost (eg, record-lock lost)
    SIGUSR1     30    user defined signal 1
    SIGUSR2     31    user defined signal 2

## mkgroup

    usage: mkgroup <options> [domain]
    This program prints group information to stdout
    Options:\n");
        -l,--local           print pseudo group information if there is
                             no domain
        -d,--domain          print global group information from the domain
                             specified (or from the current domain if there is
                             no domain specified)
        -?,--help            print this message

The `mkgroup` program can be used to help configure your Windows system to be more UNIX-like by creating an initial `/etc/group` substitute (some commands need this file) from your system information. It only works on NT. To initially set up your machine, you'd do something like this:

### Setting up the groups file

    $ mkdir /etc
    $ mkgroup -l > /etc/group

Note that this information is static. If you change the group information in your system, you'll need to regenerate the group file for it to have the new information.

The `-d` and `-l` options allow you to specify where the information comes from, either the local machine or the default (or given) domain.

## mkpasswd

    Usage: mkpasswd [options] [domain]
    This program prints a /etc/passwd file to stdout
    Options are
       -l,--local              print local accounts
       -d,--domain             print domain accounts (from current domain
                               if no domain specified
       -g,--local-groups       print local group information too
       -?,--help               displays this message
    This program does only work on Windows NT

The `mkpasswd` program can be used to help configure your Windows system to be more UNIX-like by creating an initial `/etc/passwd` substitute (some commands need this file) from your system information. It only works on NT. To initially set up your machine, you'd do something like this:

### Setting up the passwd file

    $ mkdir /etc
    $ mkpasswd -l > /etc/passwd

Note that this information is static. If you change the user information in your system, you'll need to regenerate the passwd file for it to have the new information.

The `-d` and `-l` options allow you to specify where the information comes from, either the local machine or the default (or given) domain.

## passwd

    Usage passwd [name]
          passwd [-x max] [-n min] [-i inact] [-L len]
          passwd {-l|-u|-S} name
      -x max   set max age of passwords
      -n min   set min age of passwords
      -i inact disables account after inact days of expiry
      -L len   set min password length
      -l       lock an account
      -u       unlock an account
      -S       show account information

`passwd` changes passwords for user accounts. A normal user may only change the password for their own account, the administrators may change the password for any account. `passwd` also changes account information, such as password expiry dates and intervals.

Password changes: The user is first prompted for their old password, if one is present. This password is then encrypted and compared against the stored password. The user has only one chance to enter the correct password. The administrators are permitted to bypass this step so that forgotten passwords may be changed.

The user is then prompted for a replacement password. `passwd` will prompt again and compare the second entry against the first. Both entries are require to match in order for the password to be changed.

After the password has been entered, password aging information is checked to see if the user is permitted to change their password at this time. If not, `passwd` refuses to change the password and exits.

Password expiry and length: The password aging information may be changed by the administrators with the `-x`, `-n` and `-i` options. The `-x` option is used to set the maximum number of days a password remains valid. After max days, the password is required to be changed. The `-n` option is used to set the minimum number of days before a password may be changed. The user will not be permitted to change the password until min days have elapsed. The `-i` option is used to disable an account after the password has been expired for a number of days. After a user account has had an expired password for inact days, the user may no longer sign on to the account. Allowed values for the above options are 0 to 999. The `-L` option sets the minimum length of allowed passwords for users, which doesn't belong to the administrators group, to len characters. Allowed values for the minimum password length are 0 to 14. In any of the above cases, a value of 0 means `no restrictions'.

Account maintenance: User accounts may be locked and unlocked with the `-l` and `-u` flags. The `-l` option disables an account. The `-u` option re-enables an account.

The account status may be given with the `-S` option. The status information is self explanatory.

Limitations: Users may not be able to change their password on some systems.

## mount

    Usage mount
          mount [-bfs] <win32path> <posixpath>
          mount [-bs] --change-cygdrive-prefix<posixpath>
          mount --import-old-mounts

      -b = text files are equivalent to binary files (newline = \n)
      -x = files in the mounted directory are automatically given execute permission.
      -f = force mount, don't warn about missing mount point directories
      -s = add mount point to system-wide registry location
      --change-automount-prefix = change path prefix used for automatic mount points
      --import-old-mounts = copy old registry mount table mounts into the current mount areas

      When invoked without any arguments, mount displays the current mount table.

The `mount` program is used to map your drives and shares onto Cygwin's simulated POSIX directory tree, much like as is done by mount commands on typical UNIX systems. Please see mount-table for more information on the concepts behind the Cygwin POSIX file system and strategies for using mounts.

### Using mount

If you just type `mount` with no parameters, it will display the current mount table for you.

#### Displaying the current set of mount points

    c:\cygnus\> mount
    Device           Directory           Type        Flags
    D:               /d                  user        textmode
    C:               /                   system      textmode

In this example, the C drive is the POSIX root and D drive is mapped to `/d`. Note that in this case, the root mount is a system-wide mount point that is visible to all users running Cygwin programs, whereas the `/d` mount is only visible to the current user.

The `mount` utility is also the mechanism for adding new mounts to the mount table. The following example demonstrates how to mount the directory `C:\cygnus\cygwin-b20\H-i586-cygwin32\bin` to `/bin` and the network directory `\\pollux\home\joe\data` to `/data`. `/bin` is assumed to already exist.

#### Adding mount points

    c:\cygnus\> ls /bin /data
    ls: /data: No such file or directory
    c:\cygnus\> mount C:\cygnus\cygwin-b20\H-i586-cygwin32\bin /bin
    c:\cygnus\> mount \\pollux\home\joe\data /data
    Warning: /data does not exist!
    c:\cygnus\> mount
    Device           Directory           Type        Flags
    \\pollux\home\joe\data   /data       user        textmode
    C:\cygnus\cygwin-b20\H-i586-cygwin32\bin   /bin   user   textmode
    D:               /d                  user        textmode
    \\.\tape1:       /dev/st1            user        textmode
    \\.\tape0:       /dev/st0            user        textmode
    \\.\b:           /dev/fd1            user        textmode
    \\.\a:           /dev/fd0            user        textmode
    C:               /                   system      textmode
    c:\cygnus\> ls /bin/sh
    /bin/sh

Note that `mount` was invoked from the Windows command shell in the previous example. In many Unix shells, including bash, it is legal and convenient to use the forward "/" in Win32 pathnames since the "\" is the shell's escape character.

The "-s" flag to `mount` is used to add a mount in the system-wide mount table used by all Cygwin users on the system, instead of the user-specific one. System-wide mounts are displayed by `mount` as being of the "system" type, as is the case for the `/` partition in the last example. Under Windows NT, only those users with Administrator priviledges are permitted to modify the system-wide mount table.

Note that a given POSIX path may only exist once in the user table and once in the global, system-wide table. Attempts to replace the mount will fail with a busy error. The "-f" (force) flag causes the old mount to be silently replaced with the new one. It will also silence warnings about the non-existence of directories at the Win32 path location.

The "-b" flag is used to instruct Cygwin to treat binary and text files in the same manner by default. Binary mode mounts are marked as "binmode" in the Flags column of `mount` output. By default, mounts are in text mode ("textmode" in the Flags column).

The "-x" flag is used to instruct Cygwin that the mounted file is "executable". If the "-x" flag is used with a directory then all files in the directory are executable. Files ending in certain extensions (.exe, .com, .bat, .cmd) are assumed to be executable by default. Files whose first two characters begin with '#!' are also considered to be executable. This option allows other files to be marked as executable and avoids the overhead of opening each file to check for a '#!'.

### Cygdrive mount points

Whenever Cygwin cannot use any of the existing mounts to convert from a particular Win32 path to a POSIX one, Cygwin will, instead, convert to a POSIX path using a default mount point: `/cygdrive`. For example, if Cygwin accesses `Z:\foo` and the Z drive is not currently in the mount table, then `Z:\` will be accessible as `/cygdrive/Z`. The default prefix of `/cygdrive` may be changed via the mount command.

The `mount` utility can be used to change this default automount prefix through the use of the "--change-cygdrive-prefix" flag. In the following example, we will set the automount prefix to `/`:

#### Changing the default prefix

    c:\cygnus\> mount --change-cygdrive-prefix /

Note that you if you set a new prefix in this manner, you can specify the "-s" flag to make this the system-wide default prefix. By default, the cygdrive-prefix applies only to the current user. In the same way, you can specify the "-b" flag such that all new automounted filesystems default to binary mode file accesses.

### Limitations

Limitations: there is a hard-coded limit of 30 mount points. Also, although you can mount to pathnames that do not start with "/", there is no way to make use of such mount points.

Normally the POSIX mount point in Cygwin is an existing empty directory, as in standard UNIX. If this is the case, or if there is a place-holder for the mount point (such as a file, a symbolic link pointing anywhere, or a non-empty directory), you will get the expected behavior. Files present in a mount point directory before the mount become invisible to Cygwin programs.

It is sometimes desirable to mount to a non-existent directory, for example to avoid cluttering the root directory with names such as `a`, `b`, `c` pointing to disks. Although `mount` will give you a warning, most everything will work properly when you refer to the mount point explicitly. Some strange effects can occur however. For example if your current working directory is `/dir`, say, and `/dir/mtpt` is a mount point, then `mtpt` will not show up in an `ls` or `echo *` command and `find .` will not find `mtpt`.

## ps

    Usage ps [-aefl] [-u uid]
      -a, -e   show processes of all users
      -f       show process uids, ppids
      -l       show process uids, ppids, pgids, winpids
      -s	   short process listing
      -u uid   show processes owned by uid
      -W	   show all windows processes, not just cygwin processes

The `ps` program gives the status of all the Cygwin processes running on the system (ps = "process status"). Due to the limitations of simulating a POSIX environment under Windows, there is little information to give. The PID column is the process ID you need to give to the `kill` command. The WINPID column is the process ID that's displayed by NT's Task Manager program.

## umount

    Usage umount [-s] <posixpath>
    -s = remove mount point from system-wide registry location

    --remove-all-mounts = remove all mounts
    --remove-auto-mounts = remove all automatically mounted mounts
    --remove-user-mounts = remove all mounts in the current user mount registry area, including auto mounts
    --remove-system-mounts = Remove all mounts in the system-wide mount registry area

The `umount` program removes mounts from the mount table. If you specify a POSIX path that corresponds to a current mount point, `umount` will remove it from the user-specific registry area. The -s flag may be used to specify removing the mount from the system-wide registry area instead (Administrator priviledges are required).

The `umount` utility may also be used to remove all mounts of a particular type. With the extended options it is possible to remove all mounts, all automatically-mounted mounts, all mounts in the current user's registry area, or all mounts in the system-wide registry area (with Administrator priviledges).

See mount) for more information on the mount table.

## strace

    Usage strace [-m mask] [-o output-file] [ft] program [args...]

    -b n		  use buffer of size 'n' when writing output file
    -d		  include delta time in usecs for each line (default)
    -f		  follow all forks and execs
    -m mask		  mask for reporting cygwin events (default 1)
    -n		  convert Win32 error messages to text
    -o output-file	  output file to hold strace events (default stderr)
    -f		  follow forked subprocesses
    -u		  include time in usecs since start for each line (default)

The `strace` program executes a program, and optionally the children of the program, reporting any Cygwin DLL output from the program(s) to file. This program is mainly useful for debugging the Cygwin DLL itself. The mask argument is a hexadecimal string signifying which events should be reported. The valid bits to set are as follows:

      Bit			Explanation
    0x00000001		All strace output is collected
    0x00000008		Unusual or weird phenomenon
    0x00000010		System calls
    0x00000020		argv/envp printout at startup
    0x00000040		Information useful for DLL debugging
    0x00000080		Paranoid information
    0x00000100		Termios debbugging
    0x00000200		Select() function debugging
    0x00000400		Window message debugging
    0x00000800		Signal and process handling
    0x00001000		Very minimal strace output
    0x00020000		Malloc calls
    0x00040000		Thread locking calls

## regtool

    Regtool Copyright (c) 2000 Red Hat Inc
     regtool -h  - print this message
     regtool [-v|-p|-k|-l] list [key]  - list subkeys and values
         -p=postfix, like ls -p, appends / postfix to key names
         -k=keys, lists only keys
         -l=values, lists only values
     regtool [-v] add [key\subkey]  - add new subkey
     regtool [-v] remove [key]  - remove key
     regtool [-v|-q] check [key]  - exit 0 if key exists, 1 if not
     regtool [-i|-s|-e|-m] set [key\value] [data ...]  - set value
         -i=integer -s=string -e=expand-string -m=multi-string
     regtool [-v] unset [key\value]  - removes value from key
     regtool [-q] get [key\value]  - prints value to stdout
         -q=quiet, no error msg, just return nonzero exit if key/value missing
     keys are like \prefix\key\key\key\value, where prefix is any of:
       root     HKCR  HKEY_CLASSES_ROOT
       config   HKCC  HKEY_CURRENT_CONFIG
       user     HKCU  HKEY_CURRENT_USER
       machine  HKLM  HKEY_LOCAL_MACHINE
       users    HKU   HKEY_USERS
     example: \user\software\Microsoft\Clock\iFormat

The `regtool` program allows shell scripts to access and modify the Windows registry. Note that modifying the Windows registry is dangerous, and carelessness here can result in an unusable system. Be careful.

The `-v` option means "verbose". For most commands, this causes additional or lengthier messages to be printed. Conversely, the `-q` option supresses error messages, so you can use the exit status of the program to detect if a key exists or not (for example).

The `list` command lists the subkeys and values belonging to the given key. The `add` command adds a new key. The `remove` command removes a key. Note that you may need to remove everything in the key before you may remove it, but don't rely on this stopping you from accidentally removing too much. The `check` command checks to see if a key exists (the exit code of the program is zero if it does, nonzero if it does not).

The `set` command sets a value within a key. `-i` means the value is an integer (DWORD). `-s` means the value is a string. `-e` means it's an expanding string (it contains embedded environment variables). `-m` means it's a multi-string (list). If you don't specify one of these, it tries to guess the type based on the value you give. If it looks like a number, it's a number. If it starts with a percent, it's an expanding string. If you give multiple values, it's a multi-string. Else, it's a regular string.

The `unset` command removes a value from a key. The `get` command gets the value of a value of a key, and prints it (and nothing else) to stdout. Note: if the value doesn't exist, an error message is printed and the program returns a non-zero exit code. If you give `-q`, it doesn't print the message but does return the non-zero exit code.