2. Runtime Configuration Options

2.2.1. Enviroment variables and configuration variables

They existed already in very early versions of DOSEMU (until now), but now evironment variables are much more useful in dosemu.conf / global.conf as before, because you now can set them, test them in the new 'if' statement and compute them in expressions. The problem with the enviroment variables is, however, that the user may set and fake them before calling DOSEMU, hence this is a security problem. To avoid this, we have the above mentioned configuration variables, which are of complete different name space and are not visible outside of DOSEMU's configuration parser. On the other hand it may be useful to export settings from global.conf to the running DOS environment, which can be achieved by the 'unix.exe -e' DOS programm.

To summarize:

At startup DOSEMU generates the following environment variables, which may be used to let the configuration adapt better:

2.2.2. Conditional statements

You may control execution of configuration statements via the following conditional statement:

ifdef <configuration variable>

or

ifndef <configuration variable> ... else ... endif

where variable is a configuration variable (not an environment variable). Additionally there is a `normal' if statement, a while statement and a foreach statement such as

if ( expression ) endif while ( expression ) done foreach loop_variable (delim, list) done

but these behaves a bit different and are described later.

The 'else' clause may be ommitted and 'ifndef' is the opposite to 'ifdef'. The <variable> can't be tested for its contents, only if it is set or not. Clauses also may contain further if*def..endif clause up to a depth of 15. All stuff in /etc/dosemu.users behind the 'loginname' in fact are configuration variables that are set. Hence, what you set there, can be tested here in the config file. Further more you may set/unset configuration variables in the config files itself:

define <configuration variable> undef <configuration variable>

However, use of define/undef is restricted to scope of global.conf, as long as you don't 'define c_var' _within_ global.conf. If you are under scope of a 'user config file' (e.g. outside global.conf) you have to prefix the configuration variable name with 'u_', else it will not be allowed to be set/unset (hence 'c_' type variables can't be unset out of scope of global.conf).

There are some configuration variables (besides the ones described above for dosemu.users) implicitely predefined by DOSEMU itself:

Also, you may define any 'u_' type variable at start of DOSEMU via the new option -u such as

# dosemu -u myspecialfun

this will then define the config variable 'u_myspecialfun' _before_ parsing any configuration file. You then may check this in your (old) ./dosrc or global.conf to do the needed special configuration.

Now, what's this with the if statement and while statement? All those conditionals via ifdef and indef are completly handled before the remaining input is passed to the parser. Hence you even may use them within a configuration statement such as

terminal { charset ifdef u_likeibm ibm else latin endif updatefreq 4 color on }

This is not the case with the (above mentioned) if statement, this one is of course processed within the parser itself and can only take place within the proper syntax context such as

if ( defined( u_likeibm ) ) $mycharset = "ibm" else $mycharset = "latin" endif terminal { charset $mycharset updatefreq 4 color on }

but it has the advantage, that you can put any (even complex) expression (see chapter `expressions') between the brackets. If the expression's numerical value is 0, then false is assumed, else true.

Same rules apply to the while statement, the loop will be executed as long as `expression' is not 0. The loop end is given by the keyword done such as in

$counter = (3) while ($counter > 0) # what ever should loop $counter = ($counter -1) done # or some kind of list processing # ... but look below, `foreach' does it better $list = "aa bbb ccc" while (strlen($list)) $item = strdel($list, strchr($list," "), 999) $list = strsplit($list, (strlen($item)+1),9999); warn "doing something with ", $item done

The foreach statement behaves a bit like the /bin/sh `for i in', but you can specify a list of delimiters.

$list = "anton, berta; caesar dora" $delim = " ,;" foreach $xx ($delim, $list) warn "My name is ", $xx done $list = "a b c : 1 2 3" $delim = ":" foreach $xx ($delim, $list) if ($delim eq ":") $delim = " "; else warn "processing number ", $xx endif done

The later example jumps to the colon (`:') in one step and after that process the numbers step by step.

For all loops and `if' statement the allowed depth is 32 (totally).

2.2.3. Include files

If you for some reason want to bundle some major settings in a separate file you can include it via

include "somefile"

If 'somefile' doesn't have a leading '/', it is assumed to be relative to /etc. Also includeing may be nested up to a max depth of 10 files. Note however, that the privilege is inherited from the main file from which is included, hence all what is included by global.conf has its privilege.

However, there are restrictions for `while' loops: You can't have include statements within loops without beeing prepared for unexpected behave. In fact you may try, but due to the technique used, include files within loops are loaded completely prior loop execution. Hence, if you do conditional including this won't work.

A further restriction is, that the name of the include file must not be a variable. However, you can work around this with a macro (see next chapter) as shows the following example:

$file = $HOME, "/.my_dosrc_include" shell("test -f ", $file) if ( ! $DOSEMU_SHELL_RETURN) # we can include $INC = ' include "', $file, '"'; $$INC endif

2.2.4. Macro substitution

There is a very rudimentary macro substitution available, which does allow recursion but no arguments: Whenever you write

$MYMACRO = "warn 'this is executed as macro'" ; $$MYMACRO

