COPYSERVER(1)                                       COPYSERVER(1)

          copyserver - file copying between a source and a destination

          copyserver [ -d ] mntdir

          copyserver starts a styxservers(2) server and mounts it at
          mntdir (replacing the old binding, if any).  Once done, the
          server is ready to accept copy requests. Unmounting mntdir
          will cleanly shutdown the server.

          Copy requests are written into the (virtual) control file of
          the server, named ctl , using the following format:

                   [srcmntopt] srcfname srcoff
                   [dstmntopt] dstfname dstoff
                   nofbytes iounit delay ctlfile

          If the source and destination files are successfully opened,
          the copy commences. The write operation on the server con-
          trol file blocks until the copy terminates, or it is killed
          (discussed in the sequel), or an r/w error occurs.  Also, a
          copy is aborted if the process that writes the request to
          the server control file is killed (this is detected by the
          server via the receipt of a flush(5) message for the write

          Here is a brief explanation of the copy request arguments:

          srcfname and dstfname specify the source and destination
          file name, relative to the root of the source and destina-
          tion file system, respectively. srcfname must point to an
          existing file.  If dstfname points to an existing file, this
          will be truncated and overwritten, else a new file will be

          srcoff and dstoff specify the offset from which to start
          reading the source and writing the destination file, respec-
          tively. These values must be equal or greater than zero.
          The file position is adjusted based on the rules for sys-seek(2) (using Sys->SEEKSTART ).

          nofbytes specifies the number of bytes to copy from the
          source to the destination file. The copy operation will ter-
          minate in case the end of the source file is reached ear-
          lier. If nofbytes is zero, the copy will not terminate
          unless the end of the source file is reached. If the source
          points to the reading end of an endless stream, the copy

     COPYSERVER(1)                                       COPYSERVER(1)

          will run "for ever", until it is aborted or killed.

          iounit specifies the size of the data buffer used to read
          bytes from the source file and write them to the destination

          delay specifies the number of milliseconds to wait between
          two successive r/w operations. Combined with a small iounit
          value (e.g. 1 byte), this makes it possible to test the copy
          server in an interactive fashion and using small files. If
          delay is zero, the copy will be performed at full speed.

          For both the source and destination, an option, srcmntopt
          and dstmntopt , respectively, can be used to specify whether
          the corresponding file systems need to be mounted, and how
          this should be achieved.  The mount option has the following

               (-s[A] | -o[A]) addr

          Option -s is specifies a conventional mount via styx(2) ,
          and option -o specifies a mount via ofs(4) to a remote
          oxport(4) server. In both cases, the -A option is used to
          turn authentication off.  addr specifies the address to be
          dialed.  If no mount option is used, the server interprets
          the filename relative to its local name space (no mount is

          For each ongoing copy, the server "creates" a (virtual) con-
          trol file, using the ctlfname that was supplied in the
          request. The server "removes" the control file when the copy
          terminates (or is aborted or is killed).

          Reading the copy control file returns the number of bytes
          copied so far as a string value. Writing the string value
          "kill" in the file kills the copy (the server will notify
          the blocked process that issued the copy request via an
          error(5) message).

          To mount a copy server on /cpsrv with debugging output

               ./copyserver -d /cpsrv

          To (background) copy file /d1/f1 exported by an oxport file
          server which does not require authentication and listens on
          tcp!!4242 , to file /d2/f2 in the file system of
          the copy server, using a r/w buffer of 512 bytes, with an
          artificial delay of 50 ms between each r/w operation, and
          cp1 being the name of the copy control file:

     COPYSERVER(1)                                       COPYSERVER(1)

               echo copy -oA tcp!!4242 /d1/f1 0
                                                /d2/f2 0
                         0 512 50 cp1 > /cpsrv/ctl &

          Or to (background) copy file /d1/f1 exported by a styx file
          server which does not require authentication and listens on
          tcp!!4243 , to file /d2/f2 in the file system
          exported by the same oxport server as above, using the same
          request settings:

               echo copy -sA tcp!!4243 /d1/f1 0
                         -oA tcp!!4242 /d2/f2 0
                         0 512 50 cp1 > /cpsrv/ctl &

          To check the progress of the copy:

               cat /cpsrv/cp1

          To abort the copy, one may kill the process that issued the
          request (and remains blocked waiting for the write operation
          to return). Alternatively, one may use the corresponding
          control file to kill the copy (this will also unblock the
          background process):

               echo kill > /cpsrv/cp1

          Finally, to unmount the copy server:

               unmount /cpsrv

          Note that the copy server will shutdown when all processes
          have unmounted it from their name space.


          styx(2) , mount(2) , ofs(4) , and oxport(4)

          There is no access control for the copy control files "cre-
          ated" by the server. Any process can read and write every
          copy control file (e.g. kill any ongoing copy, if it so
          desires).  Also, the ownership and access rights of the des-
          tination files created as a side effect of a copy are not
          properly set.

          There is a subtle race condition when reading the copy con-
          trol file, which may result in occasionally delivering a

     COPYSERVER(1)                                       COPYSERVER(1)

          wrong value for the number of bytes that have been copied so
          far. The probability for this is (very) small.

          For simplicity, dialing and mounting (and unmounting) file
          systems is currently done via shell commands (instead of a
          direct invocation of the corresponding primitives). This
          means that changes in the command syntax will "brake" the
          copyserver code. Also, the failure of a shell command is
          inferred indirectly, by checking whether any output was
          written on standard error.

          Killing/aborting a copy is asynchronous, i.e. it may be per-
          formed with a (small) delay, after having sent the corre-
          sponding reply message to the entity that triggered this