#include <errno.h>
#include <sys/fcntl.h>
#include <tmf/sys/tmfctl.h>

void
main( int argc, char **argv ) {

    tmfpblk_t  req;
    int fd;
    int c;

    /*
     *   Open the TMF path.  "tmfpath" is the path name specified on
     *   the tmmnt command.
     */

    fd = open( "tmfpath", O_RDWR );
    if ( fd < 0 ) {
         printf( "Unable to open file tmfpath (errno = %d)\n",
                                                     errno );
         exit(errno);
    }

    /*
     *   Create and send the TMF rewind request.
     */

     req.request = TR_RWD;
     req.async   = 0;
     req.length  = 0;
     req.reply   = 0;
     c = ioctl( fd, TMFC_DMNREQ, &req );
     if ( c < 0 ) {
         printf( "Unable to issue the TMF rewind request (errno=%d)\n",
         errno );
         exit(errno);
     }

    /*
     *   Check the status of the rewind request.
     */

     if (req.reply ) {
         printf( "Error %d on the TMF rewind request\n", req.reply);
         exit(EIO);
     }
     exit(0);
}

#include <errno.h>
#include <stdlib.h>
#include <sys/fcntl.h>
#include <tmf/sys/tmfctl.h>

void
main( int argc, char **argv ) {

    tmfpblk_t  req;
    int  fd;
    int  c;

    /*
     *   Open the TMF path.  "tmfpath" is the path name specified on
     *   the tmmnt command.
     */

    fd = open( "tmfpath", O_RDWR );
    if ( fd < 0 ) {
       printf( "Unable to open file tmfpath (errno = %d)\n", errno );
                exit(errno);
    }

    /*
     *   Create and send a request to position forward 5 blocks.
     */

    req.rh.request  = TR_PBLKS;
    req.rh.length   = sizeof(tmfpblk_t) - sizeof(tmfreqhdr_t);
    req.rh.async    = 0;
    req.rh.reply    = 0;
    req.rh.residual = 0;
    req.count       = 5;
    c = ioctl( fd, TMFC_DMNREQ, &req );
    if ( c < 0 ) {
       printf("Unable to issue the block position request (errno=%d)\n",
                                            errno );
       exit(errno);
    }

    /*
     *   Check the status of the block positioning request.
     */

    if ( req.rh.reply ) {
       printf("Error %d on the block position request\n", req.rh.reply );
       printf("%d blocks of the requested %d blocks were positioned\n",
                abs(req.count) - req.rh.residual, abs(req.count) );
       exit(EIO);
    }
    exit(0);
}

#include <errno.h>
#include <stdlib.h>
#include <sys/fcntl.h>
#include <tmf/sys/tmfctl.h>

void
main( int argc, char **argv ) {

   tmfpfm_t  req;
   int  fd;
   intc;

    /*
     *  Open the TMF path.  "tmfpath" is the path name specified on
     *   the tmmnt command.
     */

   fd = open( "tmfpath", O_RDWR );
   if ( fd < 0 ) {
        printf( "Unable to open file tmfpath (errno = %d)\n", errno );
        exit(errno);
   }

   /*
    *   Create and send a request to position backward 7 filemarks.
    */

   req.rh.request  = TR_PFMS;
   req.rh.length   = sizeof(tmfpfm_t) - sizeof(tmfreqhdr_t);
   req.rh.async    = 0;
   req.rh.reply    = 0;
   req.rh.residual = 0;
   req.count       = -7;
   c = ioctl( fd, TMFC_DMNREQ, &req );
   if ( c < 0 ) {
        printf("Unable to issue the file position request (errno=%d)\n",
                                                       errno );
        exit(errno);
   }

   /*
    *   Check the status of the file positioning request.
    */

   if ( req.rh.reply ) {
        printf("Error %d on the file position request\n", req.rh.reply );
        printf("%d files of the requested %d files were positioned\n",
                 abs(req.count) - req.rh.residual, abs(req.count) );
        exit(EIO);
   }
   exit(0);
}