it will expand to

warn 'this is executed as macro'

Note, that the `;' is required for parser to recognize the end of the statement and to set the variable before it tries to read the next token (which will let the lexer process `$$MYMACRO'). Macro substitution is completely done on the input stream before the parser gets the data.

For what is it worth then? Now, this enables you to insert text into the input stream, that otherwise would be expected to be constant. Or simple, it allows you to be lazy to write the same things more then once.

$loop = ' while ($xxx) warn "loop in macro ",$xxx $xxx = ($xxx -1) done '; $xxx = (2); $$loop; $xxx = (3); $$loop; $_X_keycode = (off) $_X_lin_filt = (on) ... if ($_X_keycode) $_X_keycode = "keycode" else $_X_keycode = "" endif if ($_X_lin_filt) $_X_lin_filt = "lin_filt" else $_X_lin_filt = "" endif X { icon_name "xdos" $$_X_keycode $$_X_lin_filt }

You see, that in cases the variables are `false', the (parameterless) `keycode' and/or `lin_filt' keywords would not appear in the `X{}' statement.

2.2.5. Expressions

Expression within the configuration files follow the usual numerical rules and may be as complex as you wish. At some places, the parser only can `understand' expressions, when you enclose them in brackets, but mostly you just can type

123 + 456 + 2 * 1.2

Though, if you want be sure, you better type them as

( 123 + 456 + 2 * 1.2 )

You may place expressions whenever a numerical value is expected and there is no ambiguity in the syntax. Such an ambiguity is given, when a statement needs more then one successive number such as

... winsize x y ... ... vesamode width heigh ... ... range from to ...

If you want to place expression herein, you need the new syntax for those statements / terms which have a coma (instead of a blank) as delimiter:

... winsize x , y ... ... vesamode width , heigh ... ... range from , to ...

The old syntax is left for compatibility and is only parsed correcty, if pure numbers (integers) are used.

Valid constant numbers (not only in expressions) are

123 decimal, integer 0x1a hexadecimal, integer 0b10101 bitstream, integer 1.2 float number, real 0.5e3 exponential form, real off boolean false, integer on boolean true, integer no boolean false, integer yes boolean true, integer

The following operator are recognized:

+ - * as usual / div division, the '/' _must_ be surrounded by whitespaces, else it conflicts with pathnames on quoteless strings | bitwise or ^ bitwise exclusive or ~ bitwise not & bitwise and >> shift right << shift left < less then <= less or equal > greater then >= greater or equal || boolean or && boolean and ! boolean not == numerical equivalence eq string equivalence != numerical, not equal ne string not equal

The type of the expression result may be real (float) or integer, depending on which type is on the `left side'. Conversion is mostly done automaticaly, but you may force it using the (below mentioned) int() and real() functions such as:

$is_real = ( 3.1415 * 100 ) $is_integer = ( int( 3.1415 * 100) ) $is_integer = ( 100 * 3.1415 ) $is_real = ( real($is_integer) )

The above also shows, how environment variables can be set: if you want to place `expressions' (which are always numbers) onto a variable, you have to surround them with brackets, else the parser won't be able to detect them. In principal, all $xxx settings are string-settings and numbers will be converted correctly before. In fact the `$xxx =' statement accepts a complete coma separated list, which it will concatenate, examples:

$termnum = (1) $MYTERM = "/dev/ttyp", $termnum # results in "/dev/ttyp1" $VER = (($DOSEMU_VERSION_CODE >> 24) & 255) $MINOR = (($DOSEMU_VERSION_CODE >> 16) & 255) $running_dosemu = "dosemu-", $VER, ".", $MINOR

Several builtin functions, which can be used in expressions, are available:

2.2.6. String expressions

For manipulation of strings there are the following builtin functions, which all return a new string. These very well may be placed as argument to a numerical function's string argument, but within an `expression' they may be only used together with the `eq' or `ne' operator.

With these tools you should be able to make your global.conf adapt to any special case, such as different terminal types, different hdimages for different users and/or different host, adapt to different (future) dosemu and/or kernel versions. Here some small examples:

$whoami = shell("who am i") if ( strchr($whoami, "(" ) < 0 ) # beeing on console else if (strstr($whoami, "(:") < 0) # beeing remote logged in endif if ($TERM eq "xterm") # beeing on xterm else if (strstr("linux console", $TERM) < 0) # remote side must be some type of real terminal else # remote side is a Linux console endif endif endif if ($DISPLAY ne "") # we can rely on reaching an Xserver if (strsplit($DISPLAY, 0, 1) ne ":") # the X server is remote endif endif if ($DOSEMU_REAL_USER eq "alistair") # ha, this one is allowed to do odds sound tricks :-) endif if (strsplit($DOSEMU_HOST, 0, strchr($DOSEMU_HOST,".")) eq $DOSEMU_HOST) # we have no domain suffix for this host, should be a local one endif # disable setting graphics mode per commandline option -g $DOSEMU_OPTIONS = strdel($DOSEMU_OPTIONS, strchr($DOSEMU_OPTIONS,"g"),1);

2.2.7. `Dry' testing your configuration

