The API Corner: Validating Inquiry Message Responses

  • Smaller Small Medium Big Bigger
  • Default Helvetica Segoe Georgia Times

Learn how to write a reply-handling exit program.


This is the second in a series of articles related to detecting when an inquiry message has been sent on your system and then making processing decisions based on the inquiry message. The underlying technology being used is known as the reply-handling exit program and has been available since V5R2.
The first article, "Beyond Watches," introduced the reply-handling exit point QIBM_QMH_REPLY_INQ documented here, provided a program prototype for an exit program and an explanation of the parameters passed to the exit program from the operating system, and reviewed our requirements for the exit program. The complete source for the RNQMGR exit program is provided below:
dRNQMgr           pr                  extpgm('RNQMGR')         
d CallType                      10i 0 const                    
d QualMsgQ                      20    const                    
d MsgKey                         4    const                    
d MsgID                          7    const                    
d Reply                        132    options(*varsize)        
d LenReply                      10i 0                          
d ReplyCCSID                    10i 0                          
d ReplyAcnCode                  10i 0                          
dRNQMgr           pi                                           
d CallType                      10i 0 const                    
d QualMsgQ                      20    const                    
d MsgKey                         4    const                    
d MsgID                          7    const                    
d Reply                        132    options(*varsize)        
d LenReply                      10i 0                            
d ReplyCCSID                    10i 0                            
d ReplyAcnCode                  10i 0                            
dRcvMsg           pr                  extpgm('QMHRCVPM')         
d Receiver                       1    options(*varsize)          
d LenReceiver                   10i 0 const                      
d Format                         8    const                       
d CSE                           10    const                      
d CSECtr                        10i 0 const                      
d MsgType                       10    const                      
d MsgKey                         4    const                      
d WaitTime                      10i 0 const                      
d MsgAction                     10    const                      
d ErrCde                              likeds(QUSEC)              
d LenCSE                        10i 0 options(*nopass) const     
d QualCSE                       20    options(*nopass) const     
d CSEType                       10    options(*nopass) const      
d CCSID                         10i 0 options(*nopass) const      
d AlwDftRpyRjct                 10    options(*nopass) const      
dSndMsg           pr                  extpgm('QMHSNDM')           
d MsgID                          7    const                       
d QualMsgF                      20    const                       
d MsgDta                       100    options(*varsize) const     
d LenMsgDta                     10i 0 const                       
d MsgType                       10    const                        
d MsgQNames                     20    const                       
d NbrMsgQNames                  10i 0 const                       
d RpyMsgQ                       20    const                       
d MsgKey                         4                                 
d ErrCde                              likeds(QUSEC)               
d CCSID                         10i 0 options(*nopass)            
dPSDS            sds           429    qualified                   
d MsgID                  40     46                                
d JobName               244    253                                
d JobUsr                254    263                                
d JobNbr                264    269                                
 /copy qsysinc/qrpglesrc,qmhrcvpm                                 
 /copy qsysinc/qrpglesrc,qusec                                     