#include <errno.h>
#include <sys/fctnl.h>
#include <tmf/sys/tmfctl.h>

void
main( int argc, char **argv )
{
   tmfpabs_t  req;
   intfd;
   intc;

   /*
    *   Open the TMF path.  "tmfpath" is the path name specified on
    *   the tmmnt command.
    */

   fd = open( "tmfpath", O_RDWR );
   if ( fd < 0 ) {
        printf( "Unable to open file tmfpath (errno = %d)\n", errno );
         exit(errno);
   }

   /*
    *   Create and send a request to position to the specified block.
    *   The block location is obtained with the MTIOCGET or MTIOCGETEXT
    *   ioctl.
    */

   req.rh.request = TR_PABS;
   req.rh.length  = sizeof(tmfpabs_t) - sizeof(tmfreqhdr_t);
   req.rh.async   = 0;
   req.rh.reply   = 0;
   req.blkaddr    = block-address;
   c = ioctl( fd, TMFC_DMNREQ, &req );
   if ( c < 0 ) {
        printf("Unable to issue the absolute positioning request (errno=%d)\n",
                                                       errno );
        exit(errno);
   }

   /*
    *   Check the status of the absolute positioning request.
    */

   if ( req.rh.reply ) {
        printf("Error %d on the absolute positioning request\n",
                                                      req.rh.reply );
        exit(EIO);
   }
   exit(0);
}

#include <errno.h>
#include <sys/fcntl.h>
#include <tmf/sys/tmfctl.h>

void
main( int argc, char **argv )
{
    tmfpvol_t  req;
    int     fd;
    int     c;

    /*
     *   Open the TMF path.  "tmfpath" is the path name specified on
     *   the tmmnt command.
     */

    fd = open( "tmfpath", O_RDWR );
    if ( fd < 0 ) {
         printf( "Unable to open file tmfpath (errno = %d)\n", errno );
         exit(errno);
    }

    /*
     *   Create and send a request to position to the beginning of the
     *   volume with an index of 2 in the volume list.
     */

    req.rh.request  = TR_PVOL;
    req.rh.length   = sizeof(tmfpvol_t) - sizeof(tmfreqhdr_t);
    req.rh.async    = 0;
    req.rh.reply    = 0;
    req.index       = 2;
    c = ioctl( fd, TMFC_DMNREQ, &req );
    if ( c < 0 ) {
         printf("Unable to issue the volume positioning request (errno=%d)\n",
                                                        errno );
         exit(errno);
    }

    /*
     *   Check the status of the volume positioning request.
     */

    if ( req.rh.reply ) {
         printf("Error %d on the volume positioning request\n",
                                                       req.rh.reply );
         exit(EIO);
    }
}

#include <errno.h>
#include <sys/fcntl.h>
#include <tmf/sys/tmfctl.h>

void
main( int argc, char **argv )
{
   tmfpvsn_t  req;
   intfd;
   intc;

   /*
    *   Open the TMF path.  "tmfpath" is the path name specified on
    *   the tmmnt command.
    */

   fd = open( "tmfpath", O_RDWR );
   if ( fd < 0 ) {
        printf( "Unable to open file tmfpath (errno = %d)\n", errno );
        exit(errno);
   }

   /*
    *   Create and send a request to position to the beginning of the
    *   volume with the external volume identifier of "004141".
    */

   req.rh.request  = TR_PVSN;
   req.rh.length   = sizeof(tmfpvsn_t) - sizeof(tmfreqhdr_t);
   req.rh.async    = 0;
   req.rh.reply    = 0;
   strcpy( req.evsn, "004141" );
   c = ioctl( fd, TMFC_DMNREQ, &req );
   if ( c < 0 ) {
        printf("Unable to issue the volume positioning request (errno=%d)\n",
                                                       errno );
        exit(errno);
   }

   /*
    *   Check the status of the volume positioning request.
    */

   if ( req.rh.reply ) {
        printf("Error %d on the volume positioning request\n",
                                                       req.rh.reply );
        exit(EIO);
   }
   exit(0);
}