It may be useful to verify, that your *.conf does what you want before starting a real running DOSEMU. For this purpose there is a new commandline option (-h), which just runs the parser, print some useful output, dumps the main configuration structure and then exits. The option has an argument (0,1,2), which sets the amount of parser debug output: 0 = no parser debug, 1 = print loop debugs, 2 = same as 1 plus if_else_endif-stack debug. This feature can be used such as

$ dosemu.bin -h0 -O 2>&1 | less

The output of `-h2' looks like

PUSH 1->2 1 >foreach__yy__< PUSH 2->3 1 >if< POP 2<-3 0 >endif< -1 POP 1<-2 1 >done< -1 PUSH 1->2 1 >foreach__yy__< PUSH 2->3 1 >if< POP 2<-3 1 >endif< -1 POP 1<-2 1 >done< -1 | | | +-------`cached' read status (0 = not cached) | | +-----------------`if' or `loop' test result (0 = false = skipped) | +-------------------inner level +----------------------outer level (1 = no depth)

There are also some configuration statements, which aren't of any use except for help debugging your *.conf such as

exprtest ($DOSEMU_VERSION_CODE) # will just print the result warn "content of DOSEMU_VERSION_CODE: ", $DOSEMU_VERSION_CODE

2.2.8. Debug statement

This section is of interest mainly to programmers. This is useful if you are having problems with DOSEMU and you want to enclose debug info when you make bug reports to a member of the DOSEMU development team. Simply set desired flags to "on" or "off", then redirect stderr of DOSEMU to a file using "dosemu.bin -o debug" to record the debug information if desired. Skip this section if you're only starting to set up.

debug { config off disk off warning off hardware off port off read off general off IPC off video off write off xms off ems off serial off keyb off dpmi off printer off mouse off sound off }

Alternatively you may use the same format as -D commandline option (but without the -D in front), look at the dosemu.bin.1 man page.

debug "+a-v" # all messages but video debug "+4r" # default + maximum of PIC debug

or simply (to turn off all debugging)

debug { off }

2.2.9. Miscellaneous

The HogThreshold value determines how nice Dosemu will be about giving other Linux processes a chance to run. Setting the HogThreshold value to approximately half of you BogoMips value will slightly degrade Dosemu performance, but significantly increase overall system idle time. A zero value runs Dosemu at full tilt.

HogThreshold 0

Want startup DOSEMU banner messages? Of course :-)

dosbanner on

Timint is necessary for many programs to work.

timint on

For "mathco", set this to "on" to enable the coprocessor during DOSEMU. This really only has an effect on kernels prior to 1.0.3.

mathco on

For "cpu", set this to the CPU you want recognized during DOSEMU.

cpu 80386

If you have DOSEMU configured to use the 386-emulator, you can enable the emulator via

cpu emulated

You may ask why we need to emulate a 386 on an 386 ;-) Well, for normal purpose its not needed (and will be slower anyway), but the emulator offers a better way to debug DOS applications, especially DPMI code. Also, we hope that some day we may be able to run DOSEMU on other machines than 386. At the time of writing this, the cpu emulators is very alpha and you should not use it except you are willing to help us. So please, don't even try to report 'bugs' except you have a patch for the bug too.

If you have a pentium, DOSEMU can make use of the pentium cycle counter to do better timing. DOSEMU detects the pentium and will use the RDTSC instruction for get time per default. To disable this feature use

rdtsc off

Also, to use the pentium cycle counter correctly DOSEMU needs to know the CPU-clock which your chip is running. This per default is calibrated automatically, however, that may be not exact enough. In this case you have to set it yourself via

cpuspeed 180

or, for values like 166.6666 you may give two numbers such as

cpuspeed 500 3

which will be calculated as 'cpuspeed=500/3'

If you have a PCI board you may allow DOSEMU to access the PCI configuration space by defining the below

pci on | off

PCI is assumed to be present on CPUs better then a pentium, otherwise the default is 'pci off'

For "bootA"/"bootC", set this to the bootup drive you want to use. It is strongly recommended you start with "bootA" to get DOSEMU going, and during configuration of DOSEMU to recognize hard disks.

bootA

During compile there will be a symbol map generated, this usually then is ./bin/dosemu.map. You may wnt to save it to an other places and let 'dosdebug' know where to find it:

dosemumap /var/lib/dosemu/dosemu.map

Normally all debug logging is done _imediately_ (unbuffered). However, when dumping big amounts of logdata, the dynamic behave of DOSEMU may change, hence hiding the real problem (or causing a new one) Using the below switches buffering on and sets the buffer size.

logbufsize 0x20000

In addition, you may want to limit the file size of the log file, especially when you expect huge amounts of data (such as with -D+e). This can be done via

logfilesize 0x200000

which (in this case) will limit the size to 2Mbytes. The default setting is a file size of 10Mbytes.

When you want to abort DOSEMU from within a configuration file (because you detected something weird) then do

abort

or

abort "message text"

When you want just to warn the user use the following (the message will get printed to the log file via the debug-flag '+c')

warn "message text"

When you want to use the CDrom driver and the Linux device is other then /dev/cdrom you may define

cdrom { /dev/xxx }

However, you need to include the DOSEMU supplied cdrom.sys into your config.sys such as

device=cdrom.sys

If you have more then one cdrom, you have to use the cdrom statement multiple times such as

cdrom { /dev/cdrom } cdrom { /dev/cdrom2 }

and have multiple instancies of the DOS driver too:

device=cdrom.sys device=cdrom.sys 2

In any case you will need MSCDEX.EXE in your autoexe.bat refer to the DOS devices MSCD0001, MSCD0002 respectively.

2.2.10. Code page and character set

To select the character set and code page for use with DOSEMU we now (against earlier versions of DOSEMU) have a separate statement:

charset XXX

where XXX is one of

With the advent of handling all characters internally to dosemu things have gotten more flexible, and more interesting. The following form of the charset option has been added.

charset { external "iso8859_1" internal "cp437" }

For external character set the allowable character sets are:

"cp437", "cp737", "cp775", "cp850", "cp852", "cp857", "cp860","cp861", "cp862", "cp863", "cp864", "cp865", "cp866", "cp869", "cp874", "iso8859-1", "iso8859-2", "iso8859-3", "iso8859-4", "iso8859-5", "iso8859-6", "iso8859-7", "iso8859-8", "iso8859-9", "iso8859-14", "iso8859-15"

For the internal character set the allowable character sets are:

"cp437", "cp737", "cp775", "cp850", "cp852", "cp857", "cp860","cp861", "cp862", "cp863", "cp864", "cp865", "cp866", "cp869", "cp874"

The external character set is used to:

• compute the unicode values of characters coming in from the terminal

• compute the character set index of unicode characters output to a terminal display screen.

• compute the unicode values of characters pasted into dosemu.

The internal character set is used to:

• compute the unicode value of characters of video memory

• compute the character set index of unicode characters returned by bios keyboard translation services.

2.2.11. Keyboard settings

For defining the keyboard layouts you are using there is the "keyboard" statement such as

keyboard { layout us .... }

or

keyboard { layout us {alt 66=230} ... }

The later modifies the US keyboard layout such that it will allow you to type a character 230 (micro) with right ALT-M.

The same can be done via a "keytable" statement such as

keytable keyb-user {alt 66=230}

The "keyb-user" is preset with an US layout and is intended to be used as "buffer" for user defined keyboard tables.

The format of the "{}" modification list (either in the "keyboard" or the "keytable" statement) is as follows:

[submap] key_number = value [,value [,...]]

Given we call the above a "definition" then it may be repeated (blank separated) such as

definition [definition [...]]

"key_number" is the physical number, that the keybord send to the machine when you hit the key, its the index into the keytable. "value" may be any integer between 0...255, a string, or one of the following keywords for "dead keys" (NOTE: deadkeys have a value below 32, so be careful).

dgrave (dead grave) dacute (dead acute) dcircum (dead circumflex) dtilde (dead tilde) dbreve (dead breve) daboved (dead above dot) ddiares (dead diaresis) dabover (dead above ring) ddacute (dead double acute) dcedilla (dead cedilla) dogonek (dead ogonek) dcaron (dead caron)

With the addition of internal unicode support "value" may be any integer between 0..65535 (specifying a unicode value), a hexadecimal integer in the form \uFFFF all 4 hexadecimal digits are mandatory, a string interpreted in the internal character set.

The implementation of dead keys has changed, and values of the unicode combining characters are used for dead key character caps. In particular:

0x0300 U_COMBINING_GRAVE_ACCENT dgrave 0x0301 U_COMBINING_ACUTE_ACCENT dacute 0x0302 U_COMBINING_CIRCUMFLEX_ACCENT dcircum 0x0303 U_COMBINING_TILDE dtilde 0x0306 U_COMBINING_BREVE dbreve 0x0307 U_COMBINING_DOT_ABOVE daboved 0x0308 U_COMBINING_DIAERESIS ddiares 0x030A U_COMBINING_RING_ABOVE dabover 0x030B U_COMBINING_DOUBLE_ACUTE_ACCENT ddacute 0x0327 U_COMBINING_CEDILLA dcedilla 0x0328 U_COMBINING_OGONEK dogonek 0x030C U_COMBINING_CARON dcaron

In unicode there is a private range of characters 0xE000 - 0xEFFF that an application can use as it wishes. In dosemu the exact usage of this range is defined in src/include/keyboard.h. Current this range is broke up as follows:

0xEF00 - 0xEFFF is defined as a pass through to whatever character set is being displayed. 0xE100 - 0xE1FF are used for special keycaps 0xE200 - 0xE2FF are used for any extra dead keys we may need to make up 0xE300 - 0xE3FF are used for special dosemu function keys

After a "key_number =" there may be any number of comma separated values, which will go into the table starting with "key_number", hence all below examples are equivalent

{ 2="1" 3="2" } { 2="1","2" } { 2="12" } { 2=0x31,50 }

"submap" tells in about something about the shift state for which the definition is to use or wether we mean the numpad:

shift 16="Q" (means key 16 + SHIFT pressed) alt 16="@" (means key 16 + right ALT pressed (so called AltGr)) numpad 12="," (means numpad index 12 (depricated)) ctrl 16=\u0011 (means key 16 + ctrl pressed) shift-alt 16=\u02A0 (means key 16 + AltGR pressed and shift pressed) ctrl-alt 209=\uE30A (means key 209 (PGDN) + ctrl pressed and alt pressed)

You may even replace the whole table with a comma/blank separated list of values. In order to make it easy for you, you may use dosemu to create such a list. The following statement will dump all current key tables out into a file "kbdtables", which is directly suitable for inclusion into global.conf (hence it follows the syntax):

keytable dump "kbdtables"

However, don't put this not into your global.conf, because dosemu will exit after generating the tablefile. Instead use the -I commandline option such as

$ dosemu.bin -I 'keytable dump "kbdtables"'

After installation of dosemu ("make install") you'll find the current dosemu keytables in /var/lib/dosemu/keymap (and in ./etc/keymap, where they are copied from). These tables are generated via "keytable dump" and split into discrete files, such that you may modify them to fit your needs. You may load them such as

$ dosemu.bin -I 'include "keymap/de-latin1"'

(when an include file is starting with "keymap/" it is taken out of /var/lib/dosemu). When there was a keytable previously defined (e.g. in global.conf), they new one will be take anyway and a warning will be printed on stderr.

Anyway, you are not forced to modify or load a keytable, and with the "layout" keyword from the "keyboard" statement, you can specify your country's keyboard layout. The following builtin layouts are implemented:

finnish us dvorak sf finnish-latin1 uk sg sf-latin1 de dk sg-latin1 es de-latin1 dk-latin1 fr es-latin1 be keyb-no fr-latin1 po it no-latin1 sw jp106 hu hu-cwi hu-latin2 keyb-user po hr-cp852 hr-latin2

The keyb-user is selected by default if the "layout" keyword is omitted, and this in fact is identical to us-layout, as long as it got not overloaded by the "keytable" statement (see above).

The keyword "keybint" allows more accurate of keyboard interrupts, It is a bit unstable, but makes keyboard work better when set to "on".

The keyword "rawkeyboard" allows for accurate keyboard emulation for DOS programs, and is only activated when DOSEMU starts up at the console. It only becomes a problem when DOSEMU prematurely exits with a "Segmentation Fault" fatal error, because the keyboard would have not been reset properly. In that case, you would have to run kbd_mode -a remotely, or use the RESET button. In reality, this should never happen. But if it does, please do report to the dosemu development team, of the problem and detailed circumstances, we're trying our best! If you don't need near complete keyboard emulation (needed by major software package), set it to "off"

recommended:

keyboard { layout us keybint on rawkeyboard off }

or

keyboard { layout de-latin1 keybint on rawkeyboard on }

If you want DOSEMU feed with keystrokes, that are typed in automagically, then you may define them such as

keystroke "cd c:\\mysource\r"

You may have any number of 'keystroke' statements, they all will be concatenated.

This feature however doesn't make much sense _here_ in the configuration file, instead together with the commandine option -I you can start dosemu and execute any arbitrary dos command such as

# dosemu.bin -D-a -I 'keystroke "c:\rcd \\windows\rwinemu\r"'

For more details please look at ./doc/README.batch

Ah, but _one_ sensible useage _here_ is to 'pre-strike' that damned F8 that is needed for DOS-7.0, when you don't want to edit the msdos.sys:

keystroke "\F8;"

2.2.12. Serial stuff

You can specify up to 4 simultaneous serial ports here. If more than one ports have the same IRQ, only one of those ports can be used at the same time. Also, you can specify the com port, base address, irq, and device path! The defaults are:

• COM1 default is base 0x03F8, irq 4, and device /dev/cua0

• COM2 default is base 0x02F8, irq 3, and device /dev/cua1

• COM3 default is base 0x03E8, irq 4, and device /dev/cua2

• COM4 default is base 0x02E8, irq 3, and device /dev/cua3

If the "com" keyword is omitted, the next unused COM port is assigned. Also, remember, these are only how you want the ports to be emulated in DOSEMU. That means what is COM3 on IRQ 5 in real DOS, can become COM1 on IRQ 4 in DOSEMU!

NOTE: You must have /var/lock for LCK-file generation ! You may change this path and the lockfile name via the below 'ttylocks' statement.

Also, as an example of defaults, these two lines are functionally equal:

serial { com 1 mouse } serial { com 1 mouse base 0x03F8 irq 4 device /dev/cua0 }

If you want to use a serial mouse with DOSEMU, the "mouse" keyword should be specified in only one of the serial lines. (For PS/2 mice, it is not necessary, and device path is in mouse line instead)

Use/modify any of the following if you want to support a modem: (or any other serial device.)

serial { com 1 device /dev/modem } serial { com 2 device /dev/modem } serial { com 3 device /dev/modem } serial { com 4 device /dev/modem } serial { com 3 base 0x03E8 irq 5 device /dev/cua2 }

If you are going to load a msdos mouse driver for mouse support use/modify one of the following

serial { mouse com 1 device /dev/mouse } serial { mouse com 2 device /dev/mouse }

What type is your mouse? Use one of the following. Use the 'internaldriver' option to try Dosemu internaldriver. Use the 'emulate3buttons' for 3button mice.

mouse { microsoft } mouse { logitech } mouse { mmseries } mouse { mouseman } mouse { hitachi } mouse { mousesystems } mouse { busmouse } mouse { ps2 device /dev/mouse internaldriver emulate3buttons } mouse { mousesystems device /dev/mouse internaldriver cleardtr }

For tty locking capabilities:

The serial lines are locked by dosemu via usual lock file technique, which is compatible with most other unix apps (such as mgetty, dip, e.t.c). However, you carefully need to check _where_ those other apps expect the lock files. The most common used place is /var/lock. The dosemu default one is /var/lock. The below defines /var/lock

ttylocks { directory /var/lock }

Note: you are responsible for ensuring that the directory exists ! If you want to define the lock prefix stub also, use this one

ttylocks { directory /var/lock namestub LCK.. }

If the lockfile should contain the PID in binary form (instead of ASCII}, you may use the following

ttylocks { directory /var/lock namestub LCK.. binary }

2.2.13. Networking Support

Turn the following option 'on' if you require IPX/SPX emulation. Therefore, there is no need to load IPX.COM within the DOS session. The following option does not emulate LSL.COM, IPXODI.COM, etc. NOTE: YOU MUST HAVE IPX PROTOCOL ENABLED IN KERNEL !!

ipxsupport off

Enable Novell 8137->raw 802.3 translation hack in new packet driver.

pktdriver novell_hack

2.2.14. Terminals

This section applies whenever you run DOSEMU remotely or in an xterm. Color terminal support is now built into DOSEMU. Skip this section for now to use terminal defaults, until you get DOSEMU to work.

There are a number of keywords for the terminal { } configuration line.

Use the following to enable the IBM character set.

terminal { charset ibm color on }

Use this for color xterms or rxvt's with no IBM font, with only 8 colors.

terminal { charset latin color on }

Use this for color xterms or rxvt's with IBM font, with only 8 colors.

terminal { charset ibm color on }

More detailed line for user configuration:

terminal { charset latin updatefreq 4 color on }

2.2.15. X Support settings

If DOSEMU is running in its own X-window (not xterm), you may need to tailor it to your needs. Valid keywords for the X { } config line:

Recommended X statement:

X { updatefreq 8 title "DOS in a BOX" icon_name "xdos" }

2.2.16. Video settings ( console only )

!!WARNING!!: A LOT OF THIS VIDEO CODE IS ALPHA! IF YOU ENABLE GRAPHICS ON AN INCOMPATIBLE ADAPTOR, YOU COULD GET A BLANK SCREEN OR MESSY SCREEN EVEN AFTER EXITING DOSEMU. JUST REBOOT (BLINDLY) AND THEN MODIFY CONFIG.

Start with only text video using the following line, to get started. then when DOSEMU is running, you can set up a better video configuration.

video { vga } Use this line, if you are using VGA video { cga console } Use this line, if you are using CGA video { ega console } Use this line, if you are using EGA video { mda console } Use this line, if you are using MDA

Notes for Graphics:

• If your VGA-Bios resides at E000-EFFF, turn off video BIOS shadow for this address range and add the statement vbios_seg 0xe000 to the correct vios-statement, see the example below

• If your VBios size is only 32K you set it with vbios_size 0x8000, you then gain some space for UMB or hardware ram locations.

• Set "allowvideoportaccess on" earlier in this configuration file if DOSEMU won't boot properly, such as hanging with a blank screen, beeping, leaving Linux video in a bad state, or the video card bootup message seems to stick.

• Video BIOS shadowing (in your CMOS setup) at C000-CFFF must be disabled.

  CAUTION: TURN OFF VIDEO BIOS SHADOWING BEFORE ENABLING GRAPHICS! This is not always necessary, but a word to the wise shall be sufficient.

• If you have a dual-monitor configuration (e.g. MDA as second display), you then may run CAD programs on 2 displays or let play your debugger on the MDA while debugging a graphics program on the VGA (e.g TD -do ). You also may switch to the MDA display by using the DOS command mode mono (mode co80 returns to your normal display). This feature can be enabled by the switch "dualmon" like this:

  video { vga console graphics dualmon }

  and can be used on a xterm and the console, but of course not, if you have the MDA as your primary display. You also must set USE_DUALMON 1 in include/video.h. NOTE: Make sure no more then one process is using this feature ! ( you will get funny garbage on your MDA display. ) Also, you must NOT have the dualmon-patches for kernel applied ( having the MDA as Linux console )

• If you want to run dosemu in situations when human doesn't sit at console (for instance to run it by cron) and want console option be enabled you should use option forcevtswitch.

  { vga console forcevtswitch }

  Without the option dosemu waits for becoming virtual terminal on which dosemu is run active (i.e. user must press Alt-F?). With this option dosemu perform the switch itself. Be careful with this option because with it user sat at console may face with unexpected switch.

It may be necessary to set this to "on" if DOSEMU can't boot up properly on your system when it's set "off" and when graphics are enabled. Note: May interfere with serial ports when using certain video boards.

allowvideoportaccess on

Any 100% compatible standard VGA card MAY work with this:

video { vga console graphics }

If your VGA-BIOS is at segment E000, this may work for you:

video { vga console graphics vbios_seg 0xe000 }

Trident SVGA with 1 megabyte on board

video { vga console graphics chipset trident memsize 1024 }

Diamond SVGA (not S3 chip)

video { vga console graphics chipset diamond }

Cirrus SVGA

video { vga console graphics chipset cirrus }

ET4000 SVGA card with 1 megabyte on board:

video { vga console graphics chipset et4000 memsize 1024 }

or

video { vga console graphics chipset et4000 memsize 1024 vbios_size 0x8000 }

S3-based SVGA video card with 1 megabyte on board:

video { vga console graphics chipset s3 memsize 1024 }

Avance Logic (ALI) 230x SVGA

video { vga console graphics chipset avance }

For ATI graphic mode

ports { 0x1ce 0x1cf 0x238 0x23b 0x23c 0x23f 0x9ae8 0x9ae9 0x9aee 0x9aef }

Matrox millenium:

video { vga console graphics chipset matrox }

VGA-cards with a WD(Paradise) chip:

video { vga console graphics chipset wdvga }

2.2.17. Memory settings

These are memory parameters, stated in number of kilobytes. If you get lots of disk swapping while DOSEMU runs, you should reduce these values.

umb_max is a new parameter which tells DOSEMU to be more aggressive about finding upper memory blocks. The default is 'off'.

To be more aggressive about finding XMS UMB blocks use this:

umb_max on

To be more secure use 'secure on'. If "on", then it disables DPMI access to dosemu code and also disables execution of dosemu supplied 'system' commands, which may execute arbitrary Linux-commands otherwise. The background is, that DPMI clients are allowed to create selectors that span the whole user space, hence may hack into the dosemu code, and (when dosemu runs root or is suid root) can be a security hole. "secure on" closes this hole, though this would very likely also disable some dos4gw games :(. Therfore NOTE: You may not be able to run some DPMI programs, hence, before reporting such a program as 'not running', first try to set 'secure off'.

secure on # "on" or "off"

The below enables/disables DPMI and sets the size of DPMI memory.

dpmi 4086 # DPMI size in K, or "off"

The best solution (security wise), however, is to run dosemu non-suid root under X (which is possible since dosemu-0.97.10). Under X most of the things we would need to run under root privilidges aren't needed, as the X server supports them. And giving DPMI access to non-suid root dosemu is not at all critical. You may forbid some users to use an eventually available suid root binary by setting `nosuidroot' in /etc/dosemu.users.

