Category : File Managers
Archive   : COPYIT20.ZIP
Filename : COPYIT.DOC
.
COPYIT
------
Version 2.0
February 15, 1989
File Copy Utility
Written by:
Frank J. Condron
Contech Systems
P.O. Box 396
Sterling Heights, MI 48311
CompuServe 73477,2536
INTRODUCTION
------------
COPYIT is a file copy utility designed to give you much more
control over your copy operations than the DOS COPY or XCOPY
commands. Features include:
* COPYIT will prompt you to insert another diskette when the
current diskette is full, allowing you to easily copy
large subdirectories of files,
* A built-in optimization system, to fill diskettes as
completely as possible,
* Break and Restore commands, to split huge files over
multiple diskettes,
* Enhanced memory usage; all available system memory is
utilized for buffering, resulting in faster operation and
fewer diskette swaps,
* Subdirectory copy - COPYIT 2.0 can duplicate a directory
structure on the target disk, or copy all of the files
from a directory structure to the same target directory if
desired
* A True Verify parameter that assures files have been
copied correctly through the use of a 32 bit CRC system,
* COPYIT can prompt you before copying each file, giving you
greater control over what files are copied,
* COPYIT can check to make sure no files will be overlaid,
* An intelligent move parameter, to move files instead of
simply copying them,
* COPYIT can copy files based on date or size criteria, or
that are hidden or system files
* Copy files based on the archive bit, and reset that bit if
desired,
ÚÄÄÄÄÄÄÄ¿
ÚÄÄÄÄÁÄÄ¿ ³ (tm)
Äij ³o ³ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
³ ÚÄÄÄÄÁÐÄ¿ ³ Association of
³ ³ ³ÄÙ Shareware
ÀÄij o ³ Professionals
ÄÄÄÄij º ³ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
ÀÄÄÄÐÄÄÄÙ MEMBER
Copyright (c) 1988, 1989 Contech Systems, all rights
reserved.
- 2 -
REGISTRATION
------------
COPYIT is distributed and marketed under the Shareware
concept. Shareware is a system that allows you to evaluate
software to see if it fills your needs BEFORE you purchase it.
You may freely distribute copies of COPYIT, as long as it is in
the original, unmodified form. It may not, however, be bundled
with other software packages without prior written permission
from Contech Systems.
Under the shareware system, you may freely use COPYIT for an
evaluation period not to exceed thirty days. If you find it
useful and continue to use it after the evaluation period, you
are required to pay a registration fee of $15. Upon registering,
you will be sent an enhanced version of COPYIT with additional
features. Your registration also entitles you to product
support, future upgrades, and discounts on other Contech System
products. To register, simply print and complete the registration
form included with COPYIT (in the file REGISTER.FRM), enclose
check or money orders payable to Contech Systems, and send to:
Contech Systems
P.O. Box 396
Sterling Heights, MI 48311
ATTN: COPYIT Registration
If you have any problems in executing COPYIT, please contact
us at the above address, or through CompuServe EasyPlex mail (ID
73477,2536). Although we cannot offer full product support
unless registered, we also cannot expect someone to register if
they cannot get the program to work at all!
DISCLAIMER
----------
Under no circumstances shall Contech Systems or its
suppliers be liable for any damages whatsoever, including but not
limited to loss of business profits or information, business
interruption, or any other loss arising out of the use or
inability to use this software product.
COPYIT Operation
----------------
COPYIT is very easy to use. If you are familiar with the
standard DOS COPY command, you can already use COPYIT in its
place for standard copy operations. To take advantage of the
special features of COPYIT, it is necessary to become familiar
with various parameters which will be described later.
COPYIT commands are entered from the DOS prompt, in the
following format:
- 3 -
COPYIT [copyfrompath\mask] [Copytopath\mask] [/p1../pn]
Copyfrompath\mask is the drive, path, and mask for the files you
want to copy. Copytopath\mask is the drive, path, and mask you
want the files copied to, and [/p1../pn] are the command
parameters, each beginning with a '/', and separated by a space.
Masks are entered in the identical format that DOS uses,
including wildcards. Specifying a copyto mask will result in
files being renamed as they are copied. For example, if
COPYIT a:*.* c:?Z*.new
were entered, the result would be that all files in the current
directory on disk A would be copied to the current directory on
drive C, and the files would be renamed. The new names would be
the same as they originally were, except that the second letter
in each name would become 'Z' and the extensions would become
.NEW . For example, a file named APPLES.BAK would be copied to a
file named AZPLES.NEW. Refer to your DOS manual for more
information on masks and wildcards.
If no copyfrom mask is specified, COPYIT will target all
files in the specified subdirectory. If no copyto mask is
entered, COPYIT assumes you wish to copy the files to the current
drive/directory.
Parameters (discussed below) are entered after the above
path\mask indicators. Parameters must be preceded by a slash
(/), and each must be separated by a space.
Copying Many Files
------------------
Many times it is necessary to copy a number of files from a
large subdirectory on a hard disk to diskettes. Using the
standard DOS copy commands, this is virtually impossible - as
soon as the first diskette is out of space, the copy command
aborts. Typing the individual file names is inconvenient and
time consuming; altering the archive bit is undesirable if you
make backups. COPYIT solves this problem. Whenever the current
diskette is out of space, COPYIT will prompt you to insert a new
one. COPYIT will then continue where it left off. This function
is always active; you do not need to specify any parameters to
use it. If you do not have another diskette available, or do not
want to spread the copy between multiple diskettes, you may press
ESC at the prompt for another diskette - this will halt the copy
operation.
- 4 -
Built-In Optimization
---------------------
During diskette copy operations that will be spread over
many diskettes, it is not always very efficient to copy the files
in the exact order they appear. For example, if the directory
listed (in this order) three files of sizes 75000, 10000, and
18000 bytes, DOS COPY would copy them in that order. You may
have already copied many files to a diskette, and only have 45000
bytes free. If you tried to copy the above files to the
diskette, DOS COPY would eventually realize the first file is too
big for the remaining space and would abort. COPYIT, however,
would copy the files to the diskette in whatever order necessary
to fit as many files on the diskette as possible; it will then
prompt you for another diskette. Thus, the 10000 byte file would
be copied, then the 18000 byte file. Since no more of the
remaining files (the 75000 byte one) will fit on the diskette,
you would then be prompted to insert another.
Enhanced Memory Usage
---------------------
COPYIT now makes use of more system memory for buffering to
speed copy operations and reduce the number of diskette swaps
that need to be performed. The shareware version utilizes up to
128K of memory for buffering; the registered version will make
use of all available system memory for buffering. The actual
amount used can be controlled through the use of parameters, if
necessary (see the /f parameter, below).
Aborting a File Copy
--------------------
Pressing the escape key (ESC) at any time during a copy
operation will halt it. Under most circumstances this takes
place immediately, but may take a few seconds depending on what
internal operations that COPYIT is performing.
- 5 -
Break and Restore Commands
--------------------------
Have you ever needed to give a friend or co-worker a copy of
a file, only to find it is too large to fit on a single diskette?
Using COPYIT, you can break the file over multiple diskettes, and
later use the Restore command to return the file to its original
condition.
Breaking Files
To break large files over many diskettes, simply use COPYIT
as you would for any copy operation, but add the '/b' parameter.
This tells COPYIT that it should plan on copying any files too
large for a single diskette onto more that one. The '/b'
parameter is not even really necessary - if the copy path/mask
entered includes a file that is too large for a single diskette,
COPYIT will warn you and prompt you for whether it should be
broken over many diskettes or not. Things to remember when
breaking files:
- For obvious reasons, COPYIT cannot break files when the
target is a hard drive
- COPYIT always processes files being broken last
- The diskettes that the file is being broken onto need not
be empty, but COPYIT will not split a file onto a diskette
that has less then 4K (4096 bytes) of free disk space
Each diskette that COPYIT uses will contain what is referred to
as a "portion file." Each portion file is named as follows:
As shown above, the portion files are named the same as the
original filename, but have a COPYIT-generated extension (the
part after the period). This extension consists of an underscore
(_), and a number ranging from 01 to 99, referring to which
portion file it is. The first eighty bytes of each portion file
contains information that COPYIT uses to restore the file.
Restoring Files
When restoring files that have been previously broken,
COPYIT operates in a much more rigid fashion than when copying
files or splitting them. When restoring a file, the basic format
for COPYIT execution is the same, except for two differences.
First, no copyfrom mask is allowed - the path and primary name
(the part before the period) must be explicitly entered. The
second difference is that the '/r' parameter is added. When
this parameter is specified, COPYIT enters Restore Mode. When in
Restore Mode, all other parameters are ignored.
- 6 -
Things to remember when restoring files:
- COPYIT will only restore one file per execution
- The file will be restored to it's original filename (the
name it had BEFORE it was broken), unless a copyto mask
has been specified
- Files can only be restored to a hard drive. The portion
files used in the restore can be on diskettes or on a hard
disk.
See the examples at the end of this documentation for reference.
Log Files
---------
COPYIT 2.0 has added support for log files. Log files
contain detailed information about COPYIT operations that you can
use later to review what has taken place. Information such as
date and time executed, parameters, files copied and their
destinations, error messages, reasons why files were bypassed,
and more is included in the logfile. For more information, see
'/L - Log Files' below.
Environment Variables
---------------------
NOTE: Environment variables are supported only in the registered
version of COPYIT.
COPYIT 2.0 now has support for environment variables. The
"environment" is a reserved area in memory for information that
is accessible by any program. It is a useful place to store
small pieces of information that often-run programs use.
The environment area consists of variables of the form:
These variables are created/altered through the use of the SET
command. If you type SET with no parameters, all of the
environment variables are listed out. If you try this now, you
should see at least one environment variable; COMSPEC. COMSPEC
is a variable used by DOS to keep track of where to find the
program COMMAND.COM.
To add or change environment variables, enter:
SET
- 7 -
COPYIT utilizes environment variables to hold parameter
information that you often, or always, wish to have COPYIT use.
For example, if you almost always enter the parameters '/z:5000-
/p /m' you may get tired typing this many times. Instead, you
could create an environment variable to hold this information by
doing the following:
SET MYPARM=/z:5000- /p /m
You can either type this in at the DOS prompt, or enter it as a
line in your AUTOEXEC.BAT file so it will always exist in the
environment. Then, when you wish to use these parms with COPYIT,
simply add the following parameter when you execute COPYIT:
/e:myparm
The '/e:' is described below in the parameter description
section. More than one environment variable can be used at a
time, subject to the following rules:
- When duplicate parameters are entered, COPYIT processes
the first it finds, and ignores the duplicates.
- COPYIT processes entries on the command line (i.e. not in
environment variables) before it processes the environment
variables.
The environment variables are then processed in the order
they have been entered when COPYIT was executed.
COPYIT uses two special, optional environment variables,
'COPYIT' and 'COPYLOG.' Their uses are as follows:
COPYIT: If this environment variable exists, COPYIT will
automatically use it whenever it is executed. You do not need to
enter '/e:copyit' to utilize it. This variable is always
processed after the command line and all other environment
variables.
COPYLOG: This variable tells COPYIT what file to use for a
log file (see the section on logfiles above). It is processed
differently than described in the rules above; if it exists,
COPYIT will immediately use it to open a logfile. This has
advantages over using the '/l' parameter described earlier -
since the logfile is opened before any other parameters are
processed, you can be sure that any parameter error descriptions
will be included in the logfile. Also, if you always wish to use
a logfile, this variable saves you from repetitiously typing in
the '/l' parameter, or entering it into the 'COPYIT' environment
variable. The format for the data portion of the COPYLOG
variable is the same as for the '/l' parameter described above,
although you may optionally leave off the '/l:' before the
filename.
- 8 -
For more information on the environment and the SET command,
please refer to your DOS manual.
Parameters
----------
Parameters are the heart of COPYIT. If you don't use them,
the main thing you gain over the DOS COPY command is the prompt
for inserting another target diskette if there is not enough
space to copy everything specified, and the built-in diskette
optimization.
/a - copy based on file archive bit.
/b - break large files over multiple diskettes
/c - check for overlay before copying.
/d - copy based on file date.
/e - utilize environment variables (registered version only)
/f - limit number of 4K buffers allocated
/h - copy Hidden files.
/l - keep detailed log file of copy operation.
/m - move files.
/p - prompt as to whether a file should be copied.
/q - quiet operation; suppress all beeps
/r - restore files split over multiple diskettes
/s - copy child subdirectories also
/sys - copy System files.
/t - place current date and time on copied files.
/v - perform DOS Verify while copying.
/vt - perform 32 bit CRC True Verification while copying.
/z - copy based on file size.
/# - show copy operation information before executing
/^ - scroll prompt and overlay files
/@ - reset archive bit on files copied.
You can see this summary at any time by entering COPYIT with no
other parameters from the DOS prompt.
Parameters may be entered in any order, as long as they
follow the copyfrom and copyto (if any) path/masks. If you make
any errors in entering parameters, COPYIT will respond with
messages describing what is wrong. If COPYIT detects any errors
with input parameters, NO copying will take place.
- 9 -
Parameter Definitions:
----------------------
/A - Copy Based on Archive Bit :
Format: /a[+-]
Use: Whenever a file is created or modified, DOS
turns on an indicator called the archive bit.
Backup programs normally reset this bit so that it
is easy to determine what files have changed since
the last backup. COPYIT normally ignores the
archive bit, copying the file regardless of its
setting. With the /a parameter, however, you can
perform copies based on the archive bit.
Specifying a plus (+) sign after the parameter
tells COPYIT to only copy files that have the
archive bit set (or turned on, indicating the file
has been created or modified). Specifying a minus
(-) does the opposite; COPYIT will only copy files
that have an archive bit that is off.
SEE ALSO: Reset Archive Bit Parameter below (/@)
/B - Break Files :
Format: /b
Use: This parameter instructs COPYIT to break
large files that cannot fit onto single diskettes
over many. See the section "Break and Restore"
above.
SEE ALSO: Restore Parameter below (/r)
/C - Check for Overlay :
Format: /c or /c-
Use: Normally, COPYIT operates much like the DOS
COPY command when copying a file to a disk or
subdirectory where an identical filename exists;
it overwrites the old file. If you are not sure
what exists in the drive or subdirectory that you
are copying to, or if you just want to know what
is being overlaid, specify the /c parameter.
COPYIT will then check if a duplicate filename
exists before copying the file. If it does, you
will be prompted as to whether or not the file
should be overlaid.
The /c- command operates in a similar
fashion, except that COPYIT will not prompt you as
to whether or not the file in question should be
overlaid - COPYIT assumes you do NOT want to
overlay the file.
- 10 -
/D - Copy based on File Date :
Format: /d:[date][+-]
Use: This parameter causes COPYIT to select files
for copying based upon the date the file was
created or last modified. After the '/d:' the
date you wish to test against should be entered.
Immediately after the date, either a plus (+),
indicating all files with dates equal to or later
than the test date, or a minus (-), indicating all
files with dates equal to or before the test date,
must be entered.
The date may be entered with or without
leading zeros. Slashes, or any other non-numeric,
non-space character my be substituted for dashes
in the date. For example, to copy all files with
dates of August 9, 1988, or later, all of the
following are valid:
/d:08-09-88+
/d:8/9/88+
/d:08/9-88+
Similarly, to copy all files created/modified on
or after November 1, 1988, enter:
/d:11.1.88-
or /d:11-01-88-
or /d:11/1/88-
/E - Environment Variables :
Format: /e:
Use: The /e parameter tells copyit to process the
data contained within the environment variable
command line when COPYIT was executed.
Environment variables are only supported in the
registered version of COPYIT. See the section
'Environment Variables,' below.
/F - Limit Buffers :
Format: /f:nn
Use: This parameter tells COPYIT to limit the
number of 4K buffers allocated to nn (any positive
integer). If this parameter is not used, COPYIT
allocates as many buffers as possible. If for
some reason you find you need to limit how much
RAM COPYIT uses, this parameter is available.
Note that in the shareware version of COPYIT,
maximum memory utilized is 128k - in the
- 11 -
registered version, all available system memory is
utilized.
/H - Hidden Files :
Format: /h
Use: Through DOS, a file can be marked as hidden.
Such a file is not shown when a directory command
is given. COPYIT normally ignores such files, but
will include them in the copy operation if this
parameter is specified.
SEE ALSO: Copy System File Parameter (/sys)
/L - Log Files :
Format: /l:
Use: When this parameter is specified, COPYIT
opens and uses a log file, as described in the Log
File section above.
path/filename combination. If a plus sign (+)
follows the filename, COPYIT will append the new
information to the end of the file if it exists;
if it does not exist, then the file is created.
If no plus sign follows the filename, COPYIT will
create a new file, deleting any old logfile
information.
SEE ALSO: Environment Variables Section, above.
/M - Move Files :
Format: /m
Use: This parameter causes the files to be moved.
If moving from one disk to another, the file is
first copied, then the original is deleted. If
the file is being moved between subdirectories on
the same disk, it is simply renamed. If True
Verification (/vt, see description) is active and
a file fails verification, the original file will
NOT be deleted.
/P - Prompt :
Format: /p
Use: When this parameter is specified, COPYIT will
prompt you as to whether or not the file should be
copied. You will not be prompted for any files
that fail other selection criteria.
- 12 -
/Q - Quiet Operation :
Format: /q
Use: Normally, COPYIT issues beeps to indicate
that some action is needed (diskette swaps and
other prompts). If you do not wish to hear these
beeps, this parameter will silence them.
/R - Restore Files :
Format: /r
Use: Specifying this tells COPYIT to enter
Restore Mode to restore a file broken with the
'/b' parameter. All other parameters are ignored
while in Restore Mode. See the section "Break and
Restore" above.
SEE ALSO: Break File Parameter above (/b)
/S - Subdirectory Copy :
Format: /s OR /s-
Use: Specifying /s tells COPYIT that you wish to
copy the files in all of the subdirectories below
the specified copyfrom subdirectory. If a minus
sign (-) is directly after the /s COPYIT will copy
all of the files to the target disk and directory
that you specified when COPYIT was executed. If
there is no minus sign, then COPYIT will "mirror"
the subdirectories. This means that all of the
subdirectories below the specified copyfrom sub-
directory will be created on target disk, below
the target directory. For example, if you have
the following directory structure on drive C:
\ÄÄ¿
ÃÄÄBATLIB
³
ÀÄÄOLDFILESÄÄÂÄÄBACKUPS
³
ÀÄÄJUNK
and the following directory structure on drive A:
\ÄÄ¿
ÃÄÄMYSTUFF
³
ÀÄÄSAVEIT
and you executed COPYIT as follows:
COPYIT c:\oldfiles\*.* a:\saveit /s
- 13 -
the final result would be that drive A: would have
a directory structure of:
\ÄÄ¿
ÃÄÄMYSTUFF
³
ÀÄÄSAVEITÄÄÂÄÄBACKUPS
³
ÀÄÄJUNK
Directory A:\SAVEIT would contain all of the files
that C:\OLDFILES has, and the directories
A:\SAVEIT\BACKUPS, and A:\SAVEIT\JUNK would
contain the same files as C:\OLDFILES\BACKUPS and
C:\OLDFILES\JUNK, respectively.
It is important to note that if the ENTIRE
subdirectory structure cannot be "mirrored" in
this fashion onto a single disk, COPYIT will print
an error message and halt.
The second use, with the minus sign, copies files
from all of the subdirectories to a single
target. If the following were entered:
COPYIT c:\oldfiles\*.* a: /s-
all of the files in directories C:\OLDFILES,
C:\OLDFILES\BACKUPS, and C:\OLDFILES\JUNK would be
copied to drive A: If there is not enough space
to copy all of the files to a single diskette, you
will be prompted for another. In this case, it is
important to note that COPYIT does not watch out
for identical filenames being overwritten - if the
file XYZ.COM existed in C:\OLDFILES and in
C:\OLDFILES\JUNK, COPYIT will copy both files. If
both happen to be copied to the same diskette, the
second version will overwrite the first. Use of
the /c (check for overlay) parameter will not help
- /c only checks that files existing BEFORE the
copy operation started are not overlaid.
- 14 -
/SYS - System Files :
Format: /sys
Use: System files, much like hidden files, are
normally ignored by COPYIT. Specifying this
parameter will cause COPYIT to process them.
SEE ALSO: Copy Hidden Files Parameter above (/h)
WARNING: Previous versions of COPYIT used "/s" to
execute this parameter. Please make note of the
change. Entering /s performs a completely
different function. See "/S - Subdirectory Copy"
below.
/T - Time Stamp Copied Files :
Format: /t
Use: When COPYIT copies files it normally does
not change the time/date stamp on the copies. If
the /t parameter is used, the current system data
and time will placed in the directory entry for
the file. The original files' time and date are
never changed.
/V - Verify During Copy :
Format: /v
Use: Specifying this parameter causes COPYIT to
use the standard DOS VERIFY to check each write to
the disk. This is a time consuming process -
expect COPYIT to take twice as long when /v is
used. If files are simply being renamed (this
occurs when /m is specified, and files are being
moved to different subdirectories on the same
disk), a message is printed and the /v parameter
is ignored.
SEE ALSO: TrueVerify Parameter below (/vt)
/VT - True Verify During Copy :
Format: /vt
Use: This parameter instructs COPYIT to utilize a
32 bit Cyclical Redundancy Check (CRC) to assure
that the files were copied correctly. The
original file is compared to the copy much more
thoroughly than normal. This, like the /v
parameter, is time consuming. If files are simply
being renamed, a message is printed and the /vt
parameter is ignored.
SEE ALSO: Verify Parameter above (/v)
- 15 -
/Z - Copy based on File Size :
Format: /z:[nnnn][+-]
Use: This parameter allows you to specify copying
based upon file size. The format is as shown,
with [nnnn] equal to the file size to be tested
against (this can be any integer). The file size
is then followed by either a plus (+) telling
COPYIT to copy all files equal to or greater than
the file size specified, or a minus (-), telling
COPYIT to copy all files equal to or less than the
filesize specified.
For example:
/z:22000+
would cause all files equal to or greater than
22000 bytes to be copied, while
/z:1000000-
specifies that only files equal to or less than
1,000,000 bytes are to be copied.
/# - Display Size Information :
Format: /#
Use: When COPYIT executes, it normally displays
information on total number of files to be copied
and total bytes involved, then begins the copy
operation. When this parameter is specified,
COPYIT will pause after the information is
displayed and prompt you as to whether you wish to
continue the copy operation.
/^ - Scroll Prompt and Overlay Selections :
Format: /^
Use: When you specify the Prompt (/p) or the
Check for Overlay (/c) parameters, COPYIT displays
the filename and prompts you for information (see
the /p and /c descriptions). After you enter
information, COPYIT displays the next filename
over the previous one. This keeps information
that was on the screen before you executed COPYIT
from scrolling off of the screen when you are
prompted for a large number of files. There are
times, however, when you want the prompt and over-
lay file names to scroll, so that you may review
them. If you wish these filenames to scroll on
- 16 -
your screen, instead of being overlaid by
subsequent file prompts, enter this parameter.
/@ - Reset Archive Bit :
Format: /@
Use: As described under the /a (copy based on
archive bit) parameter, the archive bit indicates
whether a file has been created/modified since the
last backup. If you want COPYIT to reset the
archive bit on each file it copies, the /@
parameter is used.
SEE ALSO: Copy Based on Archive Bit above (/a)
WARNING: Most backup utilities perform
incremental backups based upon the settings of the
archive bit. If the archive bit has been reset
through the use of COPYIT (or any other utility),
your incremental backups may not contain all of
the files that have been modified/created since
your last backup.
- 17 -
EXAMPLES:
copyit a:*.*
OR
copyit a:
Copies all files in the current directory of
drive A: to the current directory in which
the command was issued.
copyit *.* \data /c /p
Copies all files in the current subdirectory
to subdirectory \DATA, prompting for each
file copy, and warning if any files in \DATA
will be overlaid.
copyit ABC.TXT HELLO.TXT /m
Since no copyfrom or copyto paths are
specified, and move (/m) is indicated, the
file ABC.TXT is simply renamed to HELLO.TXT.
copyit \data\*.bak d:\olddata\*.old /c /m /d:11-1-88 /v
Moves all files with extensions of .BAK from
directory \DATA to drive D:, subdirectory
\OLDDATA. The files' extensions are renamed
to .OLD, and a warning is issued if any
similarly named files exist in \OLDDATA.
Only files created or last modified on or
after November 1, 1988 are moved. Lastly,
each file copy is verified.
copyit c:\db\*.* a: /b
Copy all files in C:\DB to drive a: - if any are
too big to fit on a single diskette, break them
onto many diskettes.
copyit a:maildb.dat c:\data /r
Since '/r' is specified, COPYIT enters Restore
Mode. The copyfrom extension (.dat) is ignored,
and COPYIT checks drive A: for the first portion
file needed, MAILDB._01 If this file is not
found, you are prompted to insert the diskette
containing it. Once it is found, restoration
begins. You will be prompted whenever a new
diskette is needed.
- 18 -
copyit a:maildb.dat c:\data\mail.big /r
This example does exactly the same thing as the
above does, except the file is restored as a file
named MAIL.BIG
- 19 -
Very nice! Thank you for this wonderful archive. I wonder why I found it only now. Long live the BBS file archives!
This is so awesome! 😀 I’d be cool if you could download an entire archive of this at once, though.
But one thing that puzzles me is the “mtswslnkmcjklsdlsbdmMICROSOFT” string. There is an article about it here. It is definitely worth a read: http://www.os2museum.com/wp/mtswslnk/