dMsgInfo          ds                  based(MsgPtr) qualified     
d MsgHdr                              likeds(QMHM010001)          
dRNQ_Msg          ds                  based(MsgRplDtaPtr)         
d Procedure               1     10                                
d PgmName                11     20                                
d Library                21     30                                
d Statement              31     40                                
dMsgQName         ds                                       
d NtfyQ                         10    inz('PGMR')          
d NtfyQLib                      10    inz('QGPL')          
dMsgTxt           s            256                         
dMsgPtr           s               *                        
dMsgRplDtaPtr     s               *                        
dInqMsgKey        s              4                         
 if ((MsgID = 'RNQ0100') or                                
      (MsgID = 'RNQ0102') or                               
      (MsgID = 'RNQ0103') or                               
      (MsgID = 'RNQ0121'));                                        
     if PSDS.JobUsr = 'JOE_PGMR';                                  
        // Do not notify support or modify response when inquiry   
        // message is from developer working on new code           
        MsgTxt = (MsgID + ' in job ' +                             
                  %trimr(PSDS.JobName) + '/' +                     
                  %trimr(PSDS.JobUsr) + '/' +                      
        QUSBPRV = 0;                                               
        // Determine size of information available with inquiry    
        // message, allocate that storage, and then receive all    
        // information related to the message                       
        RcvMsg(QMHM010001 :%size(QMHM010001) :'RCVM0100' :'*EXT'     
               :0 :'*ANY' :MsgKey :0 :'*SAME' :QUSEC);               
        MsgPtr = %alloc(QMHBAVL02);                                  
        if MsgPtr <> *NULL;                                          
           RcvMsg(MsgInfo :QMHBAVL02 :'RCVM0100' :'*EXT' :0           
                  :'*ANY' :MsgKey :0 :'*SAME' :QUSEC);               
           if MsgInfo.MsgHdr.QMHDRTN00 >= 30;                        
              MsgRplDtaPtr = MsgPtr + %size(QMHM010001);             
              MsgTxt = %trimr(MsgTxt) + ' running program ' + PgmName;
                 when ((CallType = 1) or (CallType = 2) or           
                       (CallType = 3));                              
                         when PgmName = 'ABC001';                      
                              if Reply <> 'D';                        
                                 Reply = 'D';                         
                                 LenReply = 1;                        
                                 MsgTxt = %trimr(MsgTxt) +            
                                          ', option D forced.';       
                                 ReplyAcnCode = 2;                    
                              if Reply <> 'C';                        
                                 MsgTxt = %trimr(MsgTxt) + ', reply ' +
                                          %subst(Reply :1 :LenReply) +
                                          ' changed to C.';           
                                 Reply = 'C';                         
                                 LenReply = 1;                         
                                 ReplyAcnCode = 2;                    
                              if CallType = 1;                        
                                 MsgTxt = %trimr(MsgTxt) +            
                                          ' Initial reply was not +   
                                           provided by system.';      
                      MsgTxt = %trimr(MsgTxt) + 'CallType ' +         
                               %char(CallType) + ' with reply ' +     
                               %subst(Reply :1 :LenReply);            
              dealloc MsgPtr;                                         
              MsgTxt = %trimr(MsgTxt) + ' running program *N';        
           MsgTxt = %trimr(MsgTxt) + 'Storage problem in RNQMGR';   
        SndMsg(' ' :' ' :MsgTxt :%len(%trimr(MsgTxt)) :'*INFO'      
               :MsgQName :1 :' ' :InqMsgKey :QUSEC);                
     MsgTxt = 'RNQMGR failure with message ' + PSDS.MsgId +         
              ' in handling initial error ' + MsgID;                
     SndMsg(' ' :' ' :MsgTxt :%len(%trimr(MsgTxt)) :'*INFO'         
            :MsgQName :1 :' ' :InqMsgKey :QUSEC);                   
 *inlr = *on;                         
Assuming that the QSYSINC library (option 13 of the operating system) is installed on your system, you can create the program RNQMGR into library VINING using the CRTBNDRPG command:
The RNQMGR exit program manages the handling of four RPG run-time RNQ inquiry messages:
  • RNQ0100—The length or start position is out of range for the string operation.
  • RNQ0102—There's been an attempt to divide by 0.
  • RNQ0103—The target for a numeric operation is too small to hold the result.
  • RNQ0121—An array index is out of range.
To have the RNQMGR program in library VINING called whenever an inquiry message is sent on the system, you use the Add Exit Program (ADDEXITPGM) command:
To stop the system from calling the RNQMGR program, you can use the Work with Registration Information (WRKREGINF) command:
Option 8 (Work with exit programs) from the displayed panel will then show you all exit programs that are called for inquiry messages. From here, you can then use option 4 (Remove) for the entry showing the exit program RNQMGR in library VINING.
When the system calls RNQMGR, a MONITOR group is first established. While it is unlikely that any inquiry message will be sent during the running of the RNQMGR program, it's better to be safe rather than sorry. We would not want an inquiry message issued from RNQMGR to cause RNQMGR to be called in order to handle its own run-time error. This would, as currently created, cause RNQMGR to be called recursively and possibly hide the underlying error(s) related to the initial inquiry message. The monitor group encompasses all statements within the program, up to setting on LR and returning. If any unexpected error is encountered while running, RNQMGR will send a message to the message queue PGMR in library QGPL indicating an internal failure. This message queue is presumably monitored by support personnel within the organization. The actual sending of the message is done in the ON-ERROR block located near the end of the source program.
Having established the monitor group, RNQMGR then determines if any of the four RNQ messages listed above are the cause of the exit program being called. If some other inquiry message has been sent, the program ends immediately. When the RNQMGR program ends, the i operating system will then determine if any additional exit programs are registered to the reply-handling exit point. If there are, the system will call the next exit program; if not, the system will process the current reply for the inquiry message.
Having verified that the inquiry message is one of the four RNQ messages of interest, RNQMGR then performs additional processing. This processing is done only after verifying the message so that we do not add unnecessary processing within the job. Remember that RNQMGR will be called for every inquiry message within a job on the system. We want to make sure the program does no unnecessary processing until we know we are in an error path of interest.
The next check made by RNQMGR is to determine if the job is being run by the user JOE_PGMR. JOE_PGMR represents a developer on the system, and we most likely do not want to be notifying support personnel of program failures that may be part of Joe's normal application development and testing efforts. RNQMGR examines the user profile portion of the current job name, which is available with the Program Status Data Structure (PSDS) variable JobUsr, and if the job is initiated by JOE_PGMR, RNQMGR ends.
In practice, it is unlikely we would want to make such a check using a hard-coded name (JOE_PGMR) within the RNQMGR program source. Every time we added a developer, removed a developer, or changed the profile name of a developer, we would need to modify, recompile, and retest the RNQMGR program. A more general-purpose approach would be to have a database file, keyed by *USRPRF name, with one record for each developer. RNQMGR could then CHAIN to the file using the user profile name and, if a record is found (for instance, a record entry for JOE_PGMR), end the program. Then any changes in the development staff could be handled with simple record maintenance to the file and not require any change to the RNQMGR exit program. This database file should be defined as USROPN and only opened after verifying that the inquiry message is one of interest. USROPN should be used in order to avoid having the program automatically open, and close, the file for every inquiry message in the job.
Having determined that the inquiry message is one of interest, and that the message is not related to one of the developers, RNQMGR then starts constructing a message (using variable MsgTxt) that will be sent to support personnel, notifying them of the program failure. The message first identifies the job experiencing the failure by logging the inquiry message ID (parameter MsgID, which was passed to RNQMGR by the system) and the qualified job name (determined from the PSDS, as RNQMGR is running in the same job as the program sending the inquiry message).
RNQMGR then uses the Receive Program Message (QMHRCVPM) API, documented here, to receive the inquiry message and the message replacement data associated with the message. All four of the RNQ messages return the same initial forty bytes of information; the first 10 bytes are the name of the RPG procedure causing the inquiry message to be sent, the next 10 bytes the name of the RPG program causing the message to be sent, then the library where the RPG program is located, and finally the RPG statement number that caused the inquiry message to be sent. Some of this replacement data will be used in subsequent processing.
For demonstration purposes, RNQMGR uses the two-call technique first introduced in the article "Retrieving Information, Part II" in order to ensure that all available message information is returned to the program. This two-call technique is not actually needed by the example program RNQMGR as we could simply define the receiver variable for the QMHRCVPM API with a size sufficient for these 40 bytes, but not all inquiry messages that you may want to track will be as accommodating as these four RNQ messages, so we will go with the more general-purpose approach of retrieving the message replacement data.
Having successfully accessed the message replacement data, RNQMGR now adds the name of the failing program to the message being constructed (MsgTxt). The program name is provided by the message replacement data associated with the message (variable PgmName of the BASED data structure RNQ_Msg). It is worth pointing out that RNQMGR is not using the name of the program sending the inquiry message. The program actually sending the message will often be a language run-time program (such as QRNXIE in the case of ILE RPG). Using the RNQ message replacement data gives RNQMGR access to the program that caused the inquiry message, not sent it.
RNQMGR now enters a SELECT group. The first WHEN statement determines if the current reply to the inquiry message can be changed by the exit program (a CallType of 1, 2, or 3). If so, the program enters another SELECT group.
Within this second SELECT group, when the program causing the inquiry message is 'ABC001', RNQMGR ensures that an RPG formatted dump is requested in response to the inquiry message. If the current message reply (parameter Reply) is not equal to 'D', RNQMGR changes the message reply to 'D', sets the message reply length to 1 byte (the length of the literal 'D'), appends to the message text stored in variable MsgTxt that a response of 'D' was made by the exit program, and sets the Reply action return code parameter (ReplyAcnCode) to the value '2'. A Reply action return code value of 2 tells the system that the current inquiry message reply should be replaced by the new value of the Reply parameter.
If the program causing the inquiry message is not ABC001 (the OTHER statement of the inner select group), RNQMGR ensures that the program is canceled. If the current message reply is not equal to 'C', RNQMGR appends to the message text stored in variable MsgTxt the response that was found (variable Reply), indicates that a response of 'C' was requested by the exit program, changes the message reply to 'C', sets the message reply length to 1 byte, and sets the Reply action return code parameter to the value of '2' (the reply provided by RNQMGR should replace the current inquiry message reply). In addition, RNQMGR determines if the initial inquiry message response was entered by the user (a call type value of 1) as opposed to being a default value. If the user explicitly entered the response (as opposed to simply using the Enter key when the inquiry message was shown), RNQMGR appends the text 'Initial reply was not provided by the system'.
If RNQMGR is not able to change the message reply (the OTHER statement of the outer select group), RNQMGR appends to the MsgTxt variable the call type encountered and the message reply being used by the system. This is to document to the support personnel when RNQMGR is unable to alter the reply to the inquiry message.
RNQMGR then does some general cleanup: deallocates any storage previously allocated when receiving the inquiry message replacement data, appends error text to the MsgTxt variable if any anticipated errors were encountered, and sends a message containing the MsgTxt variable to the message queue PGMR in library QGPL.
The program then ends.
Hopefully, this example program gives you a rough idea of the things you can do in terms of being aware of inquiry messages that may be occurring on your system, ways to change the responses being made to these inquiry messages, and some of the considerations you will want to keep in mind in order to minimize the impact of running an exit program within your jobs. When your exit program receives control, only your imagination (and of course your authorization!) limit what you can do within the exit program.
One usage note should be made prior to concluding this article. When you are developing a reply-handling exit program, be aware that debug breakpoints within the exit program will not be processed. Any breakpoints you set in the exit program will be ignored, and, after the exit program completes, the message CPF195A (Breakpoint already run when notification received) will be found in the job log. When developing your reply-handling exit program, you may find the RPG DSPLY opcode to be your friend. Additional usage notes can be found in the exit point documentation.
In the next article, we'll look at another exit program capability: the inquiry-handling exit point QIBM_QMH_HDL_INQEXT. This exit, available only with V6R1, allows your exit program to run and reply to an inquiry message, preventing the end user from even seeing the inquiry message.

Meanwhile, if you have other API questions, send them to me at This email address is being protected from spambots. You need JavaScript enabled to view it.. I'll see what I can do about answering your burning questions in future columns.

Bruce Vining

Bruce Vining is president and co-founder of Bruce Vining Services, LLC, a firm providing contract programming and consulting services to the System i community. He began his career in 1979 as an IBM Systems Engineer in St. Louis, Missouri, and then transferred to Rochester, Minnesota, in 1985, where he continues to reside. From 1992 until leaving IBM in 2007, Bruce was a member of the System Design Control Group responsible for OS/400 and i5/OS areas such as System APIs, Globalization, and Software Serviceability. He is also the designer of Control Language for Files (CLF).A frequent speaker and writer, Bruce can be reached at 

MC Press books written by Bruce Vining available now on the MC Press Bookstore.

IBM System i APIs at Work IBM System i APIs at Work
Leverage the power of APIs with this definitive resource.
List Price $89.95

Now On Sale



Support MC Press Online





  • White Paper: Node.js for Enterprise IBM i Modernization

    SB Profound WP 5539

    If your business is thinking about modernizing your legacy IBM i (also known as AS/400 or iSeries) applications, you will want to read this white paper first!

    Download this paper and learn how Node.js can ensure that you:
    - Modernize on-time and budget - no more lengthy, costly, disruptive app rewrites!
    - Retain your IBM i systems of record
    - Find and hire new development talent
    - Integrate new Node.js applications with your existing RPG, Java, .Net, and PHP apps
    - Extend your IBM i capabilties to include Watson API, Cloud, and Internet of Things

    Read Node.js for Enterprise IBM i Modernization Now!


  • Profound Logic Solution Guide

    SB Profound WP 5539More than ever, there is a demand for IT to deliver innovation.
    Your IBM i has been an essential part of your business operations for years. However, your organization may struggle to maintain the current system and implement new projects.
    The thousands of customers we've worked with and surveyed state that expectations regarding the digital footprint and vision of the companyare not aligned with the current IT environment.

    Get your copy of this important guide today!


  • 2022 IBM i Marketplace Survey Results

    Fortra2022 marks the eighth edition of the IBM i Marketplace Survey Results. Each year, Fortra captures data on how businesses use the IBM i platform and the IT and cybersecurity initiatives it supports.

    Over the years, this survey has become a true industry benchmark, revealing to readers the trends that are shaping and driving the market and providing insight into what the future may bring for this technology.

  • Brunswick bowls a perfect 300 with LANSA!

    FortraBrunswick is the leader in bowling products, services, and industry expertise for the development and renovation of new and existing bowling centers and mixed-use recreation facilities across the entertainment industry. However, the lifeblood of Brunswick’s capital equipment business was running on a 15-year-old software application written in Visual Basic 6 (VB6) with a SQL Server back-end. The application was at the end of its life and needed to be replaced.
    With the help of Visual LANSA, they found an easy-to-use, long-term platform that enabled their team to collaborate, innovate, and integrate with existing systems and databases within a single platform.
    Read the case study to learn how they achieved success and increased the speed of development by 30% with Visual LANSA.


  • The Power of Coding in a Low-Code Solution

    LANSAWhen it comes to creating your business applications, there are hundreds of coding platforms and programming languages to choose from. These options range from very complex traditional programming languages to Low-Code platforms where sometimes no traditional coding experience is needed.
    Download our whitepaper, The Power of Writing Code in a Low-Code Solution, and:

    • Discover the benefits of Low-code's quick application creation
    • Understand the differences in model-based and language-based Low-Code platforms
    • Explore the strengths of LANSA's Low-Code Solution to Low-Code’s biggest drawbacks



  • Why Migrate When You Can Modernize?

    LANSABusiness users want new applications now. Market and regulatory pressures require faster application updates and delivery into production. Your IBM i developers may be approaching retirement, and you see no sure way to fill their positions with experienced developers. In addition, you may be caught between maintaining your existing applications and the uncertainty of moving to something new.
    In this white paper, you’ll learn how to think of these issues as opportunities rather than problems. We’ll explore motivations to migrate or modernize, their risks and considerations you should be aware of before embarking on a (migration or modernization) project.
    Lastly, we’ll discuss how modernizing IBM i applications with optimized business workflows, integration with other technologies and new mobile and web user interfaces will enable IT – and the business – to experience time-added value and much more.


  • UPDATED: Developer Kit: Making a Business Case for Modernization and Beyond

    Profound Logic Software, Inc.Having trouble getting management approval for modernization projects? The problem may be you're not speaking enough "business" to them.

    This Developer Kit provides you study-backed data and a ready-to-use business case template to help get your very next development project approved!

  • What to Do When Your AS/400 Talent Retires

    FortraIT managers hoping to find new IBM i talent are discovering that the pool of experienced RPG programmers and operators or administrators is small.

    This guide offers strategies and software suggestions to help you plan IT staffing and resources and smooth the transition after your AS/400 talent retires. Read on to learn:

    • Why IBM i skills depletion is a top concern
    • How leading organizations are coping
    • Where automation will make the biggest impact


  • Node.js on IBM i Webinar Series Pt. 2: Setting Up Your Development Tools

    Profound Logic Software, Inc.Have you been wondering about Node.js? Our free Node.js Webinar Series takes you from total beginner to creating a fully-functional IBM i Node.js business application. In Part 2, Brian May teaches you the different tooling options available for writing code, debugging, and using Git for version control. Attend this webinar to learn:

    • Different tools to develop Node.js applications on IBM i
    • Debugging Node.js
    • The basics of Git and tools to help those new to it
    • Using as a pre-built development environment



  • Expert Tips for IBM i Security: Beyond the Basics

    SB PowerTech WC GenericIn this session, IBM i security expert Robin Tatam provides a quick recap of IBM i security basics and guides you through some advanced cybersecurity techniques that can help you take data protection to the next level. Robin will cover:

    • Reducing the risk posed by special authorities
    • Establishing object-level security
    • Overseeing user actions and data access

    Don't miss this chance to take your knowledge of IBM i security beyond the basics.



  • 5 IBM i Security Quick Wins

    SB PowerTech WC GenericIn today’s threat landscape, upper management is laser-focused on cybersecurity. You need to make progress in securing your systems—and make it fast.
    There’s no shortage of actions you could take, but what tactics will actually deliver the results you need? And how can you find a security strategy that fits your budget and time constraints?
    Join top IBM i security expert Robin Tatam as he outlines the five fastest and most impactful changes you can make to strengthen IBM i security this year.
    Your system didn’t become unsecure overnight and you won’t be able to turn it around overnight either. But quick wins are possible with IBM i security, and Robin Tatam will show you how to achieve them.

  • Security Bulletin: Malware Infection Discovered on IBM i Server!

    SB PowerTech WC GenericMalicious programs can bring entire businesses to their knees—and IBM i shops are not immune. It’s critical to grasp the true impact malware can have on IBM i and the network that connects to it. Attend this webinar to gain a thorough understanding of the relationships between:

    • Viruses, native objects, and the integrated file system (IFS)
    • Power Systems and Windows-based viruses and malware
    • PC-based anti-virus scanning versus native IBM i scanning

    There are a number of ways you can minimize your exposure to viruses. IBM i security expert Sandi Moore explains the facts, including how to ensure you're fully protected and compliant with regulations such as PCI.



  • Encryption on IBM i Simplified

    SB PowerTech WC GenericDB2 Field Procedures (FieldProcs) were introduced in IBM i 7.1 and have greatly simplified encryption, often without requiring any application changes. Now you can quickly encrypt sensitive data on the IBM i including PII, PCI, PHI data in your physical files and tables.
    Watch this webinar to learn how you can quickly implement encryption on the IBM i. During the webinar, security expert Robin Tatam will show you how to:

    • Use Field Procedures to automate encryption and decryption
    • Restrict and mask field level access by user or group
    • Meet compliance requirements with effective key management and audit trails


  • Lessons Learned from IBM i Cyber Attacks

    SB PowerTech WC GenericDespite the many options IBM has provided to protect your systems and data, many organizations still struggle to apply appropriate security controls.
    In this webinar, you'll get insight into how the criminals accessed these systems, the fallout from these attacks, and how the incidents could have been avoided by following security best practices.

    • Learn which security gaps cyber criminals love most
    • Find out how other IBM i organizations have fallen victim
    • Get the details on policies and processes you can implement to protect your organization, even when staff works from home

    You will learn the steps you can take to avoid the mistakes made in these examples, as well as other inadequate and misconfigured settings that put businesses at risk.



  • The Power of Coding in a Low-Code Solution

    SB PowerTech WC GenericWhen it comes to creating your business applications, there are hundreds of coding platforms and programming languages to choose from. These options range from very complex traditional programming languages to Low-Code platforms where sometimes no traditional coding experience is needed.
    Download our whitepaper, The Power of Writing Code in a Low-Code Solution, and:

    • Discover the benefits of Low-code's quick application creation
    • Understand the differences in model-based and language-based Low-Code platforms
    • Explore the strengths of LANSA's Low-Code Solution to Low-Code’s biggest drawbacks



  • The Biggest Mistakes in IBM i Security

    SB Profound WC Generic The Biggest Mistakes in IBM i Security
    Here’s the harsh reality: cybersecurity pros have to get their jobs right every single day, while an attacker only has to succeed once to do incredible damage.
    Whether that’s thousands of exposed records, millions of dollars in fines and legal fees, or diminished share value, it’s easy to judge organizations that fall victim. IBM i enjoys an enviable reputation for security, but no system is impervious to mistakes.
    Join this webinar to learn about the biggest errors made when securing a Power Systems server.
    This knowledge is critical for ensuring integrity of your application data and preventing you from becoming the next Equifax. It’s also essential for complying with all formal regulations, including SOX, PCI, GDPR, and HIPAA
    Watch Now.

  • Comply in 5! Well, actually UNDER 5 minutes!!

    SB CYBRA PPL 5382

    TRY the one package that solves all your document design and printing challenges on all your platforms.

    Produce bar code labels, electronic forms, ad hoc reports, and RFID tags – without programming! MarkMagic is the only document design and print solution that combines report writing, WYSIWYG label and forms design, and conditional printing in one integrated product.

    Request your trial now!

  • Backup and Recovery on IBM i: Your Strategy for the Unexpected

    FortraRobot automates the routine tasks of iSeries backup and recovery, saving you time and money and making the process safer and more reliable. Automate your backups with the Robot Backup and Recovery Solution. Key features include:
    - Simplified backup procedures
    - Easy data encryption
    - Save media management
    - Guided restoration
    - Seamless product integration
    Make sure your data survives when catastrophe hits. Try the Robot Backup and Recovery Solution FREE for 30 days.

  • Manage IBM i Messages by Exception with Robot

    SB HelpSystems SC 5413Managing messages on your IBM i can be more than a full-time job if you have to do it manually. How can you be sure you won’t miss important system events?
    Automate your message center with the Robot Message Management Solution. Key features include:
    - Automated message management
    - Tailored notifications and automatic escalation
    - System-wide control of your IBM i partitions
    - Two-way system notifications from your mobile device
    - Seamless product integration
    Try the Robot Message Management Solution FREE for 30 days.

  • Easiest Way to Save Money? Stop Printing IBM i Reports

    FortraRobot automates report bursting, distribution, bundling, and archiving, and offers secure, selective online report viewing.
    Manage your reports with the Robot Report Management Solution. Key features include:

    - Automated report distribution
    - View online without delay
    - Browser interface to make notes
    - Custom retention capabilities
    - Seamless product integration
    Rerun another report? Never again. Try the Robot Report Management Solution FREE for 30 days.

  • Hassle-Free IBM i Operations around the Clock

    SB HelpSystems SC 5413For over 30 years, Robot has been a leader in systems management for IBM i.
    Manage your job schedule with the Robot Job Scheduling Solution. Key features include:
    - Automated batch, interactive, and cross-platform scheduling
    - Event-driven dependency processing
    - Centralized monitoring and reporting
    - Audit log and ready-to-use reports
    - Seamless product integration
    Scale your software, not your staff. Try the Robot Job Scheduling Solution FREE for 30 days.