XMS is enabled by the following statement

xms 1024 # XMS size in K, or "off"

For ems, you now can set the frame to any 16K between 0xc800..0xe000

ems 1024 # EMS size in K, or "off"

or

ems { ems_size 1024 ems_frame 0xe000 }

or

ems { ems_size 2048 ems_frame 0xd000 }

If you have adapters, which have memory mapped IO, you may map those regions with hardware_ram { .. }. You can only map in entities of 4k, you give the address, not the segment. The entry below maps 0xc8000..0xc8fff and 0xcc000..0xcffff:

hardware_ram { 0xc8000 range 0xcc000 0xcffff }

With the entry below you define the maximum conventional RAM to show apps:

dosmem 640

2.2.18. IRQ passing

The irqpassing statement accepts IRQ values between 3..15, if using the { .. } syntax each value or range can be prefixed by the keyword use_sigio to monitor the IRQ via SIGIO. If this is missing the IRQ is monitored by SIGALRM.

Use/modify one of the below statements

irqpassing off # this disables IRQ monitoring irqpassing 15 irqpassing { 15 } irqpassing { use_sigio 15 } irqpassing { 10 use_sigio range 3 5 }

2.2.19. Port Access

WARNING: GIVING ACCESS TO PORTS IS BOTH A SECURITY CONCERN AND SOME PORTS ARE DANGEROUS TO USE. PLEASE SKIP THIS SECTION, AND DON'T FIDDLE WITH THIS SECTION UNLESS YOU KNOW WHAT YOU'RE DOING.

