Yes, you use RCFV
You would use %SST to identify with records are the records you need to process.
For instance pos 2 = blank and pos 70 = period.
YOU NEED to be careful what you are cancelling. The WRKACTJOB is giving you job information from all subsystems. I’m guesing you only want selected jobs, like TYPE = INT
ot something. Or selected USRPRF.

One trick that works well is to :
run your command whatever it is to an outfile,
run a query to an outfile selecting the records and fields you are concerned with.
Then read that file (RCVF) in a CLP inside a loop,
process (end job, delete user profile- just kidding, whatever), until EOF (CPF0864).

To add to CharlieBrowne’s post, WRKACTJOB SBS(QINTER, QPGMR, QBATCH).

Do it like eating an apple, one bite at a time.
Nick

Assuming that you want to end all *ACTIVE jobs that have job names beginning with JOBLOG*, this is a little easier than the previous one:

pgm

/* Identify a PARTIAL job-name to work over...                      */
   dcl   &SCHNAME     *char   10     value( 'JOBLOG*' )

   dcl   &SchJob      *char   26

/* Identify a *USRSPC name...                                       */
   dcl   &usrspc      *char   10     value( 'LSTACTJOBS' )
   dcl   &usrspclib   *char   10     value( 'QTEMP' )

   dcl   &qusrspc     *char   20

/* General fields from *usrspc header...                            */
   dcl   &offslst     *int
   dcl   &nbrlste     *int
   dcl   &sizlste     *int

/* Various work fields...                                           */

   dcl   &jobname     *char   10
   dcl   &jobusr      *char   10
   dcl   &jobnbr      *char    6

   dcl   &qjob        *char   26

/* Various receiver variables...                                    */
   dcl   &us_hdr      *char  150
   dcl   &JOBL0100F   *char   56


/*---------------------------------------------------------------------------*/
/* Global MONMSG...                                                          */
/*---------------------------------------------------------------------------*/

   monmsg    ( cpf0000 mch0000 ) exec( goto Std_Err )


/*                                                                           */
/* Create *usrspc for the SBS info APIs...                                   */
/*                                                                           */

   chgvar          &qusrspc               ( &usrspc *cat &usrspclib )

   call  QUSCRTUS         ( +
                            &qusrspc                +
                            'ACTJOB    '            +
                            x'00004000'             +
                            X'00'                   +
                            '*ALL      '            +
                  'List active jobs                                  ' +
                            '*YES      '            +
                            x'0000000000000000'     +
                          )


/* Set the qualified search-job name -- list 'em all...                      */

   chgvar          &SchJob                ( &SCHNAME *cat '*ALL      *ALL  ' )


/*                                                                           */
/* List the active jobs into our *usrspc...                                  */
/*                                                                           */

   call  QUSLJOB          ( +
                            &qusrspc                +
                            'JOBL0100'              +
                            &SchJob                 +
                            '*ACTIVE   '            +
                            x'0000000000000000'     +
                            '*'                     +
                            x'00000000'             +
                            x'00000000'             +
                          )


/* Retrieve the *usrspc header...                                            */

   call  QUSRTVUS         ( +
                            &qusrspc                +
                            x'00000001'             +
                            x'00000096'             +
                            &us_hdr                 +
                          )

/*                                                           */
/* Get the offset to the list within the space, the number   */
/*   of list entries and size of each entry from the header. */
/*                                                           */
   chgvar          &offslst           %bin( &us_hdr    125 4 )
   chgvar          &nbrlste           %bin( &us_hdr    133 4 )
   chgvar          &sizlste           %bin( &us_hdr    137 4 )


/* If no entries, then get out of here...                    */

   if  ( &nbrlste *eq 0 )     do
      sndpgmmsg  msgid( CPF9897 ) msgf( QCPFMSG ) +
                   msgdta( 'No active jobs found.' ) +
                   topgmq( *EXT ) +
                   msgtype( *COMP )
      goto   End_Run
   enddo


/* Set the offset to the list within the space...            */

   chgvar          &offslst               ( &offslst + 1 )



    dowhile  ( &nbrlste *gt 0 )

/*    Retrieve one listed job entry from the list...                         */

      call  QUSRTVUS      ( +
                            &qusrspc                +
                            &offslst                +
                            &sizlste                +
                            &JOBL0100F              +
                          )


/* Get the qualified job name from the list entry...                         */

      chgvar       &qjob              %sst( &JOBL0100F  1 26 )


      chgvar       &jobname           %sst( &qjob  1 10 )
      chgvar       &jobusr            %sst( &qjob 11 10 )
      chgvar       &jobnbr            %sst( &qjob 21  6 )

      endjob      job( &jobnbr/&jobusr/&jobname )


/* Bump our offset up by the size of a list entry...                         */

      chgvar       &offslst               ( &offslst + &sizlste )

/* Decrement our loop counter and loop back if more...                       */

      chgvar       &nbrlste               ( &nbrlste - 1 )

   enddo


End_Run:

   dltusrspc   &usrspclib/&usrspc  /* Cleanup */

   return


 Std_Err:

   /* Move any *DIAG messages up the stack...        */

   Qsys/call       QSYS/QMHMOVPM       ( +
                                         '    '          +
                                         '*DIAG     '    +
                                         x'00000001'     +
                                         '*         '    +
                                         x'00000001'     +
                                         x'00000000'     +
                                       )
   Qsys/monmsg     ( CPF0000 MCH0000 )

   /* Resend any *ESCAPE messages up the stack...     */

   Qsys/call       QSYS/QMHRSNEM       ( +
                                         '    '          +
                                         x'00000000'     +
                                       )
   Qsys/monmsg     ( CPF0000 MCH0000 )

   return


endpgm

Compare the code to note the differences. Also compare to note how they essentially the same program, with just some differences in details. Once you have one API-based solution, it’s easy to clone it for a new solution.

In the new version, the SearchName has become the generic name — “JOBLOG*”. When the generic name is concatenated with *ALL users and *ALL job numbers, it becomes “all fully qualified jobs that begin with ‘JOBLOG’”.

If that’s all we need for selection criteria, then all we have to do is list them into a temporary space and end every job that was listed. We don’t even need to check any of the job attributes. We already know it’s an *ACTIVE job, it has a name that begins with JOBLOG* and we don’t care what subsystem it’s running in nor what any other attribute is.

But, as for your actual question, you’ll put your spooled file into a physical file and code something like this:

dountil  ( &eofJobs )
   rcvf
   monmsg  ( cpf0864 )  exec( do )
      chgvar   &eofJobs  '1'
      iterate
   enddo

   if ( [valid_line] *and [valid_job] )  do
      endjob ...
   enddo

enddo

I don’t know how you will create the condition to test for a “valid_line”. You’ll probably do something like CharlieBrowne suggested and simply check different positions in the line to see if your program recognizes the line as a header line or a detail line or just blank. And I suppose for the “valid_job” condition you’ll just check the job name columns to see if they have a name that you want to handle. If the conditions are met, then substring the name, user and nbr from the line and end that job.

In order to compile the program, you will need to have the database file already created. The compiler will need the file description in order to supply the RCVF command with the correct attributes.

You probably only want the database file to exist in QTEMP when your program runs, but you can add an OVRDBF command to redirect to your QTEMP file at run-time.

Tom