Little Known Works of Famous Authors

DOS/Windows to Linux HOWTO

  From DOS/Windows to Linux HOWTO

  By Guido Gonzato,

  v1.3.0, 15 April 1998


  This HOWTO is dedicated to all the (soon to be former?) DOS and Win_

  dows users who have decided to switch to Linux, the free UNIX clone.

  The purpose of this document is to help the reader translate his or

  her knowledge of DOS and Windows into the Linux environment, as well

  as providing hints on exchanging files and resources between the two




  Table of Contents






















































  1. Introduction


     1.1 Is Linux Right for You?

     1.2 It Is. Tell Me More

        1.2.1 Introductory Concepts

        1.2.2 Getting Help

     1.3 Conventions


  2. For the Impatient


  3. Files and Programs


     3.1 Files: Preliminary Notions

     3.2 Symbolic Links

     3.3 Permissions and Ownership

     3.4 Files: Translating Commands

        3.4.1 Examples

     3.5 Running Programs: Multitasking and Sessions

     3.6 Running Programs on Remote Computers


  4. Using Directories


     4.1 Directories: Preliminary Notions

     4.2 Directories Permissions

     4.3 Directories: Translating Commands

        4.3.1 Examples


  5. Floppies, Hard Disks, and the Like


     5.1 Managing Devices the DOS Way

     5.2 Managing Devices the UNIX Way

     5.3 Backing Up


  6. What About Windows?


  7. Tailoring the System


     7.1 System Initialisation Files

     7.2 Program Initialisation Files


  8. A Bit of Programming


     8.1 Shell Scripts: .BAT Files on Steroids

     8.2 C for Yourself


  9. The Remaining 1%


     9.1 Using tar & gzip

     9.2 Installing Applications

     9.3 Tips You Can't Do Without

     9.4 Where to Find Applications

     9.5 A Few Things You Couldn't Do

     9.6 Common Extensions and Related Programs

     9.7 Converting Files


  10. The End, for Now


     10.1 Copyright

     10.2 Disclaimer








  1.  Introduction




  1.1.  Is Linux Right for You?



  You want to switch from DOS/Windows to Linux? Good idea: Linux is

  technically superior to DOS, Windows 95 and even Windows NT. But

  beware: it might not be useful for you if you are not the right type

  of user. In fact, DOS and Windows are mostly employed for games and

  office productivity, while Linux gives its best at networking,

  development, and scientific computing.  Linux is incredibly powerful,

  but learning how to harness that power takes time. Thus, if mostly

  need commercial sw, or if you don't feel like learning new commands

  and concepts, you had better look elsewhere.


  Work is underway to make Linux simpler to use, but don't expect to be

  proficient with it unless you read a lot of documentation and use it

  at least for a few months. Linux won't give you instant results. In

  spite of these warnings, I'm 100% confident that if you are the right

  user type you'll find in Linux your computer Nirvana, and never want

  to use DOS or Windows again. By the way, Linux + DOS/Win can coexist

  happily on the same machine.


  Prerequisites for this howto: I'll assume that



  _  you know the basic DOS commands and concepts;


  _  Linux, possibly with X Window System, is properly installed on your



  _  your shell---the equivalent of COMMAND.COM---is bash.


  Unless specified, all information in this work is aimed at bad ol'

  DOS.  There is information about Windows here and there, but bear in

  mind that Windows and Linux are totally different, unlike DOS that is

  sort of a UNIX poor relation. Please also note that this work is

  neither a complete primer nor a configuration guide!




  1.2.  It Is. Tell Me More



  You installed Linux and the programs you needed on the PC. You gave

  yourself an account (if not, type adduser now!) and Linux is running.

  You've just entered your name and password, and now you are looking at

  the screen thinking: ``Well, now what?''


  Now, don't despair. You're almost ready to do the same things you used

  to do with DOS/Win, and many more. If you were running DOS/Win instead

  of Linux, you would be doing some of the following tasks:



  _  running programs and creating, copying, viewing, deleting,

     printing, renaming files;


  _  CD'ing, MD'ing, RD'ing, and DIR'ring your directories;


  _  formatting floppies and copying files from/to them;


  _  tailoring the system;



  _  writing .BAT files and programs in your favourite language;


  _  the remaining 1%.


  You'll be glad to know that these tasks can be accomplished under

  Linux in a fashion similar to DOS. Under DOS, the average user uses

  very few of the 100+ commands available: the same, up to a point,

  applies to Linux.




  1.2.1.  Introductory Concepts



  The best way to learn something new is to get your feet wet. You are

  strongly encouraged to experiment and play with Linux: you can't

  damage the system that way. A few points:



  _  first of all, how to quit Linux safely. If you see a text mode

     screen, press <CTRL-ALT-DEL>, wait for the system to reboot, then

     switch off the PC. If you are working under X Window System, press

     <CTRL-ALT-BACKSPACE> first, then <CTRL-ALT-DEL>. Never switch off

     or reset the PC directly: this could damage the file system;


  _  unlike DOS, Linux has built-in security mechanisms. Files and

     directories have permissions associated to them; as a result, some

     cannot be accessed by the normal user; (see Section ``Permissions

     and Ownership''). DOS, on the contrary, will let you wipe out the

     entire contents of your hard disk;


  _  there's a special user called ``root'': the system administrator,

     with full power of life and death on the machine.  If you work on

     your own PC, you'll be root as well. Working as root is dangerous:

     any mistake can seriously damage or destroy the system just like

     with DOS/Win. Don't work as root unless absolutely necessary;


  _  much of the complexity of Linux comes from its extreme

     configurability: virtually every feature and every application can

     be tailored through one or more configuration files. Complexity is

     the price to pay for power;


  _  redirection and piping are a side DOS feature, a very inportant one

     and much more powerful under Linux. Simple commands can be strung

     together to accomplish complex tasks. I strongly suggest that you

     learn how to use them.




  1.2.2.  Getting Help



  There are many ways to get help with Linux. The most important are:



  _  reading the documentation---I mean it. Although the HOWTO you are

     reading may serve as an introduction to Linux, there are several

     books that you really should read: Matt Welsh's ``Linux

     Installation and Getting Started'' (

     <> ), Larry Greenfield's

     ``Linux User Guide'' (


     guide>), and the Linux FAQ ( <

     FAQ.html>).  Feel a guilty conscience until you have read at least

     one of them;


  _  the documentation of the packages installed on the machine is often

     found in subdirectories under /usr/doc/;


  _  to get some help about the ``internal commands'' of the shell, type

     help or, better, man bash or info bash;


  _  to get help on a command, type man command that invokes the manual

     (``man'') page pertinent to command. Alternatively, type info

     command that invokes, if available, the info page pertinent to

     command. Info is a hypertext-based documentation system, perhaps

     not intuitive to use at first. Finally, you may try apropos command

     or whatis command. With all of these commands, press `q' to exit.




  1.3.  Conventions



  Throughout this work, examples will often follow the following format:

  <...> is a required argument, while [...] an optional one.  Example:




       $ tar -tf <file.tar> [> redir_file]





  file.tar must be indicated, but redirection to redir_file is optional.


  ``RMP'' means ``please Read the Man Pages for further information''.

  I can't stress enough how important reading the documentation is.


  When the prompt of a command example is `#', the command can only be

  performed by root.




  2.  For the Impatient


  Want to strike out? Have a look at this table:

























  DOS                     Linux                   Notes



  ATTRIB (+-)attr file    chmod <mode> file       completely different

  BACKUP                  tar -Mcvf device dir/   ditto

  CD dirname\             cd dirname/             almost the same syntax

  COPY file1 file2        cp file1 file2          ditto

  DEL file                rm file                 beware - no undelete

  DELTREE dirname         rm -R dirname/          ditto

  DIR                     ls                      not exactly the same syntax

  DIR file /S             find . -name file       completely different

  EDIT file               vi file                 I think you won't like it

                          jstar file              feels like dos' edit

  FORMAT                  fdformat,

                          mount, umount           quite different syntax

  HELP command            man command,            same philosophy

                          info command

  MD dirname              mkdir dirname/          almost the same syntax

  MOVE file1 file2        mv file1 file2          ditto

  NUL                     /dev/null               ditto

  PRINT file              lpr file                ditto

  PRN                     /dev/lp0,

                          /dev/lp1                ditto

  RD dirname              rmdir dirname/          almost the same syntax

  REN file1 file2         mv file1 file2          not for multiple files

  RESTORE                 tar -Mxpvf device       different syntax

  TYPE file               less file               much better

  WIN                     startx                  poles apart!





  If you need more than a table of commands, please refer to the

  following sections.




  3.  Files and Programs





  3.1.  Files: Preliminary Notions



  Linux has a structure of directories and files very similar to

  DOS/Win's.  Files have filenames that obey special rules, are stored

  in directories, some are executable, and among these most have command

  switches. Moreover, you can use wildcard characters, redirection, and

  piping. There are only a few minor differences:



  _  under DOS, file names are in the so-called 8.3 form; e.g.

     NOTENOUG.TXT. Under Linux we can do better. If you installed Linux

     using a file system like ext2 or umsdos, you can use longer

     filenames (up to 255 characters), and with more than one dot: for

     example, This_is.a.VERY_long.filename. Please note that I used both

     upper and lower case characters: in fact...


  _  upper and lower case characters in file names or commands are

     different. Therefore, FILENAME.tar.gz and filename.tar.gz are two

     different files. ls is a command, LS is a mistake;


  _  Windows 95 users, beware when using long file names under Linux.

     If a file name contains spaces (not recommended but possible), you

     must enclose the file name in double quotes whenever you refer to

     it. For example:




       $ # the following command makes a directory called "My old files"

       $ mkdir "My old files"

       $ ls

       My old files    bin     tmp






  Further, some characters shouldn't be used: some are !*$&.


  _  there are no compulsory extensions like .COM and .EXE for programs,

     or .BAT for batch files. Executable files are marked by an asterisk

     `*' at the end of their name when you issue the ls -F command. For





       $ ls -F

       I_am_a_dir/   cindy.jpg    cjpg*   letter_to_Joe    my_1st_script*  old~






  The files cjpg* and my_1st_script* are executables, that is ``pro_

  grams''. Under DOS, backup files end in .BAK, while under Linux they

  end with a tilde `~'. Further, a file whose name starts with a dot is

  considered as hidden. Example: the file won't show

  up after the ls command;


  _  DOS program switches are obtained with /switch, Linux switches with

     -switch or --switch. Example: dir /s becomes ls -R. Note that many

     DOS programs, like PKZIP or ARJ, use UNIX-style switches.


  You can now jump to Section ``Translating Commands from DOS to

  Linux'', but if I were you I'd read on.




  3.2.  Symbolic Links



  UNIX has a type of file that doesn't exist under DOS: the symbolic

  link.  This can be thought of as a pointer to a file or to a

  directory, and can be used instead of the file or directory it points

  to; it's similar to Windows 95 shortcuts. Examples of symbolic links

  are /usr/X11, which points to /usr/X11R6; /dev/modem, which points to

  either /dev/cua0 or /dev/cua1.


  To make a symbolic link:




       $ ln -s <file_or_dir> <linkname>








       $ ln -s /usr/doc/g77/DOC g77manual.txt





  Now you can refer to g77manual.txt instead of /usr/doc/g77/DOC.  Links

  appear like this in directory listings:




       $ ls -F


       $ ls -l

       (various things...)           g77manual.txt -> /usr/doc/g77/DOC







  3.3.  Permissions and Ownership



  DOS files and directories have the following attributes: A (archive),

  H (hidden), R (read-only), and S (system). Only H and R make sense

  under Linux: hidden files start with a dot, and for the R attribute,

  read on.


  Under UNIX a file has ``permissions'' and an owner, who in turn

  belongs to a ``group''. Look at this example:




       $ ls -l /bin/ls

       -rwxr-xr-x  1  root  bin  27281 Aug 15 1995 /bin/ls*





  The first field contains the permissions of the file /bin/ls, which

  belongs to root, group bin. Leaving the remaining information aside,

  remember that -rwxr-xr-x means, from left to right:


  - is the file type (- = ordinary file, d = directory, l = link, etc);

  rwx are the permissions for the file owner (read, write, execute); r-x

  are the permissions for the group of the file owner (read, execute);

  (I won't cover the concept of group, you can survive without it as

  long as you're a beginner ;-) r-x are the permissions for all other

  users (read, execute).


  The directory /bin has permissions, too: see Section ``Directories

  Permissions'' for further details. This is why you can't delete the

  file /bin/ls unless you are root: you don't have the permission to do

  so. To change a file's permissions, the command is:




       $ chmod <whoXperm> <file>





  where who is u (user, that is owner), g (group), o (other), X is

  either + or -, perm is r (read), w (write), or x (execute). Common

  examples of chmod use are the following:


       $ chmod +x file





  this sets the execute permission for the file.




       $ chmod go-rw file





  this removes read and write permission for everyone but the owner.




       $ chmod ugo+rwx file





  this gives everyone read, write, and execute permission.




       # chmod +s file





  this makes a so-called ``setuid'' or ``suid'' file---a file that

  everyone can execute with its owner's privileges. Typically, you'll

  come across root suid files; these are often important system files,

  like the X server.


  A shorter way to refer to permissions is with digits: rwxr-xr-x can be

  expressed as 755 (every letter corresponds to a bit: --- is 0, --x is

  1, -w- is 2, -wx is 3...). It looks difficult, but with a bit of

  practice you'll understand the concept.


  root, being the superuser, can change everyone's file permissions.





  3.4.  Files: Translating Commands



  On the left, the DOS commands; on the right, their Linux counterpart.




       ATTRIB:         chmod

       COPY:           cp

       DEL:            rm

       MOVE:           mv

       REN:            mv

       TYPE:           more, less, cat





  Redirection and plumbing operators:  < > >> |


  Wildcards: * ?


  nul:        /dev/null


  prn, lpt1:  /dev/lp0 or /dev/lp1; lpr



  3.4.1.  Examples






       DOS                                     Linux



       C:\GUIDO>ATTRIB +R FILE.TXT            $ chmod 400 file.txt

       C:\GUIDO>COPY JOE.TXT JOE.DOC           $ cp joe.txt joe.doc

       C:\GUIDO>COPY *.* TOTAL                $ cat * > total

       C:\GUIDO>COPY FRACTALS.DOC PRN         $ lpr fractals.doc

       C:\GUIDO>DEL TEMP                       $ rm temp

       C:\GUIDO>DEL *.BAK                     $ rm *~

       C:\GUIDO>MOVE PAPER.TXT TMP\          $ mv paper.txt tmp/

       C:\GUIDO>REN PAPER.TXT PAPER.ASC       $ mv paper.txt paper.asc

       C:\GUIDO>PRINT LETTER.TXT              $ lpr letter.txt

       C:\GUIDO>TYPE LETTER.TXT               $ more letter.txt

       C:\GUIDO>TYPE LETTER.TXT               $ less letter.txt

       C:\GUIDO>TYPE LETTER.TXT > NUL         $ cat letter.txt > /dev/null

               n/a                             $ more *.txt *.asc

               n/a                             $ cat section*.txt | less








  _  * is smarter under Linux: * matches all files except the hidden

     ones; .* matches all hidden files (but also the current directory

     `.' and parent directory `..': beware!); *.* matches only those

     that have a '.' in the middle or that end with a dot; p*r matches

     both `peter' and `piper'; *c* matches both `picked' and `peck';


  _  when using more, press <SPACE> to read through the file, `q' to

     exit. less is more intuitive and lets you use the arrow keys;


  _  there is no UNDELETE, so think twice before deleting anything;


  _  in addition to DOS' < > >>, Linux has 2> to redirect error messages

     (stderr); moreover, 2>&1 redirects stderr to stdout, while 1>&2

     redirects stdout to stderr;


  _  Linux has another wildcard: the []. Use: [abc]* matches files

     starting with a, b, c; *[I-N1-3] matches files ending with I, J, K,

     L, M, N, 1, 2, 3;


  _  lpr <file> prints a file in background. To check the status of the

     print queue, use lpq; to remove a file from the print queue, use



  _  there is no DOS-like RENAME; that is, mv *.xxx *.yyy won't work.

     You could try this simple script; see Section ``Shell Scripts: .BAT

     Files on Steroids'' for details.






     # ren: rename multiple files according to several rules


     if [ $# -lt 3 ] ; then

       echo "usage: ren \"pattern\" \"replacement\" files..."

       exit 1



     OLD=$1 ; NEW=$2 ; shift ; shift


     for file in $*


       new=`echo ${file} | sed s/${OLD}/${NEW}/g`

       mv ${file} $new






  Beware: it doesn't behave like DOS' REN, as it uses ``regular expres_

  sions'' that you still don't know. Shortly, if you simply want to

  change file extensions, use it as in: ren "htm$" "html" *htm.  Don't

  forget the $ sign.


  _  use cp -i and mv -i to be warned when a file is going to be





  3.5.  Running Programs: Multitasking and Sessions



  To run a program, type its name as you would do under DOS. If the

  directory (Section ``Using Directories'') where the program is stored

  is included in the PATH (Section ``System Initialisation Files''), the

  program will start. Exception: unlike DOS, under Linux a program

  located in the current directory won't run unless the directory is

  included in the PATH. Escamotage: being prog your program, type



  This is what the typical command line looks like:




       $ command [-s1 [-s2] ... [-sn]] [par1 [par2] ... [parn]] [< input] [> output]





  where -s1, ..., -sn are the program switches, par1, ..., parn are the

  program parameters. You can issue several commands on the command





       $ command1 ; command2 ; ... ; commandn





  That's all about running programs, but it's easy to go a step beyond.

  One of the main reasons for using Linux is that it is a multitasking

  os---it can run several programs (from now on, processes) at the same

  time. You can launch processes in background and continue working

  straight away. Moreover, Linux lets you have several sessions: it's

  like having many computers to work on at once!



  _  To switch to session 1..6 on the virtual consoles, press <ALT-F1>

     ... <ALT-F6>


  _  To start a new session in the same v.c. without leaving the current

     one, type su - <loginname>. Example: su - root. This is useful, for

     instance, when you need to perform a task that only root can do.


  _  To end a session, type exit. If there are stopped jobs (see later),

     you'll be warned.


  _  To launch a process in background, add an ampersand '&' at the end

     of the command line:




       $ progname [-switches] [parameters] [< input] [> output] &

       [1] 123






  the shell identifies the process with a job number (e.g. [1]; see

  below), and with a PID (Process Identification Number; 123 in our



  _  To see how many processes there are, type ps -ax. This will output

     a list of currently running processes.


  _  To kill a process, type kill <PID>. You may need to kill a process

     when you don't know how to quit it the right way.... Unless you're

     root, you can't kill other people's processes. Sometimes, a process

     will only be killed by kill -SIGKILL <PID>.


     In addition, the shell allows you to stop or temporarily suspend a

     process, send a process to background, and bring a process from

     background to foreground. In this context, processes are called



  _  To see how many jobs there are, type jobs. Here the jobs are

     identified by their job number, not by their PID.


  _  To stop a process running in foreground, press <CTRL-C> (it won't

     always work).


  _  To suspend a process running in foreground, press <CTRL-Z> (ditto).


  _  To send a suspended process into background, type bg <job> (it

     becomes a job).


  _  To bring a job to foreground, type fg <job>. To foreground the last

     backgrounded (is my English weird?) job, simply type fg.


  _  To kill a job, type kill <%job> where <job> may be 1, 2, 3,...


  Using these commands you can format a disk, zip a bunch of files,

  compile a program, and unzip an archive all at the same time, and

  still have the prompt at your disposal. Try this with DOS! And try

  with Windows, just to see the difference in performance (if it doesn't

  crash, of course).




  3.6.  Running Programs on Remote Computers



  To run a program on a remote machine whose IP address is, you do:




       $ telnet





  After logging in, start your favourite program. Needless to say, you

  must have a shell account on the remote machine.


  If you have X11, you can even run an X application on a remote

  computer, displaying it on your X screen. Let be

  the remote X computer and let be your Linux machine.

  To run from an X program that resides on, do the following:



  _  fire up X11, start an xterm or equivalent terminal emulator, then





       $ xhost

       $ telnet






  _  after logging in, type:





       remote:$ progname &






  (instead of DISPLAY..., you may have to write: setenv DISPLAY It depends on the remote shell.)


  Et voila! Now progname will start on and will be

  displayed on your machine. Don't try this over the modem though, for

  it's too slow to be usable.




  4.  Using Directories




  4.1.  Directories: Preliminary Notions



  We have seen the differences between files under DOS and Linux. As for

  directories, under DOS the root directory is \, under Linux / is.

  Similarly, nested directories are separated by \ under DOS, by / under

  Linux. Example of file paths:


       Linux:  /home/guido/papers/geology/middle_eocene.tex





  As usual, .. is the parent directory and . is the current directory.

  Remember that the system won't let you cd, rd, or md everywhere you

  want. Each user starts from his or her own directory called 'home',

  given by the system administrator; for instance, on my PC my home dir

  is /home/guido.




  4.2.  Directories Permissions



  Directories, too, have permissions. What we have seen in Section

  ``Permissions and Ownership'' applies to directories as well (user,

  group, and other). For a directory, rx means you can cd to that

  directory, and w means that you can delete a file in the directory

  (according to the file's permissions, of course), or the directory



  For example, to prevent other users from snooping in /home/guido/text:




       $ chmod o-rwx /home/guido/text







  4.3.  Directories: Translating Commands





       DIR:            ls, find, du

       CD:             cd, pwd

       MD:             mkdir

       RD:             rmdir

       DELTREE:        rm -R

       MOVE:           mv






  4.3.1.  Examples















  DOS                                     Linux



  C:\GUIDO>DIR                            $ ls

  C:\GUIDO>DIR FILE.TXT                   $ ls file.txt

  C:\GUIDO>DIR *.H *.C                    $ ls *.h *.c

  C:\GUIDO>DIR/P                          $ ls | more

  C:\GUIDO>DIR/A                          $ ls -l

  C:\GUIDO>DIR *.TMP /S                   $ find / -name "*.tmp"

  C:\GUIDO>CD                             $ pwd

          n/a - see note                  $ cd

          ditto                           $ cd ~

          ditto                           $ cd ~/temp

  C:\GUIDO>CD \OTHER                      $ cd /other

  C:\GUIDO>CD ..\TEMP\TRASH               $ cd ../temp/trash

  C:\GUIDO>MD NEWPROGS                    $ mkdir newprogs

  C:\GUIDO>MOVE PROG ..                   $ mv prog ..

  C:\GUIDO>MD \PROGS\TURBO                $ mkdir /progs/turbo

  C:\GUIDO>DELTREE TEMP\TRASH             $ rm -R temp/trash

  C:\GUIDO>RD NEWPROGS                    $ rmdir newprogs

  C:\GUIDO>RD \PROGS\TURBO                $ rmdir /progs/turbo








  1. when using rmdir, the directory to remove must be empty. To delete

     a directory and all of its contents, use rm -R (at your own risk).


  2. the character '~' is a shortcut for the name of your home

     directory. The commands cd or cd ~ will take you to your home

     directory from wherever you are; the command cd ~/tmp will take you

     to /home/your_home/tmp.


  3. cd - ``undoes'' the last cd.




  5.  Floppies, Hard Disks, and the Like



  There are two ways to manage devices under Linux: the DOS way and the

  UNIX way. Take your pick.



  5.1.  Managing Devices the DOS Way



  Most Linux distributions include the Mtools suite, a set of commands

  that are perfectly equivalent to their DOS counterpart, but start with

  an `m': i.e., mformat, mdir, mdel, mmd, and so on. They can even

  preserve long file names, but not file permissions. If you configure

  Mtools editing a file called /etc/mtools.conf (a sample is provided),

  you can also access the DOS/Win partition, the CD-ROM, and the Zip



  To format a fresh disk though, the mformat command won't do. As root,

  you'll have to issue this command beforehand:




       # fdformat /dev/fd0H1440



  Note: you can't access files on the floppy with a command like, say,

  less a:file.txt! This is the disadvantage of the DOS way of mounting




  5.2.  Managing Devices the UNIX Way



  UNIX has a different way to handle devices than DOS/Win. There are no

  separate volumes like A: or C:; a disk, be it a floppy or whatever,

  becomes part of the local file system through an operation called

  ``mounting''. When you're done using the disk, before extracting it

  you must ``unmount'' it.


  Physically formatting a disk is one thing, making a file system on it

  is another. The DOS command FORMAT A: does both things, but under

  Linux there are separate commands. To format a floppy, see above; to

  create a file system:




       # mkfs -t ext2 -c /dev/fd0H1440





  You can use minix, vfat, dos or other formats instead of ext2. Once

  the disk is prepared, mount it with the command




       # mount -t ext2 /dev/fd0 /mnt





  specifying the right file system if you don't use ext2. Now you can

  address the files in the floppy. All you used to do with A: or B: is

  now done using /mnt instead. Examples:




       DOS                                     Linux



       C:\GUIDO>DIR A:                         $ ls /mnt

       C:\GUIDO>COPY A:*.*                     $ cp /mnt/* .

       C:\GUIDO>COPY *.ZIP A:                  $ cp *.zip /mnt

       C:\GUIDO>EDIT A:FILE.TXT                $ jstar /mnt/file.txt

       C:\GUIDO>A:                             $ cd /mnt

       A:>_                                    /mnt/$ _





  When you've finished, before extracting the disk you must unmount it

  with the command




       # umount /mnt






  Obviously, you have to fdformat and mkfs only unformatted disks, not

  previously used ones. If you want to use the drive B:, refer to

  fd1H1440 and fd1 instead of fd0H1440 and fd0 in the examples above.


  Needless to say, what applies to floppies also applies to other

  devices; for instance, you may want to mount another hard disk or a

  CD-ROM drive. Here's how to mount the CD-ROM:




       # mount -t iso9660 /dev/cdrom /mnt





  This was the ``official'' way to mount your disks, but there's a trick

  in store. Since it's a bit of a nuisance having to be root to mount a

  floppy or a CD-ROM, every user can be allowed to mount them this way:



  _  as root, do the following:




       # mkdir /mnt/a: ; mkdir /mnt/a ; mkdir /mnt/cdrom

       # chmod 777 /mnt/a* /mnt/cd*

       # # make sure that the CD-ROM device is right

       # chmod 666 /dev/hdb ; chmod 666 /dev/fd*






  _  add in /etc/fstab the following lines:




       /dev/cdrom      /mnt/cdrom  iso9660 ro,user,noauto          0       0

       /dev/fd0        /mnt/a:     msdos   user,noauto             0       0

       /dev/fd0        /mnt/a      ext2    user,noauto             0       0






  Now, to mount a DOS floppy, an ext2 floppy, and a CD-ROM:




       $ mount /mnt/a:

       $ mount /mnt/a

       $ mount /mnt/cdrom





  /mnt/a, /mnt/a:, and /mnt/cdrom can now be accessed by every user.

  Remember that allowing everyone to mount disks this way is a gaping

  security hole, if you care.


  Two useful commands are df, which gives information on the mounted

  file systems, and du dirname which reports the disk space consumed by

  the directory.




  5.3.  Backing Up



  There are several packages to help you, but the very least you can do

  for a multi-volume backup is (as root):




       # tar -M -cvf /dev/fd0H1440 dir_to_backup/





  Make sure to have a formatted floppy in the drive, and several more

  ready.  To restore your stuff, insert the first floppy in the drive

  and do:




       # tar -M -xpvf /dev/fd0H1440







  6.  What About Windows?



  The ``equivalent'' of Windows is the graphic system X Window System,

  or X11 for short. Unlike Windows or the Mac, X11 wasn't designed for

  ease of use or to look good, but just to provide graphic facilities to

  UNIX workstations.  These are the main differences:



  _  while Windows looks and feels the same all over the world, X11 does

     not: it's much more configurable. X11's overall look is given by a

     key component called ``window manager'', of which you have a wide

     choice: fvwm, basic but nice and memory efficient, fvwm2-95,

     Afterstep, and many more. The w.m. is usually invoked by a file

     called .xinitrc;


  _  your w.m. can be configured so as a window acts as in, er, Windows:

     you click on it and it comes to foreground. Another possibility is

     that it comes to foreground when the mouse moves over it

     (``focus''). Also, the placement of windows on the screen can be

     automatic or interactive: if a strange frame appears instead of

     your program, left click where you want it to appear;


  _  most actions can be tailored editing one or more configuration

     files. Read the docs of your window manager; the configuration file

     can be .fvwmrc, .fvwm2rc95, .steprc, etc. A sample configuration

     file is typically found in /etc/X11/window-manager-



  _  X11 applications are written using special libraries (``widget

     sets''); as several are available, applications look different. The

     most basic ones are those that use the Athena widgets (2--D look;

     xdvi, xman, xcalc); others use Motif (netscape), others still use

     Tcl/Tk, XForms, Qt, Gtk, and what have you. Some---not all---of

     these libraries provide roughly the same look and feel as Windows;


  _  well, not quite. The feel, unfortunately, can be incoherent. For

     instance, if you select a line of text using the mouse and press

     <BACKSPACE>, you'd expect the line to disappear, right? This

     doesn't work with Athena--based apps, but it does with Motif, Qt,

     Gtk, and Tcl/Tk ones;


  _  how the scrollbars and resizing work depends on the window manager

     and the widget set. Tip: if you find that the scrollbars don't

     behave as you would expect, try using the central button or the two

     buttons together to move them;


  _  applications don't have an icon by default, but they can have many.

     Most window managers feature a menu you recall by clicking on the

     desktop (``root window''); needless to say, the menu can be

     tailored. To change the root window appearance, use xsetroot or



  _  the clipboard can only contain text, and behaves strange. Once

     you've selected text, it's already copied to the clipboard: move

     elsewhere and press the central button to paste it. There's an

     application, xclipboard, that provides for multiple clipboard



  _  drag and drop is an option, and is only available if you use X11

     applications that support it.


  To save memory, one should use applications that use the same

  libraries, but this is difficult to do in practice.


  The K Desktop Environment project aims at making X11 look and behave

  as coherently as Windows; it's currently in early beta stage but,

  believe me, it's awesome. Point your browser to  <>.




  7.  Tailoring the System




  7.1.  System Initialisation Files



  Two important files under DOS are AUTOEXEC.BAT and CONFIG.SYS, which

  are used at boot time to initialise the system, set some environment

  variables like PATH and FILES, and possibly launch a program or batch

  file.  Under Linux there are lots of initialisation files, some of

  which you had better not tamper with until you know exactly what you

  are doing. I'll tell you what the most important are, anyway:




       FILES                                   NOTES


       /etc/inittab                            don't touch for now!

       /etc/rc.d/*                             ditto





  If all you need is setting the $PATH and other environment variables,

  or you want to change the login messages or automatically launch a

  program after the login, have a look at the following files:









  FILES                                   NOTES


  /etc/issue                              sets pre-login message

  /etc/motd                               sets post-login message

  /etc/profile                            sets $PATH and other variables, etc.

  /etc/bashrc                             sets aliases and functions, etc.

  /home/your_home/.bashrc                 sets your aliases + functions

  /home/your_home/.bash_profile   or

  /home/your_home/.profile                sets environment + starts your progs





  If the latter file exists (note that it is a hidden file), it will be

  read after the login and the commands in it will be executed.


  Example---look at this .bash_profile:




  # I am a comment

  echo Environment:

  printenv | less   # equivalent of command SET under DOS

  alias d='ls -l'   # easy to understand what an alias is

  alias up='cd ..'

  echo "I remind you that the path is "$PATH

  echo "Today is `date`"  # use the output of command 'date'

  echo "Have a good day, "$LOGNAME

  # The following is a "shell function"

  ctgz() # List the contents of a .tar.gz archive.


    for file in $*


      gzip -dc ${file} | tar tf -



  # end of .profile





  $PATH and $LOGNAME, you guessed right, are environment variables.

  There are many others to play with; for instance, RMP for apps like

  less or bash.




  7.2.  Program Initialisation Files



  Under Linux, virtually everything can be tailored to your needs. Most

  programs have one or more initialisation files you can fiddle with,

  often as a .prognamerc in your home dir. The first ones you'll want to

  modify are:



  _   .inputrc: used by bash to define key bindings;


  _   .xinitrc: used by startx to initialise X Window System;


  _   .fvwmrc: used by the window manager fvwm.


  _   .joerc: used by the editor joe;


  _   .jedrc: used by the editor jed;


  _   .pinerc: used by the mail reader pine;


  _   .Xdefault: used by many X programs.


  For all of these and the others you'll come across sooner or later,

  RMP. As a final note, let me suggest that you check out the

  Configuration HOWTO on

    <> .




  8.  A Bit of Programming





  8.1.  Shell Scripts: .BAT Files on Steroids



  If you used .BAT files to create shortcuts of long command lines (I

  did a lot), this goal can be attained by inserting appropriate alias

  lines (see example above) in profile or .profile. But if your .BATs

  were more complicated, then you'll love the scripting language made

  available by the shell: it's as powerful as QBasic, if not more. It

  has variables, structures like while, for, case, if... then... else,

  and lots of other features: it can be a good alternative to a ``real''

  programming language.


  To write a script---the equivalent of a .BAT file under DOS---all you

  have to do is write a standard ASCII file containing the instructions,

  save it, then make it executable with the command chmod +x

  <scriptfile>. To execute it, type its name.


  A word of warning. The system editor is called vi, and in my

  experience most new users find it very difficult to use. I'm not going

  to explain how to use it, because I don't like it and don't use it, so

  there. Suffice it here to say that:



  _  to insert some text, type `i' then your text;


  _  to delete characters, type <ESC> then `x';


  _  to quit vi whithout saving, type <ESC> then :q!


  _  to save and quit, type <ESC> then :wq.


  A good beginner editor is joe: invoking it by typing jstar you'll get

  the same key bindings as the DOS editor. jed in WordStar or IDE mode

  is even better. Please consult Section ``Where to Find Applications''

  to see where to get these editors.


  Writing scripts under bash is such a vast subject it would require a

  book by itself, and I will not delve into the topic any further. I'll

  just give you an example of shell script, from which you can extract

  some basic rules:














  # I am a comment

  # don't change the first line, it must be there

  echo "This system is: `uname -a`" # use the output of the command

  echo "My name is $0" # built-in variables

  echo "You gave me the following $# parameters: "$*

  echo "The first parameter is: "$1

  echo -n "What's your name? " ; read your_name

  echo notice the difference: "hi $your_name" # quoting with "

  echo notice the difference: 'hi $your_name' # quoting with '

  DIRS=0 ; FILES=0

  for file in `ls .` ; do

    if [ -d ${file} ] ; then # if file is a directory

      DIRS=`expr $DIRS + 1`  # DIRS = DIRS + 1

    elif [ -f ${file} ] ; then

      FILES=`expr $FILES + 1`


    case ${file} in

      *.gif|*jpg) echo "${file}: graphic file" ;;

      *.txt|*.tex) echo "${file}: text file" ;;

      *.c|*.f|*.for) echo "${file}: source file" ;;

      *) echo "${file}: generic file" ;;



  echo "there are ${DIRS} directories and ${FILES} files"

  ls | grep "ZxY--!!!WKW"

  if [ $? != 0 ] ; then # exit code of last command

    echo "ZxY--!!!WKW not found"


  echo "enough... type 'man bash' if you want more info."







  8.2.  C for Yourself



  Under UNIX, the system language is C, love it or hate it. Scores of

  other languages (Java, FORTRAN, Pascal, Lisp, Basic, Perl, awk...) are

  also available.


  Taken for granted that you know C, here are a couple of guidelines for

  those of you who have been spoilt by Turbo C++ or one of its DOS kin.

  Linux's C compiler is called gcc and lacks all the bells and whistles

  that usually accompany its DOS counterparts: no IDE, on-line help,

  integrated debugger, etc. It's just a rough command-line compiler,

  very powerful and efficient. To compile your standard hello.c you'll





       $ gcc hello.c





  which will create an executable file called a.out. To give the

  executable a different name, do





  $ gcc -o hola hello.c





  To link a library against a program, add the switch -l<libname>. For

  example, to link in the math library:




       $ gcc -o mathprog mathprog.c -lm





  (The -l<libname> switch forces gcc to link the library

  /usr/lib/lib<libname>.a; so -lm links /usr/lib/libm.a).


  So far, so good. But when your prog is made of several source files,

  you'll need to use the utility make. Let's suppose you have written an

  expression parser: its source file is called parser.c and #includes

  two header files, parser.h and xy.h. Then you want to use the routines

  in parser.c in a program, say, calc.c, which in turn #includes

  parser.h. What a mess! What do you have to do to compile calc.c?


  You'll have to write a so-called makefile, which teaches the compiler

  the dependencies between sources and objects files. In our example:




  # This is makefile, used to compile calc.c

  # Press the <TAB> key where indicated!


  calc: calc.o parser.o

  <TAB>gcc -o calc calc.o parser.o -lm

  # calc depends on two object files: calc.o and parser.o


  calc.o: calc.c parser.h

  <TAB>gcc -c calc.c

  # calc.o depends on two source files


  parser.o:  parser.c parser.h xy.h

  <TAB>gcc -c parser.c

  # parser.o depends on three source files


  # end of makefile.





  Save this file as Makefile and type make to compile your program;

  alternatively, save it as calc.mak and type make -f calc.mak, and of

  course RMP. You can invoke some help about the C functions, that are

  covered by man pages, section 3; for example,




       $ man 3 printf





  To debug your programs, use gdb. info gdb to learn how to use it.


  There are lots of libraries available; among the first you'll want to

  use are ncurses, to handle textmode effects, and svgalib, to do

  graphics. If you feel brave enough to tackle X11 programming, there

  are libraries like the abovementioned XForms, Qt, Gtk and many others,

  which make writing X11 programs a breeze. Have a look at

  <> .


  Many editors can act as an IDE; emacs and jed, for instance, also

  feature syntax highlighting, automatic indent and so on.

  Alternatively, get the package rhide from

  <>.  It's a Borland

  IDE clone, and chances are that you'll like it.




  9.  The Remaining 1%



  More than 1%, actually...




  9.1.  Using tar & gzip



  Under UNIX there are some widely used applications to archive and

  compress files. tar is used to make archives---it's like PKZIP but it

  doesn't compress, it only archives. To make a new archive:




       $ tar -cvf <archive_name.tar> <file> [file...]





  To extract files from an archive:




       $ tar -xpvf <archive_name.tar> [file...]





  To list the contents of an archive:




       $ tar -tf <archive_name.tar> | less





  You can compress files using compress, which is obsolete and shouldn't

  be used any more, or gzip:




       $ compress <file>

       $ gzip <file>





  that creates a compressed file with extension .Z (compress) or .gz

  (gzip). These programs can compress only one file at a time. To

  decompress, use:

       $ compress -d <file.Z>

       $ gzip -d <file.gz>







  There are also the unarj, zip and unzip (PK??ZIP compatible)

  utilities. Files with extension .tar.gz or .tgz (archived with tar,

  then compressed with gzip) are as common in the UNIX world as .ZIP

  files are under DOS. Here's how to list the contents of a

   .tar.gz archive:




       $ tar -ztf <file.tar.gz> | less







  9.2.  Installing Applications



  First of all: installing packages is root's work. Most Linux

  applications are distributed as a .tar.gz archive, which typically

  will contain a directory called pkgname/ containing files and/or

  subdirectories.  A good rule is to install these packages from

  /usr/local with the command




       # tar -zxf <archive.tar.gz>





  reading then the README or INSTALL file. In many cases, the package is

  distributed in source, which you'll have to compile to create the

  binaries; often, typing make then make installwill suffice.

  Obviously, you'll need the gcc or g++ compiler.


  Other archives may have to be unpacked from /; this is the case with

  Slackware's .tgz archives. Other archives contain the files but not a

  subdirectory. Always list the contents of the archive before

  installing it.


  The Debian and Red Hat distributions have their own archive format;

  respectively, .deb and .rpm. The latter is gaining wide acceptance; to

  install an .rpm package, type




       # rpm -i package.rpm







  9.3.  Tips You Can't Do Without




  Command completion: pressing <TAB> when issuing a command will

  complete the command line for you. Example: you have to type gcc

  this_is_a_long_name.c; typing gcc thi<TAB> will suffice. (If you have

  other files that start with the same characters, supply enough

  characters to resolve any ambiguity.)


  Backscrolling: pressing <SHIFT + PAG UP> (the grey key) allows you to

  backscroll a few pages, depending on how much video memory you have.


  Resetting the screen: if you happen to more or cat a binary file, your

  screen may end up full of garbage. To fix it, blind type reset or this

  sequence of characters: echo CTRL-V ESC c RETURN.


  Pasting text: in console, see below; in X, click and drag to select

  the text in an xterm window, then click the middle button (or the two

  buttons together if you have a two-button mouse) to paste. There is

  also xclipboard (alas, only for text); don't get confused by its very

  slow response.


  Using the mouse: if you installed gpm, a mouse driver for the console,

  you can click and drag to select text, then right click to paste the

  selected text. It works across different VCs.


  Messages from the kernel: have a look at /var/adm/messages or

  /var/log/messages as root to see what the kernel has to tell you,

  including bootup messages. The command dmesg is also handy.




  9.4.  Where to Find Applications



  If you're wondering whether there are applications to replace your old

  DOS/Win ones, I suggest that you browse the main Linux software


    <> ,

   <> , and

   <> .  Another excellent place is the

  ``Linux Applications and Utilities Page'' at

    <> .




  9.5.  A Few Things You Couldn't Do



  Linux can do an awful lot of things that were cumbersome, difficult or

  impossible do to with DOS/Win. Here's a short list that may whet your




  _  at allows you to run programs at a specified time;


  _  awk is a simple yet powerful language to manipulate data files (and

     not only). For example, being data.dat your multi field data file,




       $ awk '$2 ~ "abc" {print $1, "\t", $4}' data.dat






  prints out fields 1 and 4 of every line in data.dat whose second field

  contains ``abc''.

  _  cron is useful to perform tasks periodically, at specified date and

     time. Type man 5 crontab.


  _  file <filename> tells you what filename is (ASCII text, executable,

     archive, etc.);


  _  find (see also Section ``Directories: Translating Commands'') is

     one of the most powerful and useful commands. It's used to find

     files that match several characteristics and perform actions on

     them. General use of find is:




       $ find <directory> <expression>






  where <expression> includes search criteria and actions. Examples:




       $ find . -type l -exec ls -l {} \;






  finds all the files that are symbolic links and shows what they point





       $ find / -name "*.old" -ok rm {} \;






  finds all the files matching the pattern and deletes them, asking for

  your permission first.




       $ find . -perm +111






  finds all the files whose permissions match 111 (executable).




       $ find . -user root






  finds all the files that belong to root. Lots of possibilities



  _  grep finds text patterns in files. For example,


       $ grep -l "geology" *.tex






  lists the files *.tex that contain the word ``geology''. The variant

  zgrep works on gzipped files. RMP;


  _  regular expressions are a complex but darn powerful way of

     performing search operations on text. For example, ^a[^a-

     m]X{4,}txt$ matches a line that starts with `a', followed by any

     character except those in the interval a-m, followed by 4 or more

     `X', and ends in `txt'. You use regular expressions with advanced

     editors, less, and many other applications. man grep for an



  _  script <script_file> dumps the screen contents on script_file until

     you issue the command exit. Useful for debugging;


  _  sudo allows users to perform some of root's tasks (e.g.  formatting

     and mounting disks; RMP);


  _  uname -a gives you info about your system;


  _  The following commands often come in handy: bc, cal, chsh, cmp,

     cut, fmt, head, hexdump, nl, passwd, printf, sort, split, strings,

     tac, tail, tee, touch, uniq, w, wall, wc, whereis, write, xargs,

     znew. RMP.




  9.6.  Common Extensions and Related Programs



  You may come across scores of file extensions. Excluding the more

  exotic ones (i.e. fonts, etc.), here's a list of who's what:



  _  1 ... 8: man pages. In the unlikely case you don't yet have it, get



  _  arj: archive made with arj.


  _  dvi: output file produced by TeX (see below). xdvi to visualise it;

     dvips to turn it into a PostScript .ps file.


  _  gz: archive made with gzip.


  _  info: info file (sort of alternative to man pages). Get info.


  _  lsm: Linux Software Map file. It's a plain ASCII file containing

     the description of a package.


  _  ps: PostScript file. To visualise or print it get gs and,

     optionally, ghostview or gv.


  _  rpm: Red Hat package. You can install it on any system using the

     package manager rpm.


  _  taz, tar.Z: archive made with tar and compressed with compress.


  _  tgz, tar.gz: archive made with tar and compressed with gzip.


  _  tex: text file to submit to TeX, a powerful typesetting system.

     Get the package tex, available in many distributions; but beware of

     NTeX, which has corrupted fonts and is included in some Slackware



  _  texi: texinfo file, can produce both TeX and info files (cp.

     info). Get texinfo.


  _  xbm, xpm, xwd: graphic file. Get xpaint.


  _  Z: archive made with compress.




  9.7.  Converting Files



  If you need to exchange text files between DOS/Win and Linux, beware

  of the ``end of line'' problem. Under DOS, each line of text ends with

  CR/LF, while under Linux with LF. If you try to edit a DOS text file

  under Linux, each line will likely end with a strange--looking `M'

  character; a Linux text file under DOS will appear as a kilometric

  single line with no paragraphs. There are a couple of tools, dos2unix

  and unix2dos, to convert the files.


  If your files contain accented characters, make sure they are made

  under Windows (with Write or Notepad, say) and not under plain DOS;

  otherwise, all accented characters will be screwed up.


  To convert Word or WordPerfect files to plain text, the matter is a

  bit trickier but possible. You'll need one of the tools that can be

  found on the CTAN sites; one is   <> .  Get the

  package word2x from the directory /pub/tex/tools/', or try one the

  packages available in directory /pub/tex/support/. I've only tried

  word2x, and works quite well.




  10.  The End, for Now



  Congratulations! You have now grasped a little bit of UNIX and are

  ready to start working. Remember that your knowledge of the system is

  still limited, and that you are expected to do more practice with

  Linux to use it comfortably. But if all you had to do was get a bunch

  of applications and start working with them, what I included here is



  I'm sure you'll enjoy using Linux and will keep learning more about

  it---everybody does. I bet, too, that you'll never go back to DOS/Win!

  I hope I made myself understood and did a good service to my 3 or 4





  10.1.  Copyright



  Unless otherwise stated, Linux HOWTO documents are copyrighted by

  their respective authors. Linux HOWTO documents may be reproduced and

  distributed in whole or in part, in any medium physical or electronic,

  as long as this copyright notice is retained on all copies. Commercial

  redistribution is allowed and encouraged; however, the author would

  like to be notified of any such distributions.


  All translations, derivative works, or aggregate works incorporating

  any Linux HOWTO documents must be covered under this copyright notice.

  That is, you may not produce a derivative work from a HOWTO and impose

  additional restrictions on its distribution. Exceptions to these rules

  may be granted under certain conditions; please contact the Linux

  HOWTO coordinator at the address given below.


  In short, we wish to promote dissemination of this information through

  as many channels as possible. However, we do wish to retain copyright

  on the HOWTO documents, and would like to be notified of any plans to

  redistribute the HOWTOs.


  If you have questions, please contact Tim Bynum, the Linux HOWTO

  coordinator, at via email.




  10.2.  Disclaimer



  ``From DOS to Linux HOWTO'' was written by Guido Gonzato,  Many thanks to Matt Welsh, the author of

  ``Linux Installation and Getting Started'', to Ian Jackson, the author

  of ``Linux frequently asked questions with answers'', to Giuseppe

  Zanetti, the author of ``Linux'', to all the folks who emailed me

  suggestions, and especially to Linus Torvalds and GNU who gave us



  This document is provided ``as is''. I put great effort into writing

  it as accurately as I could, but you use the information contained in

  it at your own risk. In no event shall I be liable for any damages

  resulting from the use of this work.


  Feedback is welcome. For any requests, suggestions, flames, etc., feel

  free to contact me.


  Enjoy Linux and life,


  Guido   =8-)