These keywords are allowable on a "ports" line.

ports { 0x388 0x389 } # for SimEarth ports { 0x21e 0x22e 0x23e 0x24e 0x25e 0x26e 0x27e 0x28e 0x29e } # for jill

2.2.20. Speaker

These keywords are allowable on the "speaker" line:

Recommended:

speaker off

2.2.21. Hard disks

WARNING: DAMAGE MIGHT RESULT TO YOUR HARD DISK (LINUX AND/OR DOS) IF YOU FIDDLE WITH THIS SECTION WITHOUT KNOWING WHAT YOU'RE DOING!

The best way to get started with DOSEMU is to use use the bootdisk method (see doc/README.txt, chapter "Disks, boot directories and floppies"). Fiddling with hdimages and real harddisk is obsolete now.

As a last resort, if you want DOSEMU to be able to access a DOS partition, the safer type of access is "partition" access, because "wholedisk" access gives DOSEMU write access to a whole physical disk, including any vulnerable Linux partitions on that drive!

IMPORTANT

You must not have LILO installed on the partition for dosemu to boot off. As of 04/26/94, doublespace and stacker 3.1 will work with wholedisk or partition only access. Stacker 4.0 has been reported to work with wholedisk access.

Please read the documentation in the "doc" subdirectory for info on how to set up access to real hard disk.