#include <errno.h>
#include <stdlib.h>
#include <sys/fcntl.h>
#include <tmf/sys/tmfctl.h>

void
closev( int );
void
eov( int, int );
int  wrttape( int, char *, int *, int * );

*define BUFSIZE  98304

void
main( int argc, char **argv ) {

   charbuf[BUFSIZE];
   int  count=0
   int  datalen;
   int  fd, c, i;

   /*
    *   Open the TMF path. "tmfpath" is the path name specified on
    *   the tmmnt command.
    */

   fd = open( "tmfpath", O_RDWR );
   if ( fd < 0 ) {
        printf( "Unable to open file tmfpath (errno = %d)\n", errno);
        exit(errno);
   }

   /*
    *   Create and send a request to select user end-of-volume processing.
    */

   eov(fd,1);

   /*
    *   Write until EOT.
    */

   while ( !wrttape( fd, buf, &count, &datalen ) );

   /*
    *   Complete the last block.
    */

   if ( datalen ) {
        c = write( fd, buf+datalen, BUFSIZE-datalen );
        if ( c != BUFSIZE-datalen )
                 exit(EIO);
   }

   /*
    *   Close the volume.
    */

   closev(fd);

   /*
    *   Deselect user end-of-volume processing.
    */

   eov(fd,0);

   /*
    *   Output additional data on the next volume.
    */

   for ( i=0; i , 5; i++ ) {
        wrttape( fd, buf, &count, &datalen );
   }
   exit(0);
}

/*
 *   closev
 *
 *   Terminate the current volume and mount the next.
 *
 */

void
closev( int fd ) {

   tmfreqhdr_t  req;
   int  c;

   req.request = TR_CLV;
   req.length  = 0;
   req.async   = 0;
   req.reply   = 0;
   c = ioctl( fd, TMFC_DMNREQ, &req );
   if (c < 0 ) {
        printf( "Unable to issue the close volume request (errno=%d)\n",
                                                      errno );
        exit(errno);
   }

   /*
    *   Check the status of the close volume request.
    */

   if ( req.reply ) {
        printf( "Error %d on the close volume request\n", req.reply );
        exit(EIO);
   }
}

/*
 *  eov
 *
 *  Select or deselect user end-of-volume processing.
 *
 */

void
eov( int fd, int value ) {
    tmfeov_t req;
    int c;

    req.rh.request = TR_EOV;
    req.rh.length  = sizeof(tmfeov_t) - sizeof(tmfreqhdr_t);
    req.rh.async   = 0;
    req.rh.reply   = 0;
    req.select     = value;
    c = ioctl( fd, TMFC_DMNREQ, &req );
    if ( c < 0 ) {
         printf( "Unable to issue the eov request (errno=%d)\n", errno );
         exit(errno);
    }

    /*
     *   Check the status of the eov request.
     */

    if ( req.rh.reply ) {
         printf('Error %d on the eov request\n", req.rh.reply );
         exit(EIO);
    }
}

/*  wrttape
 *
 *  Returns;
 *    0        No error
 *    1        EOT
 *
 */

int
wrttape( int fd, char *buf, int *count, int *datalen ) {

    char *bp = buf;
    int  *bpw = (int *)buf;
    int  nbytes, len;

    len    = BUFSIZE;
    bpw[0] = *count;
    while ( len ) {
         nbytes = write( fd, bp, len );
         if ( nbytes < 0 ) {

/* Error on write */

              if ( errno == ENOSPC )
                   return(1);

                       /* At End-of-Tape */

              printf( "Unrecoverable write error (errno = %d)\n", errno );
              exit(1);
         }
         *datalen = len - nbytes;
         bp  += nbytes;
         len -= nbytes;
     }
     (*count)++;
     return(0);
}