#include <stdio.h>                                                              
#include <stdlib.h>                                                             
#include <string.h>                                                             
#include <QUSCRTUS.h>                                                           
#include <QUSLJOB.h>                                                            
#include <QUSRTVUS.h>                                                           
#include <micomput.h> /* triml */                                               
#include <QMHRTVM.h>                                                            
#include <QMHSNDPM.h>                                                           
                                                                                
#define TRUE         0                                                          
#define FALSE       -1                                                          
typedef struct {                                                                
   int  BYTESPRO;                                                               
   int  BYTESAVL;                                                               
   char MSGID[7];                                                               
   char RESRVD;                                                                 
   char EXCPDATA[100];                                                          
} ERRSTRUCTURE;       /* Define the error return structure      */              
ERRSTRUCTURE  errcode;/* API Error Code Structure               */              
typedef struct {                                                                
   char NM[10];                                                                 
   char LIB[10];                                                                
} QNAME;     /* Define the qualified name                            */         
QNAME         inname;                 /*  Qualified user space name */          
typedef struct {                                                                
   char JOB[10];                                                                
   char USER[10];                                                               
   char JOBNBR[6];                                                              
} JOBINFO;                                                                      
JOBINFO jobinfo;                                                                
int  offset, size, entries;                                                     
typedef _Packed struct header_struct {                                          
     char user_data[64];                                                        
     int  generic_header_size;                                                  
     char header_version[4];                                                    
     char format_name[8];                                                       
     char program_name[10];                                                     
     char time_generated[13];                                                   
     char information_status;                                                   
     int  usrspc_used;                                                          
     int  parm_section_offset;                                                  
     int  parm_section_size;                                                    
     int  header_section_offset;                                                
     int  header_section_size;                                                  
     int  list_section_offset;                                                  
     int  list_section_size;                                                    
     int  number_of_entries;                                                    
     int  size_of_entry;                                                        
} header_struct;                                                                
header_struct inspace;                                                          
char ref[132];                                                                  
                                                                                
/*************************************************************/                 
/*       内　部　使　用　　関　　数                          */                 
/*************************************************************/                 
void  CreateUsrSpace(char* space, char* lib);                                   
void  ApiError(char* place);                                                    
void  SendMessage(char* Message, char* Status, char* Pgmque);                   
                                                                                