These are meanings of the keywords:

Use/modify one (or more) of the folling statements:

disk { image "/var/lib/dosemu/hdimage" } # use diskimage file. disk { partition "/dev/hda1" readonly } # 1st partition on 1st IDE. disk { partition "/dev/hda1" bootfile "/var/lib/bootsect.dos" } # 1st partition on 1st IDE # booting from the specified # file. disk { partition "/dev/hda6" readonly } # 6th logical partition. disk { partition "/dev/sdb1" readonly } # 1st partition on 2nd SCSI. disk { wholedisk "/dev/hda" } # Entire disk drive unit

Recommended:

disk { image "/var/lib/dosemu/hdimage" }

2.2.22. DOSEMU boot

Use the following option to boot from the specified file, and then once booted, have bootoff execute in autoexec.bat. Thanks Ted :-). Notice it follows a typical floppy spec. To create this file use:

dd if=/dev/fd0 of=/var/lib/dosemu/bdisk bs=16k

bootdisk { heads 2 sectors 18 tracks 80 threeinch file /var/lib/dosemu/bdisk }

Specify extensions for the CONFIG and AUTOEXEC files. If the below are uncommented, the extensions become CONFIG.EMU and AUTOEXEC.EMU. NOTE: this feature may affect file naming even after boot time. If you use MSDOS 6+, you may want to use a CONFIG.SYS menu instead.

