p’ing and f’ing a C job or started task

I have a C program which can run as a long running batch program. I wanted to be able to stop it when I had finished using it. C runtime has the __console and __console2 which allow an operator to interact with the job, by using the operator commands stop(p) and modify(f).

Using the __console* interface I can use the operator commands

p colinjob
f colinjob,appl=’these parameters’

When the modify command is used, the string returned to the application is null terminated. I think you can enter 127 characters in the appl=’…’ parameter.

The string is converted to upper case.

__console or __console2?

__console was available first. __console2 extends the capability of __console, by having the capability to set more attributes on the message, such as where the message gets routed to.

An application can issue an operator command, and specify a Command And Response Token (CART). The target application can tag responses with the same CART value, and so the requesting application gets the responses to its original request.

Write to operator

You can use __console() __console2() just to write to the operator.

• If the user does not have access to BPX.CONSOLE in the FACILITY class, and is not a super user, you get “BPXM023I (userid) A Message”
• If the userid is has read access to BPX.CONSOLE in the FACILITY class or running as a super user (id(0) ), you get “A Message” without the BPXM023I

You can use __console* to write to the operator and return with no special programming.

Waiting for a stop or modify request

When using __console* to wait for a modify or stop request, the __console* request is suspended, until it receives a modify or stop request. This means that you need to set up a thread to do this work, and to notify the main program when an event occurs.

include statements

You need

 #pragma runopts(POSIX(ON)) 
  /*Include standard libraries */ 
  #include <stdio.h> 
  #include <stdlib.h> 
  #include <string.h> 
  #include <stdarg.h> 
  #include <errno.h> 
  #include <sys/__messag.h> 
  #define _OPEN_SYS 1 
  #include <pthread.h> 
  #define _OPEN_SYS 
  #include <signal.h>
// the following is used to communicate between thread and main task
struct consoleMsg{ 
  char code; 
  char message[128]; 

}; 

The main program

int main( int argc, char *argv[]) 
{ 
...
struct consoleMsg consoleMsg; 
memset(&consoleMsg,0,sizeof(consoleMsg)); 
consoleStart(&consoleMsg);

for...
{
...
 if (consoleMsg.code ==_CC_stop ) break;  
 else 
 if (consoleMsg.code == _CC_modify ) 
 { 
  printf("modify message:%s.\n",consoleMsg.message); 
  consoleMsg.code = 0; 
 } 
...
} // for
consoleStop(&consoleMsg);
} 

consoleStart(…)

This function takes the input parameter and passes it to the thread.

pthread_t thid; 
void consoleStart( struct consoleMsg  * pCons) 
{ 
 // this creates the thread and says execute "thread" function below
  if (pthread_create(&thid, NULL, thread, (void * ) pCons) != 0) 
  { 
    perror("pthread_create() error"); 
    exit(1); 
  } 
  return; 
} 

consoleStop(…)

If the operator used the stop command, the thread (below) ends. If the main program wants to end it, it issues a kill. You should not issue the kill if the thread has ended.

void consoleStop( struct consoleMsg  * pCons) 
{
  // if the P command was issued, the thread ended,so we do not need to kill it 
  if (pCons -> status = 0) return; // it has already ended 
  int status; 
  status = pthread_kill(thid, SIGABND); 
  if (status  != 0) 
  { 
    perror("pthread_kill() error"); 
  } 

The thread subtask

This does all of the work. It is passed the pointer which was passed in the consoleStart function. In this example, it points to a buffer for the returned data, and the reason the exit was woken up.

When the thread is started, it displays a message, giving

BPXM023I (COLIN) Use f jobname,appl=data or p Jobname

void *thread(void * pArg ) { 
   // map the passed argument to ours
    struct consoleMsg * pCM = ( struct consoleMsg * ) pArg; 
    char * pMessage = "Use f jobname,appl=data or p Jobname"; 
    char reply[128]; /* it gets the data */ 
    int  concmd; // what command was issued 
    char consid[4] = "CONS"; 
    unsigned int msgid = 0 ; 
    unsigned int routeCode[] = {0}; 
    unsigned int descr[] = {0}; 
    char cart[8] = "MYCART  "; 
    struct __cons_msg2 cons; 
    cons.__cm2_format       = __CONSOLE_FORMAT_3; 
    cons.__cm2_msglength    = strlen(pMessage); 
    cons.__cm2_msg          = pMessage; 
    cons.__cm2_routcde      = routeCode; 
    cons.__cm2_descr        = descr; 
    cons.__cm2_token        = 0; 
    cons.__cm2_msgid        = &msgid; 
    cons.__cm2_dom_token    = 0;
    cons.__cm2_dom_msgid    = 0; 
    cons.__cm2_mod_cartptr  = &cart[0]; 
    cons.__cm2_mod_considptr= &consid[0]; 
    memcpy(&cons.__cm2_msg_cart,&cart     ,8); 
    memcpy(&cons.__cm2_msg_consid, &consid,4); 
    int rc; 
    int loop; 

for( loop = 0; loop < 1000;loop ++) 
  { 
  // issue the message and wait
      rc=  __console2(&cons, &reply[0], &concmd); 
      if (rc != 0) 
         perror("__console2"); 
      printf("__console2 gave rc  %d function %d\n",rc,concmd); 
      pCM -> code = concmd; 
      if (concmd == _CC_modify ) 
        { 
          printf("Modify issued %s\n",reply); 
          memcpy(&pCM-> message,&reply,sizeof(reply)); 
        } 
      else 
      if (concmd == _CC_stop) 
        { 
          printf("Stop issued\n"); 
          break; 
        } 
   } 
  void * ret = "thread returned\n" ; 
  pthread_exit(ret); 
}