void main(void){                                                                
   int i;                                                                       
   char Job[11], User[11], Nbr[7];                                              
   Qus_JOBL0100_t jobl0100;                                                     
                                                                                
   printf("** TESTUSLJOB : QUSLJOB のテスト **\n");                             
   getchar();                                                                   
                                                                                
   /*(1) QUSCRTUS: ユーザー・スペースの作成 */                                  
   CreateUsrSpace("USLJOB    ", "QTEMP     ");                                  
                                                                                
   /*(2) QUSLJOB: ユーザー QTMHHTTP のジョブ一覧を出力する */                   
   memcpy(jobinfo.JOB, "*ALL      ", 10);                                       
   memcpy(jobinfo.USER, "QTMHHTTP  ", 10);                                      
   memcpy(jobinfo.JOBNBR, "*ALL  ", 6);                                         
                                                                                
   QUSLJOB((char*)&inname, "JOBL0100", (char*)&jobinfo, "*ACTIVE   ",           
       &errcode);                                                               
   if(errcode.BYTESAVL != 0){/*APIERR*/                                         
         ApiError("MAIN-QUSLJOB"); exit(0);                                     
   }/*APIERR*/                                                                  
                                                                                
   /*(3) QUSRTVUS: ユーザー・スペースを読んで初期情報を取得する */              
   QUSRTVUS("USLJOB    QTEMP     ", 0x01,sizeof(inspace), &inspace,             
        (char*)&errcode);                                                       
   if(errcode.BYTESAVL != 0){/*APIERR*/                                         
       sprintf(ref, "QUSRTVUS-%d", __LINE__);                                   
       ApiError(ref);                                                           
       return;                                                                  
   }/*APIERR*/                                                                  
  offset  = inspace.list_section_offset +1;                                     
  size    = inspace.size_of_entry;                                              
  entries = inspace.number_of_entries;                                          
                                                                                
  /*(4) QUSRTVUS: ユーザー・スペースを LOOP して読み取る */                     
  for(i = 0; i<inspace.number_of_entries; i++){/*for-loop*/                     
    QUSRTVUS((char*)&inname, offset, size, (char*)&jobl0100,                    
       (char*)&errcode);                                                        
    /*--------------( 処理の開始 )-----------------*/                           
    memcpy(Job, jobl0100.Job_Name_Used, 10);                                    
    Job[10] = 0x00;                                                             
    memcpy(User, jobl0100.User_Name_Used, 10);                                  
    User[10] = 0x00;                                                            
    memcpy(Nbr, jobl0100.Job_Number_Used, 6);                                   
    Nbr[6] = 0x00;                                                              
    printf("[%d] Job = %10s, User = %10s, Nbr = %06s\n",                        
         i, Job, User, Nbr);                                                    
    /*--------------( 処理の終了 )-----------------*/                           
    offset += inspace.size_of_entry;                                            
  }/*for-loop*/                                                                 
  getchar();                                                                    
                                                                                
                                                                                
}                                                                               
/*******************************************/                                   
void  CreateUsrSpace(char* space, char* lib)                                    
/*******************************************/                                   
{                                                                               
char          extattrib[10];           /*  External attributes       */         
long int      initialsize;                                                      
char          initialvalue;                                                     
char          authority[10];                                                    
char          description[50];                                                  
char          replace[10];                                                      
                                                                                
     memset(&inname, 0, sizeof(QNAME));                                         
     memcpy(inname.NM, space, 10);                                              
     memcpy(inname.LIB, lib, 10);                                               
     initialsize = 1000;                                                        
     initialvalue = '0';                                                        
     memcpy(authority, "*ALL      ", sizeof(authority));                        
     memset(description, ' ', sizeof(description));                             
     memcpy(replace, "*YES      ", sizeof(replace));                            
     memcpy(extattrib, "PF        ", sizeof(extattrib));                        
     QUSCRTUS((char *)(&inname), extattrib, initialsize,                        
              &initialvalue, authority, description, replace,                   
             (char *)(&errcode));/* create user space at QTEMP )*/              
}                                                                               
/**************************/                                                    
void  ApiError(char* place)                                                     
/**************************/                                                    
{                                                                               
   char msgid[8], msgdta[100], Message[512], msg[512];                          
   int  msglen, msgdtalen, pos;                                                 
   char* ptr;                                                                   
   typedef struct {                                                             
     Qmh_Rtvm_RTVM0100_t  rtvm0100;                                             
     char msg[512];                                                             
   } ERRMSG;                                                                    
   ERRMSG errmsg;                                                               
                                                                                
   memset(msgid, 0, sizeof(msgid));                                             
   memcpy(msgid, errcode.MSGID, 7);                                             
   memset(msgdta, 0, sizeof(msgdta));                                           
   memcpy(msgdta, errcode.EXCPDATA, 100);                                       
   msglen = sizeof(Qmh_Rtvm_RTVM0100_t);                                        
   msgdtalen = strlen(msgdta);                                                  
   memset(&errmsg, 0, sizeof(ERRMSG));                                          
   QMHRTVM(&errmsg,  msglen, "RTVM0100", msgid, "QCPFMSG   *LIBL     ",         
          msgdta, msgdtalen, "*YES      ", "*YES      ", &errcode);             
   memset(Message, 0, sizeof(Message));                                         
   memcpy(Message, errmsg.msg, 512);                                            
   ptr = strstr(Message, "&N");                                                 
   if(ptr != NULL){                                                             
     pos = (int)(ptr - Message);                                                
     Message[pos] = 0x00;                                                       
   }                                                                            
   sprintf(msg, "%s-%s:%s", place, msgid, Message);                             
   SendMessage(msg, "*COMP     ", "*PGMBDY   ");                                
}                                                                               
/**********************************************************/                    
void SendMessage(char* Message, char* Status, char* Pgmque)                     
/**********************************************************/                    
{                                                                               
  char msg_id[7];                                                               
  char msg_fl_name[20];                                                         
  char msg_data[3000];                                                          
  int msg_data_len;                                                             
  char msg_type[10];                                                            
   int  pgm_stk_cnt;                                                            
  char msg_key[4];                                                              
   char pgm_que[10];                                                            
                                                                                
    memset(msg_id, 0, sizeof(msg_id));                                          
    strcpy(msg_id, "CPF9897");                                                  
    memset(msg_fl_name, 0, sizeof(msg_fl_name));                                
    strcpy(msg_fl_name, "QCPFMSG   QSYS      ");                                
    memset(msg_data, 0, sizeof(msg_data));                                      
    strcpy(msg_data, Message);                                                  
    msg_data_len = triml(Message, ' ');                                         
    strcpy(msg_type, Status);                                                   
    strcpy(pgm_que, Pgmque);                                                    
    if(strncmp(Pgmque, "*EXT      ", 10) == 0)                                  
      pgm_stk_cnt = 0;                                                          
    else pgm_stk_cnt = 1;                                                       
    memset(msg_key, 0x40, sizeof(msg_key));                                     
    errcode.BYTESPRO = 160;                                                     
    errcode.BYTESAVL = 0;                                                       
    QMHSNDPM(msg_id, msg_fl_name, msg_data, msg_data_len, msg_type,             
         pgm_que, pgm_stk_cnt, msg_key, &errcode);                              
}