EmuSys EMU EmuBat EMU

2.2.23. Floppy disks

This part is fairly easy. Make sure that the first (/dev/fd0) and second (/dev/fd1) floppy drives are of the correct size, "threeinch" and/or "fiveinch". A floppy disk image can be used instead, however.

FOR SAFETY, UNMOUNT ALL FLOPPY DRIVES FROM YOUR FILESYSTEM BEFORE STARTING UP DOSEMU! DAMAGE TO THE FLOPPY MAY RESULT OTHERWISE!

Use/modify one of the below:

floppy { device /dev/fd0 threeinch } floppy { device /dev/fd1 fiveinch } floppy { heads 2 sectors 18 tracks 80 threeinch file /var/lib/dosemu/diskimage }

If floppy disk speed is very important, uncomment the following line. However, this makes the floppy drive a bit unstable. This is best used if the floppies are write-protected. Use an integer value to set the time between floppy updates.

FastFloppy 8

2.2.24. Printers

Printer is emulated by piping printer data to a file or via a unix command such as "lpr". Don't bother fiddling with this configuration until you've got DOSEMU up and running already.

NOTE: Printers are assigned to LPT1:, LPT2:, and LPT3: on a one for one basis with each line below. The first printer line is assigned to LPT1:, second to LPT2:, and third to LPT3:. If you do not specify a base port, the emulator will setup the bios to report 0x378, 0x278, and 0x3bc for LPT1:, LPT2:, and LPT3: respectively.

To use standard unix lpr command for printing use this line:

printer { options "%s" command "lpr" timeout 20 }

And for any special options like using pr to format files, add it to the options parameter:

printer { options "-p %s" command "lpr" timeout 10 } pr format it

To just have your printer output end up in a file, use the following line:

printer { file "lpt3" }

If you have a DOS application that is looking to access the printer port directly, and uses the bios LPT: setting to find out the port to use, you can modify the base port the bios will report with the following:

printer { options "%s" command "lpr" base 0x3bc }

Be sure to also add a port line to allow the application access to the port:

ports { device /dev/lp0 0x3bc 0x3bd 0x3be }

NOTE: applications that require this will not interfere with applications that continue to use the standard bios calls. These applications will continue to send the output piped to the file or unix command.

2.2.25. Sound

The sound driver is more or less likely to be broken at the moment.

Use this to disable sound support even if it is configured in

sound_emu off

Linux defaults

sound_emu { sb_base 0x220 sb_irq 5 sb_dma 1 sb_dsp /dev/dsp sb_mixer /dev/mixer mpu_base 0x330 }

NetBSD defaults

sound_emu { sb_base 0x220 sb_irq 5 sb_dma 1 sb_dsp /dev/sound sb_mixer /dev/mixer mpu_base 0x330 }