Chapter 8
Migrating from Verimation MEMO
To migrate users from Verimation MEMO to Microsoft Exchange Server, you use the MEMO Source Extractor.
The MEMO Source Extractor migrates information from an existing system, thereby reducing the migration workload. It provides users with access to their original MEMO documents, thereby minimizing disruption. It can also populate the Microsoft Exchange Server directory with users remaining on MEMO, thereby simplifying communication.
This chapter explains how to install, operate, and troubleshoot the MEMO Source Extractor. You should be familiar with the following:
	Verimation MEMO and MEMO utilities
	Microsoft Exchange Server Migration Wizard
	MVS Job Control Language (JCL) 
	PC-TSO file transfer programs

For more detailed information, you can refer to specialized manuals, such as the following:
	MEMO/SNADS Installation and Reference Guide
	MEMO Utilities Reference
	MEMO/API Installation Manual
	MEMO/API User Reference
	MEMO Reference Manual
	MEMO/Gateway Installation Guide

Microsoft Exchange Server Host Migration Tools
Support and Services 
Microsoft Exchange Server Host Migration tools assist in migrating from the following host-based messaging systems to Microsoft Exchange Server:
	IBM PROFS/OfficeVision
	Digital ALL-IN-1
	Verimation MEMO

These comprehensive tools provide host administrators with a means of migrating users’ accounts, private e-mail messages, shared information, attachments, documents, calendar data, and personal address data to Microsoft Exchange Server.

Important
The PROFS/OV, ALL-IN-1 and MEMO host source extractors are not supported through standard Microsoft Product Support Services, such as the Premier Support Plan.

To receive support and customization services around these tools, host administrators have the following options:
Microsoft Consulting Services 
Microsoft Consulting Services is providing services to assist in migrating to Microsoft Exchange Server. 
Independent Consultants and Software Vendors 
A number of independent software vendors and consultants provide fee-for-service and products to assist you in your migration planning, implementation, and customization. For contact information and descriptions of migration services and products offered, see the sections that follow. Also see the Microsoft Exchange Server home page (http://www.microsoft.com/exchange) for an up-to-date listing of Microsoft Exchange Server-compatible products and services.
Self-support/Customization 
Included with host migration are tools and documentation that enable you to manage your migration. The source code for each tool is provided to enable your system programmers, solution providers, or system integrators to support and tailor the tools to your specific needs.
Attachmate Corporation
Attachmate Corporation offers SupportWare for Zip!Office connectivity products and Migration Consulting Services. 
Attachmate SupportWare
Provides multilevel customer support offering specialized assistance on MAPI-to-host connectivity products including ZIP! Office Connector for PROFS, ZIP! Office Connector for SNADS, and ZIP! Office Client Connection. Services include toll-free customer support directly to engineers.
Attachmate Consulting Services
Provide a wide variety of custom programming or installation assistance on any of our program products or utilities that assist customers with migration or coexistence strategies concerning Microsoft Exchange Server and IBM hosts. Services include a quick-start program, contract programming, migration assistance, and coexistence consulting.
Attachmate Corporation
3617 131st Avenue, SE
Bellevue, WA 98006
Phone: 800-426-6283 or 206-644-4010
http://www.attachmate.com/
Digital Systems Integration Enterprise Messaging Services
Digital Systems Integration has a worldwide professional force of enterprise messaging and workgroup computing professionals. With a closely coordinated network of more than 450 experts around the world, many of them certified Microsoft Solution Developers, Digital can support the most demanding requirements of enterprise messaging networks.
MS-Exchange Planning Service
Designed for the customer who has committed to the implementation of the Microsoft Exchange Server as an enterprise-wide messaging infrastructure and wants to migrate from or integrate with an existing messaging infrastructure.
MS-Exchange Startup Pilot
Designed for the customer who wants to evaluate a practical implementation of Microsoft Exchange Server.
MS-Exchange Integration and Migration Service
Provides the customer with a working messaging handling system based on Microsoft Exchange Servers and clients. Installation, configuration, testing, roll-out project management, and training are delivered to customer locations around the world. The service addresses coexistence between legacy enterprise mail (office automation) systems and Microsoft Exchange Server, as well as migration from Digital’s ALL-IN-1, IBM PROFS, HP-Desk, and other legacy e-mail systems, including directory integration, administration, and management.
Americas
    Digital Systems Integration
    Enterprise Messaging Manager
    6404 Ivy Lane., M/S COP 1-7/9
    Greenbelt, MD, USA, 20770-1443
    Phone: 301-918-7732
    E-mail: Enterprise.Messaging@cop.mts.dec.com	
Europe
    Digital Systems Integration
    Business Development Manager
    BP 027 
    06901 Sophia Antipolis, France
    Phone: +33 92 95 54 85
    E-mail: Enterprise.Messaging@vbo.mts.dec.com	
Asia/Pacific
    Digital Systems Integration
    Consulting Manager
    139 Frome Street
    Adelaide, SA 5000, Australia
    Phone: +61 (8) 235-7242
    E-mail: Enterprise.Messaging@ado.mts.dec.com	

Icom Solutions Ltd.
Icom Solutions has worked with over 500 of the world’s largest organizations to design, build, and customize automated office and workflow solutions. Icom Solutions offers strategic and technical assistance and the full range of systems integration expertise to help the corporate organization define and realize migration strategies from high-cost, low-function host systems to lower-cost, high-function client/server systems.
Icom offers specialized and off-the-shelf solutions to address migration to Microsoft Exchange Server from: Verimation MEMO, OfficeVision/MVS, OfficeVision/VM, OfficeVision/400, Fischer TAO, CA Email, DISOSS Library, and Lotus Notes and cc:Mail.
Icom Solutions provides a comprehensive migration service that covers the key issues in achieving a successful move. Business consultants help construct the business case for making the move to Microsoft Exchange Server to ensure the right level of sponsorship within an organization. Consultants can make a clear assessment of the starting point of the migration and define the optimum target architecture. Specialist planning services help organizations to plan and prioritize the transfer of users and applications and address the areas of internal skills development.
Technical consultants provide a wide range of specialist networking and systems integration skills to assist throughout the process.
Icom Solutions Ltd.
PO Box 1240 
Witton
Birmingham
U.K. B6 7UH
Phone: +44 (0) 121 356 8383
Fax: +44 (0) 121 356 0463
Microsoft Consulting Services
Microsoft Exchange Planning Service
For large organizations moving to Microsoft Exchange Server, Microsoft Consulting Services (MCS) provide a focused planning service that evaluates the customer’s current messaging and network infrastructure in light of their business objectives. Based on that evaluation, MCS produces a preliminary Microsoft Exchange Server design, highlights key technical and migration issues unique to the customer, and provides recommendations for testing, piloting, and migration resources.
In addition to the planning service, MCS can assist organizations with every aspect of their move to Microsoft Exchange Server, from piloting through deployment. With an emphasis on knowledge transfer, the MCS staff works closely with the customer’s technical staff and third-parties to ensure a successful migration to Microsoft Exchange Server.
To find out more about Microsoft Exchange Server Migration Consulting Services, contact your Microsoft account representative, or call (800) 426-9400. In Canada, call Microsoft Canada at (905) 568-0434. Outside the United States or Canada, contact your local Microsoft office.
SysTEAMus Corporation
SysTEAMus Corporation is a software engineering firm that specializes in the design, development, and implementation of client/server systems, electronic messaging applications, and Digital ALL-IN-1 systems.
SysTEAMus Exchange Migration Service is specially tailored to assist organizations in integrating with or making the transition from Digital ALL-IN-1 to Microsoft Exchange Server. The service includes the necessary up-front planning to ensure a smooth transition. Additionally, it is flexible and can be adjusted in scope to accommodate any size organization as either a supplement to internal staff or as a “we do it all” engagement. Services include migration of ALL-IN-1 applications to Visual Basic.
SysTEAMus Corporation
Suite #2800
6855 Jimmy Carter Blvd.
Norcross, GA 30071
Phone:   (770) 417-1251
Fax:       (770) 417-1909
Introduction
The MEMO Source Extractor is a host-based MVS batch application that creates migration files. You transfer these files to Microsoft Exchange Server by using a PC-TSO file transfer program and the Migration Wizard, a user interface of Microsoft Exchange Server.
The MEMO Source Extractor consists of two MVS batch JCL jobs. The first job generates lists of users. The other job migrates the users.
This chapter is organized into the following sections:
	Installing the MEMO Source Extractor 
	Performing the Migration
	Connecting MEMO to Microsoft Exchange Server 
	Troubleshooting the MEMO Source Extractor 
	MEMO Glossary

Installing the Memo Source Extractor
This section guides you through the process of  installing the MEMO Source Extractor. You will need to perform each of the following steps, which are explained in the sections that follow.
	Prepare for installation.
	Unload the MEMO Source Extractor.
	Run the set-up job.
	Create the error message file.
	Update the sample JCL jobs. 
	Modify the MEMO user profiles.
	Customize the error messages. (Optional)
	Transfer formatted messages.
	Test the installation.

Prepare for Installation
The MEMO Source Extractor will only operate with MEMO/MVS, not MEMO for other operating systems. The MEMO Source Extractor requires MEMO V3.2.1 (or later version), MEMO/API V1.4.0 (or later version), and VS/COBOL II Run Time Library Release 3.0 (or later version).
Before installing the MEMO Source Extractor, you must install Microsoft Exchange Server and a PC-TSO file transfer program, which will transfer mail between MEMO and Microsoft Exchange Server. This file transfer program must convert the text of mail messages from EBCDIC to ASCII.
You may decide to migrate all MEMO users at one time (single-phase migration) or in multiple steps (multi-phase migration). If you choose multi-phase migration, you also need to install a connection between MEMO and Microsoft Exchange Server.
The MEMO Source Extractor migrates only mail messages, not binary files. The following maximums are also imposed on the migrated data:
	Maximum memo text size: 500K
	Maximum number of recipients for each mail item: 70
	Maximum number of items migrated from one maillog: 10,000

If you need to migrate more than 10,000 items in a user’s maillog, you can re-run the migration process for that user, as explained in the “Troubleshooting the MEMO Source Extractor” section.
Unload the MEMO Source Extractor
The MEMO Source Extractor is supplied in a PC-readable format, which consists of two sequential files:
File	Dataset Name (DSN)	Descriptions	
			
1	MEMOJCL.PDS	JCL library for MEMO Source Extractor	
2	MEMOLOAD.PDS	Load library for MEMO Source Extractor	

	To unload the MEMO Source Extractor, follow these steps for both of the sequential files
	1.	Use the PC-TSO file transfer program to copy the file from the MEMO Source Extractor PC format to a sequential dataset on the host. If the PC-TSO file transfer program allows you to specify the LRECL value of the dataset, use 80 bytes.
	2.	Expand the sequential dataset to create a partitioned dataset, by using the TSO RECEIVE command. For example, enter RECEIVE INDSNAME(MEMOJCL) where MEMOJCL is the name of the sequential dataset that you created on the host.
	3.	When prompted, enter the name of the partitioned dataset that you want to create. For example, to create the MEMO Source Extractor JCL partitioned dataset, type DATASET(MEMOMIG.JCL).
Run the MEMO Source Extractor Set-Up Job
The MEMO Source Extractor set-up job creates the dataset MIGACCT and copies a sample record into it. The sample record will help you understand the format of MIGACCT records. The set-up job also creates generation data group indexes required by MIGUSERL, MIGPRIM1, MIGPRIM2, MIGPACK, MIGPACK2, and MIGSEC.
Start set-up by submitting the JCL job MIGSET in the MEMO Source Extractor JCL library. 
	To run the JCL job MIGSET
	1.	Edit MIGSET by changing the job card information to conform to your installation standards.
	2.	Change the library name to the library where you have installed the MEMO Source Extractor. All MEMO Source Extractor datasets in the sample JCL are prefixed by MEMOMIG.
	3.	Save.
	4.	Submit.
Create the Error Message File
Error messages from the MEMO Source Extractor are held in the VSAM file MIGCUST. To create MIGCUST, you need to run the JCL job MIGCUST in the MEMO Source Extractor library. 
	To run the JCL job MIGCUST
	1.	Edit MIGCUST by changing the job card information to conform to your installation standards.
	2.	Change the library name to the library where you have installed the MEMO Source Extractor. All MEMO Source Extractor datasets in the sample JCL are prefixed by MEMOMIG.
	3.	Specify your installation’s COBOL II runtime library in Step 30.
	4.	Save.
	5.	Submit.

Note
The error messages produced by the MEMO Source Extractor can be customized. Refer to the “Customize the Error Messages” section, later in this chapter.

Update the Sample JCL Jobs
To install the MEMO Source Extractor, you submit two JCL jobs: MIGGENU (UserList) and MIGMIGU (Migrate Users). Sample JCL for these jobs can be found in the MEMO Source Extractor JCL library.
Both jobs are supplied with dummy job card and library definitions. You must update the sample JCL before running the jobs. For information about running these functions, see the “Performing the Migration” section, later in this chapter.
Start the UserList function by submitting the MVS batch job MIGGENU from the MEMO Source Extractor JCL library. Refer to Figure 2.4 and follow these steps:
	To update the UserList sample JCL job MIGGENU
	1.	Run Step 10, which runs the MEMO HLPERUD1 program that produces MIGUSRL, a list of all users currently defined in MEMO. The HLPERUD1 program operation is described in the MEMO Reference Manual.

Note
CATSEQI must be defined as a dummy dataset to ensure that MIGUSRL contains all users currently defined in MEMO.

	2.	Run Step 20, which runs the MEMO Source Extractor MIGGENU program that generates messages to send to the Microsoft Exchange Server Migration Assistant.
	3.	Update the Job Control information.
	4.	Update all MEMO Source Extractor dataset names, all of which are prefixed MEMOMIG. Replace MEMOMIG with the name of the library where you installed the MEMO Source Extractor. 
	5.	Update all MEMO dataset names, which are prefixed MEMO. Replace MEMO with the name of the library for your installation.
	6.	Specify the COBOL II runtime library for your installation in Step 20.
	7.	Update Step 20 as follows:
MODE
Specify M to create mailboxes, or specify R to create remote addresses. You create mailboxes for all users to be migrated to Microsoft Exchange Server. You create remote addresses for users who will continue to use MEMO but want to communicate with Microsoft Exchange Server users.
PRIMARY
Specify the PC file name for MIGPRIM1, the extracted information file produced by the MEMO Source Extractor. This name must correspond to the name to be used during PC-TSO file transfer. For example: primary.pri.
GCID
Specify the Graphic Character Identification (GCID) code-page that will hold the extracted information on the PC. Its standard value will be 850, which is the multilingual code-page. This value should correspond to the code-page to which your PC-TSO file transfer program will convert when converting from EBCDIC to ASCII. For example: gcidcodepage.

//JOBNAME  JOB (ACCOUNT),'PROGNAME',                                    
//         CLASS=0,MSGCLASS=A,NOTIFY=XXXXXXX,COND=(0,NE)                
//*ROUTE PRINT RMT188                                                   
//********************************************************************* 
//*                                                                   * 
//* MEMO SOURCE EXTRACTOR                                             *
//*                                                                   * 
//* This process can be run in two modes:                             * 
//*                                                                   * 
//* a) Generate list of Memo users to be created as Microsoft Exchange Server users.        * 
//*                                                                   * 
//* b) Generate list of Memo users to be created as Microsoft Exchange Server mailboxes.    * 
//*                                                                   * 
//*                                                                   * 
//* Held in library  - MEMOMIG.JCL(MIGGENU)                           * 
//* Created          - 19/09/95 by IMI                                * 
//* Last Updated     -                                                * 
//*                                                                   * 
//* Steps - STEP010  PGM HLPERUD1   Generate a file of all current    *
//*                                 Memo users.                       * 
//*         STEP020  PGM MIGGENU    Generate a file containing a list * 
//*                                 of users to be downloaded and a   * 
//*                                 packing list containing the file  * 
//*                                 names used.                       * 
//********************************************************************* 
//****************************************************                  
//****     Create file of ALL MEMO users          ****                  
//****************************************************                  
//*                                                                     
//STEP010  EXEC PGM=HLPERUD1,PARM='GMT+0'                               
//*                                                                     
//STEPLIB  DD  DSN=MEMO.MEMO32.LOAD,DISP=SHR                            
//CATBASE  DD  DSN=MEMO.MEMO32.CATBASEP,DISP=SHR                        
//CATCHG   DD  DSN=MEMO.MEMO32.CATCHGP,DISP=SHR                         
//CHKPT    DD  DSN=MEMO.MEMO32.CHKPT,DISP=SHR                           
//CATSEQI  DD  DUMMY                                                    
//CATSEQO  DD  DUMMY                                                    
//CATSEQU  DD  DSN=&&CATSEQU,DISP=(NEW,PASS,DELETE),                    
//             UNIT=DASD,SPACE=(TRK,(5,5),RLSE),                        
//             DCB=(RECFM=VB,LRECL=467,BLKSIZE=23000)                   
//WTOLOG   DD  DSN=MEMO.MEMO32.DIRUPD.WTOLOG,DISP=SHR
//*                                                                     
//SORT     EXEC PGM=SORT,REGION=512K                                    
//SORTIN   DD  DSN=&&CATSEQU,DISP=(OLD,PASS)                            
//SORTOUT  DD  DSN=MEMOMIG.MIGUSRL(+1),                                 
//             DISP=(NEW,CATLG,DELETE),                                 
//             UNIT=DASD,SPACE=(TRK,(5,5),RLSE),                        
//             DCB=(MODEL.DSCB,RECFM=VB,LRECL=467,BLKSIZE=23000)        
//SORTWK01 DD  DSN=&UT1,UNIT=3380,SPACE=(CYL,(9),,CONTIG)               
//SORTWK02 DD  DSN=&UT2,UNIT=3380,SPACE=(CYL,(9),,CONTIG)               
//SORTWK03 DD  DSN=&UT3,UNIT=3380,SPACE=(CYL,(9),,CONTIG)               
//SYSIN    DD  DSN=MEMO.MEMO32.MAINT(RDIRSORT),DISP=SHR                 
//SYSOUT   DD  SYSOUT=*                                                 
//*                                                                     
//****************************************************                  
//****     Generate UserList                      ****                  
//****************************************************                  
//*                                                                     
//STEP020  EXEC PGM=MIGGENU                                             
//*                                                                     
//STEPLIB  DD  DISP=SHR,DSN=MEMOMIG.LOAD                                
//*                     COBOL 2 LIBRARY                                 
//         DD  DISP=SHR,DSN=SYS1.COB2LIB
//MIGUSRL  DD  DISP=SHR,DSN=MEMOMIG.MIGUSRL(+1)                         
//MIGACCT  DD  DISP=SHR,DSN=MEMOMIG.MIGACCT                             
//MIGCUST  DD  DISP=SHR,DSN=MEMOMIG.VSAM.MIGCUST                        
//MIGPRIM1 DD  DSN=MEMOMIG.MIGPRIM1(+1),                                
//             DISP=(NEW,CATLG,CATLG),                                  
//             UNIT=DASD,SPACE=(TRK,(5,5),RLSE),                        
//             DCB=(MODEL.DSCB,RECFM=FB,LRECL=255,BLKSIZE=22950)        
//MIGPACK  DD  DSN=MEMOMIG.MIGPACK(+1),                                 
//             DISP=(NEW,CATLG,CATLG),                                  
//             UNIT=DASD,SPACE(TRK,(5,5),RLSE),                         
//             DCB=(RECFM=FB,LRECL=255,BLKSIZE=22950)                   
//MIGPARM1 DD *                                                         
MODE        R                                                           
PRIMARY     PRIM1.PRI                                                   
GCID        850                                                         
/*                                                                      
//SYSOUT   DD  SYSOUT=*                                                 
//SYSPRINT DD  SYSOUT=*                                                 
//SYSABOUT DD  SYSOUT=*                                                 
//SYSUDUMP DD  SYSOUT=*              
//*

 Figure 2.4 Supplied JCL to run UserList MIGGENU

Update the Migrate Users Sample JCL Job
This process will migrate all mail items for a specified list of MEMO users to Microsoft Exchange Server. Start the process by submitting the MVS batch job MIGMIGU from the MEMO Source Extractor JCL library. Refer to the sample JCL in Figure 2.5 and follow these steps.
	To update the Migrate Users sample JCL job MIGMIGU
	1.	Run Step 10, which runs the MEMO HLPERUD1 program that produces MIGUSRL, a list of all users currently defined in MEMO. (The HLPERUD1 program operation is described in the MEMO Reference Manual.)

Note
CATSEQI must be defined as a dummy dataset to ensure that MIGUSRL contains all users currently defined to MEMO.

	2.	Run Step 20, which runs the IBM utility IDCAMS that creates a VSAM dataset MIGUSRV.
	3.	Run Step 30, which copies MIGUSRL to the VSAM dataset MIGUSRV that was created in Step 20.
	4.	Run Step 40, which runs the MEMO Source Extractor MIGMIGU program that generates MIGDOC2, a file with all items in the maillogs of a specified list of users.
	5.	Update the job control information.
	6.	Update all MEMO Source Extractor dataset names (prefixed MEMOMIG). Replace MEMOMIG with the name of the library where you have installed the MEMO Source Extractor.
	7.	Update all MEMO dataset names (prefixed MEMO). Replace MEMO with the name of the MEMO library for your installation. 
	8.	Specify the COBOL II runtime library for your installation in Step 10.
	9.	Update Step 40 as follows:
PRIMARY
Specify the PC file name for MIGPRIM2, the file with the extracted memo header information produced by the MEMO Source Extractor. This name must correspond to the name to be used during PC-TSO file transfer. For example: primary.pri.
SECONDARY
Specify the PC file name for MIGSEC, the file with the extracted memo text produced by the MEMO Source Extractor. This name must correspond to the name to be used during PC-TSO file transfer. For example: secondary.sec.
GCID
Specify the Graphic Character Identification (GCID) code-page that will hold the extracted information on the PC. Its standard value will be 850, which is the multilingual code-page. This value should correspond to the code-page to which your PC-TSO file transfer program will convert when converting from EBCDIC to ASCII. For example: gcidcodepage.

//JOBNAME  JOB (ACCOUNT),'PROGNAME',                                    
//         CLASS=0,MSGCLASS=A,NOTIFY=XXXXXXX                            
//********************************************************************* 
//*                                                                   * 
//* MEMO SOURCE EXTRACTOR                                             * 
//*                                                                   * 
//* Held in library  - MEMOMIG.JCL(MIGMIGU)                           * 
//* Created          - 25/09/95 by IMI                                * 
//* Last Updated     -                                                * 
//*                                                                   * 
//* Steps - STEP010  PGM HLPERUD1   Generate a file of all current    * 
//*                                 Memo users.                       * 
//* Steps - STEP020  PGM IDCAMS     Create a VSAM user file           * 
//*         STEP030  PGM IDCAMS     Copy file of all current Memo     * 
//*                                 users onto the VSAM file          * 
//*         STEP040  PGM MIGMIGU    Generate a file containing all    * 
//*                                 mail items from the mail logs of  * 
//*                                 all the specified users.          * 
//*                                                                   * 
//********************************************************************* 
//****************************************************
//****     Create file of ALL MEMO users          ****                  
//****************************************************                  
//*                                                                     
//STEP010  EXEC PGM=HLPERUD1,PARM='GMT+0'                               
//*                                                                     
//STEPLIB  DD  DSN=MEMO.MEMO32.LOAD,DISP=SHR                            
//CATBASE  DD  DSN=MEMO.MEMO32.CATBASEP,DISP=SHR                        
//CATCHG   DD  DSN=MEMO.MEMO32.CATCHGP,DISP=SHR                         
//CHKPT    DD  DSN=MEMO.MEMO32.CHKPT,DISP=SHR                           
//CATSEQI  DD  DUMMY                                                    
//CATSEQO  DD  DUMMY                                                    
//CATSEQU  DD  DSN=&&CATSEQU,DISP=(NEW,PASS,DELETE),                    
//             UNIT=DASD,SPACE=(TRK,(5,5),RLSE),                        
//             DCB=(RECFM=VB,LRECL=467,BLKSIZE=23000)                   
//WTOLOG   DD  DSN=MEMO.MEMO32.DIRUPD.WTOLOG,DISP=SHR                   
//*                                                                     
//SORT     EXEC PGM=SORT,REGION=512K                                    
//SORTIN   DD  DSN=&&CATSEQU,DISP=(OLD,PASS)                            
//SORTOUT  DD  DSN=MEMOMIG.MIGUSRL(+1),                                 
//             DISP=(NEW,CATLG,DELETE),                                 
//             UNIT=DASD,SPACE=(TRK,(5,5),RLSE),                        
//             DCB=(MODEL.DSCB,RECFM=VB,LRECL=467,BLKSIZE=23000)
//SORTWK01 DD  DSN=&UT1,UNIT=3380,SPACE=(CYL,(9),,CONTIG)               
//SORTWK02 DD  DSN=&UT2,UNIT=3380,SPACE=(CYL,(9),,CONTIG)               
//SORTWK03 DD  DSN=&UT3,UNIT=3380,SPACE=(CYL,(9),,CONTIG)               
//SYSIN    DD  DSN=MEMO.MEMO32.MAINT(RDIRSORT),DISP=SHR                 
//SYSOUT   DD  SYSOUT=*                                                 
//*                                                                     
//STEP20    EXEC PGM=IDCAMS                                             
//SYSPRINT  DD   SYSOUT=*                                               
//DD1       DD   UNIT=DASD,                                             
//          VOL=SER=PRM001,DISP=SHR                                     
//SYSIN     DD   *                                                      
    DELETE MEMOMIG.MIGUSRV                                              
    DEFINE CLUSTER  (NAME(MEMOMIG.MIGUSRV)    -                         
                     VOL(PRM001)              -                         
                     FILE(DD1)                -                         
                     UNIQUE                   -                         
                     CYL(1 1)                 -                         
                     SHAREOPTIONS(2 3))       -                         
           DATA  (NAME(MEMOMIG.MIGUSRV.DATA)  -                         
                     RECORDSIZE(463 463)      -                         
                     KEYS(20 12))             -                         
           INDEX (NAME(MEMOMIG.MIGUSRV.INDEX) -
	IMBED                 -                         
                      REPLICATE)                                         
 /*                                                                      
 //****************************************************************      
 //* COPY DATA OVER FROM THE ORIGINAL MIGUSRL TO THE COPY         *      
 //****************************************************************      
 //*                                                                     
 //STEP30   EXEC PGM=IDCAMS                                              
 //SYSPRINT DD  SYSOUT=*                                                 
 //INPUT    DD  DISP=SHR,DSN=MEMOMIG.MIGUSRL(0)                          
 //OUTPUT   DD  DISP=SHR,DSN=MEMOMIG.MIGUSRV                             
 //SYSIN    DD  *                                                        
   REPRO INFILE(INPUT) OUTFILE(OUTPUT)                                   
 //********************************************************************* 
 //*                                                                   * 
 //* STEP40: GENERATE FILE CONTAINING LIST OF MAIL ITEMS FOR ALL       * 
 //*         SUPPLIED USERS.                                           * 
 //*                                                                   * 
 //********************************************************************* 
 //*                       
 //STEP40    EXEC PGM=MIGMIGU                                            
 //STEPLIB   DD DSN=MEMOMIG.LOAD,DISP=SHR
//*                     COBOL 2 LIBRARY                                 
//          DD DSN=SYS1.COB2LIB,DISP=SHR                                
//          DD DSN=MEMO.MEMO32.API14.LOAD,DISP=SHR                      
//SYSOUT    DD SYSOUT=*                                                 
//SYSABOUT  DD SYSOUT=*                                                 
//APIPARM   DD DSN=MEMO.MEMO32.API14.PARMLIB,DISP=SHR                   
//MIGCUST   DD DSN=MEMOMIG.VSAM.MIGCUST,DISP=SHR                        
//MIGPRIM2  DD DSN=MEMOMIG.MIGPRIM2(+1),                                
//             DISP=(NEW,CATLG,DELETE),                                 
//             UNIT=DASD,SPACE=(TRK,(5,5),RLSE),                        
//             DCB=(MODEL.DSCB,RECFM=FB,LRECL=255,BLKSIZE=22950)        
//MIGSEC    DD DSN=MEMOMIG.MIGSEC(+1),                                  
//             DISP=(NEW,CATLG,DELETE),                                 
//             UNIT=DASD,SPACE=(CYL,(1,5),RLSE),                        
//             DCB=(MODEL.DSCB,RECFM=FB,LRECL=255,BLKSIZE=25500)        
//MIGPACK2  DD DSN=MEMOMIG.MIGPACK2(+1),                                
//             DISP=(NEW,CATLG,DELETE),                                 
//             UNIT=DASD,SPACE=(TRK,(5,5),RLSE),                        
//             DCB=(MODEL.DSCB,RECFM=FB,LRECL=255,BLKSIZE=25500)        
//MIGUSER   DD *                                                        
USER    PASSWORDDISTGRP                                                 
/*
//*                                                                     
//MIGPARM2  DD *                                                        
PRIMARY     PRIM.PRI                                                    
SECONDARY   SECOND.SEC                                                  
GCID        850                                                         
/*

Figure 2.5 Supplied JCL to run Migrate Users MIGMIGU

Modify the MEMO User Profiles
The MEMO Source Extractor uses the Call Type (L2) Interface to access the data in MEMO. To extract the mail items of a MEMO user to be migrated, the MEMO Source Extractor will log on to MEMO by using the memo-ID of the user.
To use the L2 Interface, you must define each user to be migrated as a MEMO/API user and specify their password in the MEMO Source Extractor migration file. The user must not be logged on to MEMO during the migration of their account.

Note
The MEMO API PARMLIB contains the SPLITSIZ field, which holds the value of the maximum memo size. You should set SPLITSIZ to at least the maximum size supported by your MEMO system. A larger document is split into separate documents and remains split after migration.

	To prepare to migrate each group of users
	1.	Modify each user’s profile to specify a MEMO/API user.
	2.	Reset each user’s password to match that specified in the MIGUSER migration file. This will ensure that the user cannot log on during the migration. 
	3.	Set the SPLITSIZ parameter in MEMO/API PARMLIB to the maximum text size supported by MEMO.
Customize the Error Messages
The MEMO Source Extractor lets you customize error messages. The text of all the error messages produced by the MEMO Source Extractor is held on a TSO dataset to allow customization.
After the error messages are customized, you must copy them onto the control file MIGCUST. You start by submitting the MVS batch job MIGCUST, as follows:
Input files			
			
MIGDCUS1	Low values header	Sequential (fixed length)	
MIGDCUS2	Control source file	Sequential (fixed length)	
Output files			
			
MIGCUST	Control file	VSAM	

The dataset MIGDCUS2 in the MEMO Source Extractor JCL library contains a sample set of control records that generate the VSAM error message file MIGCUST. MIGDCUS2 contains groups of three records. Each group defines one error message, formatted as follows :
/M
ID           =nnnn
TEXT01 =Text for message code nnnn   

	/M defines the error message definition.
	ID defines the error message number (nnnn).
	TEXT01 defines the message text for error number (nnnn). 
Only the message text can be customized. The error message definition and number records must not be changed.
	To customize an error message 
	1.	Edit MIGDCUS2 and change the text of a particular TEXT01 record.
	2.	Save MIGDCUS2.
	3.	Submit the JCL job MIGCUST.
The following table lists the error messages that you may write to the job output with the MEMO Source Extractor. 
Number	Message	
		
0100	MIGGENU0100E Invalid mode type	
0101	MIGGENU0101E No records on MIGACCT	
0102	MIGGENU0102E Not all required fields specified in MIGACCT	
0103	MIGGENU0103E Mode field missing from MIGPARM1	
0104	MIGGENU0104E Mode field blank in MIGPARM1	
0105	MIGGENU0105E Primary field missing from MIGPARM1	
0106	MIGGENU0106E Primary field blank in MIGPARM1	
0107	MIGGENU0107E Container field blank in MIGPARM1	
0108	MIGGENU0108E No records on MIGPARM1	
0109	MIGGENU0109W No users found to migrate	
0200	MIGMIGU0200E No records on MIGPARM2	
0201	MIGMIGU0201E Primary field missing from MIGPARM2	
0202	MIGMIGU0202E Primary field blank in MIGPARM2	
0203	MIGMIGU0203E Secondary field missing from MIGPARM2	
0204	MIGMIGU0204E Secondary field blank in MIGPARM2	
0205	MIGMIGU0205E No users on MIGUSER	
0206	MIGMIGU0206E Error calling MEMO/API	
0207	MIGMIGU0207E Error signing user onto MEMO--processing continues onto next user	
0208	MIGMIGU0208W User has more than 10,000 mail items in maillog	
0209	MIGMIGU0209W Mail item has more than 70 recipients	
0210	MIGGENU0210W Mail item is too large	

Figure 2.6	MEMO Source Extractor Error Messages 

Transfer Formatted Messages
You transfer the formatted files produced by the UserList and Migrate Users functions to Microsoft Exchange Server. UserList will create MIGPRIM1 and MIGPACK. Migrate Users will create MIGPRIM2, MIGSEC, and MIGPACK2. Transfer these datasets to a PC on your Microsoft Exchange LAN by using a PC-TSO file transfer program and the Migration Wizard.

Note
The PC-TSO file transfer program must be able to convert message text from EBCDIC to ASCII.

Test the Installation
To test the installation, run both the MIGGENU and MIGMIGU sample JCL jobs. Because you are only testing the installation, not performing migration, the files created should not be downloaded to Microsoft Exchange Server. Check the formatted files produced by the MEMO Source Extractor and make sure that they’re not forwarded to the Microsoft Exchange Server Migration Assistant.
	To test the UserList function MIGGENU
	1.	Submit the job.
	2.	Browse MIGPRIM1 and MIGPACK.
	To test the Migrate Users function MIGMIGU
	1.	Submit the job.
	2.	Browse MIGPRIM2, MIGSEC, and MIGPACK2.
Performing the Migration
This section explains how to migrate users, whether at one time or in multiple steps, and how to run the two primary MEMO Source Extractor functions, UserList and Migrate Users. 
UserList allows you to add groups of MEMO users as either Microsoft Exchange Server mailboxes or remote users. The Migrate Users function allows you to migrate MEMO users to Microsoft Exchange Server.

Important
After migration but before the MEMO maillogs are deleted, you should have the users migrate any important information that was not migrated. The MEMO Source Extractor does not migrate the following information: binary files, personal address information, calendar information, bulletin boards, and distribution lists.

Choose Single-Phase Or Multi-Phase Migration
You must first decide whether to migrate all MEMO users at one time or in multiple steps. Depending on which type of migration you choose, you would use the following procedures, which are explained in more detail in later sections.
	To perform single-phase migration
	1.	Run the UserList program MIGGENU in mailbox creation mode. 
	2.	In MIGACCT, list the users to be extracted.
	3.	Modify all user profiles so that users are registered to use MEMO/API. 
	4.	Run the Migrate Users MIGMIGU program. 
	5.	In MIGUSER, list each user to be migrated. You cannot migrate the mail for all users by using wildcard values. A sample format is:
JH	PASSWORDMEMOIMI	
DLB	PASSWORDMEMOIMI	

	To perform multi-phase migration
	1.	Run the UserList program MIGGENU in the remote address creation mode. 
	2.	Install a connection between MEMO and Microsoft Exchange Server to allow migrated users to communicate with remaining MEMO users. (See the “Connecting MEMO to Microsoft Exchange Server” section later in this chapter.)
	3.	For each group of users to be migrated, do the following: 
		Run the UserList program MIGGENU in the mailbox creation mode. 
		In MIGACCT, list the users to be extracted. Specify users either as individuals or as a group.
		*    , MEMOIMI
		SJG, MEMOIMI
		Modify all user profiles so that users are registered to use MEMO/API.
		Run the Migrate Users MIGMIGU program. 
		In MIGUSER, list the users to be migrated. You cannot migrate mail for all users by using wildcard values. A sample format is:
JH	PASSWORDMEMOIMI	
DLB	PASSWORDMEMOIMI	

Run the UserList Function MIGGENU
You run the UserList function by submitting an MVS batch job MIGGENU, from the MEMO Source Extractor JCL library. This creates output files with the memo-IDs of the users to be migrated. 
Input files			
			
MIGPARM1	Parameter information	Sequential (fixed length)	
MIGUSRL	List of MEMO users	Sequential (variable length)	
MIGACCT	List of users to be generated	Sequential (variable length)	
MIGCUST	Control file	VSAM	
Output files			
			
MIGPRIM1	Migration data to be sent to Microsoft Exchange Server	Sequential (fixed length)	
MIGPACK	Configuration information used by Microsoft Exchange Server	Sequential (fixed length)	

You run UserLists for both mailboxes and remote addresses:
	Mailboxes
You assign mailboxes to MEMO users to be migrated to Microsoft Exchange Server. Each user will have a Microsoft Exchange Server account, created by the Microsoft Exchange Server Migration Assistant.
	Remote Addresses
You assign remote addresses to MEMO users who will remain on MEMO but want to communicate with Microsoft Exchange Server. These remote addresses are registered on Microsoft Exchange Server by the Microsoft Exchange Server Migration Assistant.
To run the UserList function, you must specify profile information in MIGPARM1, and users in MIGACCT.
Specify Profile Information in MIGPARM1
To run the UserList function, you specify profile information in MIGPARM1. MIGPARM1 is specified as instream data in the JCL job MIGGENU. 
You type 10 characters in the fields. The data for the fields can be up to 70 characters. The order of the records does not matter. MIGPARM1 has the following fields:
MODE
Specify M to create mailboxes, or specify R to create remote addresses.
PRIMARY
Specify the PC file name for MIGPRIM1, the extracted information file produced by the MEMO Source Extractor. This name must correspond to the name to be used during the PC-TSO file transfer. For example: primary.pri.
GCID
Specify the Graphic Character Identification (GCID) code-page, which holds the extracted information on the PC. Its standard value will be 850, which is the multilingual code-page. This value should correspond to the code-page to which your PC-TSO file transfer program will convert when converting from EBCDIC to ASCII. For example: gcidcodepage.
Specify Users in MIGACCT
When using the UserList program in either mode, you specify the group of users to be extracted from MEMO in the sequential dataset MIGACCT. The fields on the records are separated by a comma, followed by a space. MIGACCT has the following fields:
DGN
Specify the distribution group name (1 to 8 characters), or  *  for all MEMO users. (Mandatory)
MEMOID 
Specify the name of a user’s mailbox (1 to 8 characters), or  *  for all memo-IDs within a particular DGN. (Mandatory)
The user control file MIGACCT allows you to extract specific users, specific distribution groups, or all MEMO users.
Specific Users
To extract specific users, add a MIGACCT record for each user to be extracted. Each record specifies one MEMO user. For example, if you specify MEMOIMI, KD, MEMOIMI, SJS, and MEMOIMI, SJG, only users KD, SJS, and SJG will be extracted.
Distribution Groups
To extract distribution groups, add a MIGACCT record for each distribution group to be extracted. The MEMOID for each record must be  *. For example, if you specify MEMOIMI, * and MEMMICRO, *  all users for distribution groups MEMOIMI and MEMMICRO will be extracted.
All Users
To extract all MEMO users, add only one MIGACCT record with DGN set to  *. As all users are to be extracted, the value of MEMOID will be ignored by the MEMO Source Extractor. For clarity, you should also set MEMOID to  *.
The MIGACCT dataset will be created as part of the installation process. MIGACCT will contain a sample record that shows how to extract all users. The sample MIGACCT created can be edited by using the TSO editor.
	To run the UserList Function MIGGENU
	1.	Specify the group of users to receive mailboxes or to be created as remote users by editing the TSO dataset MIGACCT and specifying the users to be extracted. (See the preceding “Specify Users in MIGACCT” section.)
	2.	Save MIGACCT.
	3.	Specify the profile information MIGPARM1.
	4.	Edit the TSO dataset MIGGENU in the MEMO Source Extractor JCL library.
	5.	Change the instream MIGPARM1 data as follows:
MODE
Specify M for mailbox, or specify R for remote.
PRIMARY
Specify the name of the PC file used for the extracted information file MIGPRIM1.
GCID
Specify the GCID code-page that will hold the extracted information on the PC.
	6.	Submit the JCL job MIGGENU.
Run the Migrate Users Function MIGMIGU
This process will migrate the lists of MEMO users to Microsoft Exchange Server. The mail messages are processed one at a time. The Migrate Users function examines the MEMO maillog for each user specified. (Only memos are migrated; binary files are ignored.)
You start by submitting the MVS batch job MIGMIGU, from the MEMO Source Extractor JCL library.
Input files			
			
MIGUSER	List of users to be migrated	Sequential (fixed length)	
MIGPARM2	Profile information	Sequential (fixed length)	
MIGUSRV	List of MEMO users	VSAM	
MIGCUST	Control file	VSAM	
Output files			
			
MIGPRIM2	Profile information of migrated memos	Sequential (fixed length)	
MIGSEC	Text of migrated memos on Microsoft Exchange Server	Sequential (fixed length)	
MIGPACK2	Configuration information used by Microsoft Exchange Server	Sequential (fixed length)	

To run the Migrate Users function, you must specify the profile information in MIGPARM2, and the users in MIGUSER.
Specify Profile Information in MIGPARM2
MIGPARM2 is specified as instream data in the JCL job MIGMIGU. You type 10 characters in the fields. The data for the fields can be up to 70 characters. MIGPARM2 has the following fields:
PRIMARY
Specify the PC file name that will be given to MIGPRIM2, which contains the extracted memo header information produced by the MEMO Source Extractor. This name must correspond to the name to be used during the PC-TSO file transfer. For example: primary.pri.
SECONDARY
Specify the PC file name that will be given to MIGSEC, which contains the extracted memo text produced by the MEMO Source Extractor. This name must correspond to the name to be used during the PC-TSO file transfer. For example: secondary.sec
GCID
Specify the Graphic Character Identification (GCID) code-page that will hold the extracted information on the PC. Its standard value will be 850, which is the multilingual code-page. This value should correspond to the code-page to which your PC-TSO file transfer software will convert when converting from EBCDIC to ASCII. For example: gcidcodepage.
Specify Users in MIGUSER
MIGUSER specifies the list of users to be migrated. MIGUSER is specified as instream data in the JCL job MIGMIGU. You cannot migrate mail for all users by using wildcard values for MEMOID and DGN. MIGUSER has the following fields:
MEMOID
Specify the name of the user’s mailbox (8 characters, fixed length). (Mandatory)
PASSWORD
Specify the user’s password (8 characters, fixed length). (Mandatory)
DGN
Specify the distribution group name (8 characters, fixed length). (Mandatory)
SAF-ID
Specify the security ID (8 characters, fixed length). (Optional) If external security is used to validate MEMO users, the SAF-ID field can specify the external security ID.
	To run the Migrate Users function MIGMIGU
	1.	Edit the JCL batch job MIGMIGU, found in the MEMO Source Extractor JCL library. Change the MIGPARM dd-card instream data to specify the primary, secondary, and GCID fields.
	2.	Add a MIGUSER record for each user to be migrated.
	3.	Submit the JCL job MIGMIGU.
Connecting MEMO to Microsoft Exchange Server
There are several ways to connect Verimation MEMO to Microsoft Exchange Server. The MEMO Source Extractor migrates MEMO addresses by using the SNADS format. If you use another type of connection (such as X.400 or SMTP), you need to enter addresses manually. For more information about installation, refer to the appropriate manuals.
Using X.400, connection requires:
	The in-built X.400 MTA of Microsoft Exchange Server.
	Verimation MEMO/Gateway.
	Verimation MEMO/X.400.

If you are connecting MS Mail to SNADS, connection on the mainframe requires:
	An existing gateway between MEMO and MS Mail. (For example, the LinkAge MS Mail/SNADS gateway.)
	The in-built MS Mail Connector of Microsoft Exchange Server.
	Verimation MEMO/Gateway.
	Verimation MEMO/SNADS.

The following sections discuss addressing issues when connecting Microsoft Exchange Server to SNADS, by using the IMI Computing Connect-ME. Using this gateway, connection on the mainframe requires: 
	IMI Computing Connect-ME, installed on any Windows NT Server computer in the Microsoft Exchange Server site.
	Verimation MEMO/Gateway.
	Verimation MEMO/SNADS.

Sending Messages from MEMO to Microsoft Exchange Server
For a MEMO sender to address a Microsoft Exchange Server recipient, you must give the recipient an 8-byte memo-ID (or DEN) and an 8-byte group name (or DGN), which together are known as the SNADS e-mail address. 
Recipients do not have to be registered in MEMO, because MEMO routes by using the SNADS e-mail address. However, the recipient must be registered in the Microsoft Exchange Server directory, with the SNADS e-mail address.
The MEMO sender doesn’t have to be registered in the Microsoft Exchange Server directory to be able to send messages to or receive replies from Microsoft Exchange Client or MS Mail recipients. However, the MEMO sender must be registered in the Microsoft Exchange Server directory in order to receive replies from SMTP or X.400 recipients. 
Sending Messages from Microsoft Exchange Server to MEMO
To send messages to MEMO recipients, users must be registered in the Microsoft Exchange Server directory, with SNADS e-mail addresses. Therefore, when the SNADS gateway is installed, you should assign SNADS e-mail addresses to all users in the Microsoft Exchange Server directory. Also, after the SNADS gateway has been installed, you should automatically assign SNADS e-mail addresses to new users.
The following sections describe additional issues and requirements for Verimation MEMO users to receive messages from the following users:
	Microsoft Exchange Client users.
	MS Mail users connected to Microsoft Exchange Server via the MS Mail connector.
	SMTP (Internet) users or X.400 users connected to Microsoft Exchange Server via an SMTP connector or an X.400 MTA.

Sending Messages From Microsoft Exchange Client to MEMO
Microsoft Exchange Client users can address MEMO recipients in any of the following ways:
	As a one-off, by using the SNADS address template.
	By selecting the MEMO user from the Microsoft Exchange Server directory. The MEMO recipient is entered in the directory during migration, either automatically or manually, or with the use of directory synchronization tools available from vendors.
	By replying to a message from a MEMO user. In this case, the MEMO user doesn’t have to be registered in the Microsoft Exchange Server directory.

Sending Messages From MS Mail to MEMO
You can manually add MS Mail users to the Microsoft Exchange Server directory, or you can use automatic directory exchange between Microsoft Exchange Server and MS Mail.
MS Mail users can address MEMO recipients in any of the following ways:
	As a one-off, by using the SNADS address template in MS Mail, which requires use of the MS Mail SNADS Message Service on the MS Mail user’s postoffice.
	By selecting the MEMO user from the MS Mail Address Book. MEMO recipients can be added to the MS Mail Address Book manually. If the MEMO users are in the Microsoft Exchange Server directory, they can be added to the MS Mail Address Book automatically, through directory exchange between Microsoft Exchange Server and MS Mail. 
	By replying to a message from a MEMO user. In this case, the MEMO user doesn’t have to be registered in the Microsoft Exchange Server directory or the MS Mail Address Book.

Sending Messages From SMTP or X.400 To MEMO
Microsoft Exchange Server does not automatically enter SMTP or X.400 users in the Microsoft Exchange Server directory, so you must add SMTP or X.400 users manually.
Troubleshooting the MEMO Source Extractor
This section explains how to respond to error messages produced by the UserList function, the Migrate Users function, or both functions.
Error message identifications that end with E indicate serious errors for which the MEMO Source Extractor will issue forced abends (S0CB).
Invoking MEMO and MEMO/API programs may also generate error messages. These error messages are documented in the MEMO Reference Manual and the MEMO/API manuals.
UserList Error Messages
This section lists all of the UserList error messages and explains how to resolve them.
MIGGENU0100E  Invalid mode type
MIGGENU0103E  Mode field missing from MIGPARM1
MIGGENU0104E  Mode field blank in MIGPARM1
These error messages indicate invalid or missing entries in the mode field of the MIGPARM1 instream data. In the mode field, you must enter either R for Remote or M for Mailbox. 
	To correct the mode field entry
	1.	Edit MIGGENU in the MEMO Source Extractor JCL library.
	2.	In the MODE field of the MIGPARM1 instream data, specify R or M.
	3.	Submit job MIGGENU.

MIGGENU0105E  Primary field missing from MIGPARM1
MIGGENU0106E  Primary field blank from MIGPARM1
MIGGENU0107E  GCID field missing from MIGPARM1
MIGGENU0108E  GCID field blank from MIGPARM1
MIGGENU0109E  No records on MIGPARM1
These error messages indicate one or more fields in the MIGPARM1 instream data with blank or missing profile information. 
	To add blank or missing profile information
	1.	Edit MIGGENU in the MEMO Source Extractor JCL library.
	2.	Add the missing MIGPARM1 profile information in the mode, primary, or GCID fields, as follows:
	MODE
Specify M (mailbox) or R (remote user).
	PRIMARY
Specify the name of the PC file used for the extracted information file MIGPRIM1 produced by the MEMO Source Extractor. This name must correspond to the name to be used during the PC-TSO file transfer. For example: primary.pri.
	GCID
Specify the Graphic Character Identification (GCID) code-page that will hold the extracted information on the PC. Its standard value will be 850, the multilingual code-page. For example: gcidcodepage.
	3.	Submit job MIGGENU.

MIGGENU0101E  No records on MIGACCT
MIGGENU0102E  Not all required fields specified in MIGACCT
MIGGENU0110E  No users found to migrate 
These error messages indicate a missing or inadequate list of users to be migrated to Microsoft Exchange Server. 
	To add or change a list of users
	1.	Edit MIGACCT in the MEMO Source Extractor library.
	2.	Specify the users to be extracted. (Refer to the “Performing the Migration” section earlier in this chapter.)
	3.	Submit job MIGGENU.

Migrate Users Error Messages
This section lists all of the Migrate Users error messages and explains how to resolve them.
MIGMIGU0200E  No records on MIGPARM2
MIGMIGU0201E  Primary field missing from MIGPARM2
MIGGENU0202E  Primary field blank from MIGPARM2
MIGMIGU0203E  Secondary field missing from MIGPARM2
MIGGENU0204E  Secondary field blank from MIGPARM2
MIGGENU0205E  GCID field missing from MIGPARM2
MIGGENU0206E  GCID field blank from MIGPARM2
These error messages indicate that one or more fields in the MIGPARM2 instream data have missing profile information. 
	To add missing or blank information to fields
	1.	Edit MIGMIGU in the MEMO Source Extractor JCL library.
	2.	In MIGPARM2, add the missing information in the primary, secondary, or GCID fields, as follows:
	PRIMARY
Specify the name of the PC file used for the extracted information file MIGPRIM2 produced by the MEMO Source Extractor. This name must correspond to the name used during the PC-TSO file transfer. For example, primary.pri.
	SECONDARY
Specify the name of the PC file used for the extracted memo text file MIGSEC. This name must correspond to the name used during the PC-TSO file transfer. For example: secondary.sec.
	GCID
Specify the Graphic Character Identification (GCID) code-page that will hold the extracted information on the PC. Its standard value will be 850, which is the multilingual code-page. For example: gcidcodepage.
	3.	Submit job MIGMIGU.

MIGMIGU0207E  No users on MIGUSER
You have not specified which users to migrate to Microsoft Exchange Server.
	To specify which users to migrate
	1.	Edit MIGMIGU in the MEMO Source Extractor JCL library.
	2.	Specify the users to be migrated. (Refer to the “Performing the Migration” section earlier in this chapter.)
	3.	Submit job MIGMIGU.

MIGMIGU0208E  Error calling MEMO/API
An error occurred in MEMO/API. Refer to your MEMO/API manual and look up the return code displayed with this error message.

MIGMIGU0209E  Error signing user onto MEMO--processing continues onto next user
This error message indicates that the MEMO Source Extractor cannot log a MEMO user on to MEMO/API. This can occur for either of these two reasons:
	The MEMO user is not specified as a MEMO/API user.
To correct this problem, modify the user profiles to specify that they are MEMO/API users. (Refer to your MEMO/API manuals.) Then re-run the Migrate Users function for these users.
	The MEMO user is already logged on to MEMO.
To correct this problem, log off the users from MEMO. Then re-run the Migrate Users function for these users.
You avoid these problems if, before migration, you perform all the tasks discussed in the “Installing the MEMO Source Extractor” section, earlier in this chapter. Before migration, you specify users as MEMO/API users and reset user passwords to match MIGUSER passwords (so that users cannot log on during migration).

MIGMIGU0210W  User has more than 10,000 mail items in maillog
A user has more than 10,000 items in their maillog. The MEMO Source Extractor processes only the first 10,000 items. If you need to migrate more than 10,000 items for a particular user, follow these steps:
	To migrate more than 10,000 mail items
	1.	Delete the 10,000 mail items already migrated to Microsoft Exchange Server.
	2.	To migrate an additional 10,000 mail items, re-run the migration process for the user.

MIGMIGU0211W  Mail item has more than 70 recipients
This is a warning message only. The mail item will migrate to Microsoft Exchange Server with only the first 70 recipients.

MIGMIGU0212W  Mail item is too large
This is a warning message only. The mail item is too large to process, so processing will continue with the next mail item. The MEMO Source Extractor supports the maximum text size currently supported by MEMO (500K).

UserList and Migrate Users Error Messages
These error messages are produced by both the UserList and Migrate Users functions.
MIG 9000E  Error on open/close file
MIG 9001E  Error on reading file
MIG 9002E  Error on writing file
Each of these error messages specifies the file with the error and the return code from the I/O call. For example, if an open error occurred on MIGACCT (return code 39) while running the UserList function MIGGENU, the following data would be output to the job log. (Refer to your COBOL II manuals for information about file return codes.)
PROG-ID: MIGGENU COMPILED: 06/08/9411.10.05                      
PROG-ID: MIGERR  COMPILED: 05/26/9415.41.48                      
========MIGGENU ========                                         
MIG    9000E Error On Open/Close File                            
-----------------------------------------------------------------
MIGACCT  39                                                      
DCCCDDE44FF444444444444444444444444444444444444444444444444444444
49736530039000000000000000000000000000000000000000000000000000000000
--- VS COBOL II ABEND Information --- 

MIG 9999E  Message not found on file. See below.
This error message indicates that the error message to be displayed cannot be found in the error message file MIGCUST. This happens if the MEMO Source Extractor error messages were customized incorrectly. You can only customize the text of an error message, not the error message number. 
The error message specifies the error message key, which could not be found. For example:
PROG-ID: MIGGENU COMPILED: 06/08/9411.10.05            
PROG-ID: MIGERR  COMPILED: 05/26/9415.41.48            
MIG 9999E Message not found on file. See below.     
FILE :  CUSTMFIL KEY :  M01000 RC :  23                
========MIGGENU ========                                 
--- VS COBOL II ABEND Information ---                  

	To correct error messages
	1.	Edit MIGDCUS2 and check that all error messages have correct error message numbers as listed in Figure 2.6 in the “Installing the MEMO Source Extractor” section, earlier in this chapter. Change any incorrect error message numbers. 
	2.	Save MIGDCUS2.
	3.	Run JCL job MIGCUST.
MEMO Glossary
Alternate Routing
A mechanism that provides an alternate route in the routing table when connections for a particular destination are unavailable.
Catalog
A dataset with information about all users and their mailboxes.
Default Directing
Default directing involves the use of default tokens, such as an asterisk, to eliminate the need to specify every user or agent in every local directory throughout the network.
Default Routing
Default routing involves the use of default tokens, such as an asterisk, to eliminate the need to specify every DSU in every routing table throughout the network.
Destination
Refers to a recipient of a distribution, either a user or a DSU.
Directing
The process of resolving a recipient name with a mailbox name.
Directory
The directory contains attributes of the user, such as full name, department name, and telephone number.
Distribution
The transport of information to one or more destinations in a Distribution Service (DS) network as a result of a request. Distribution can also be a synonym for data transported by DSUs in honoring such requests.
Distribution Element Name (DEN)
The second part of a Distribution User Name (DUN). The Distribution Element Name (DEN) is unique within its particular Distribution Group Name (DGN).
Distribution Group Name (DGN)
The first part of a Distribution User Name (DUN). The Distribution Group Name (DGN) is unique throughout the DS network. The DGN is a natural grouping of names, with no reference to location.
Distribution Services (DS)
See SNA Distribution Services (SNADS).
Distribution Service Unit (DSU)
The collection of distribution transaction programs and data structures (e.g., queues, routing tables, and the user directory) that provide the distribution service at a particular location in a DS network. The DSU name consists of the Routing Group Name (RGN) and the Routing Element Name (REN), and it identifies specific locations on the DS network. Users are not usually aware of DSU names.
Distribution User Name (DUN)
A MEMO mailbox has a name which corresponds to the SNADS DUN. The DUN consists of  the Distribution Group Name (DGN) and the Distribution Element Name (DEN).
Intermediate DSU
A DSU through which a distribution passes as it travels from the origin DSU to the destination DSU(s). An intermediate DSU receives, routes, and may redirect the distribution before forwarding it.
LU 6.2 Conversation
In SNADS, a logical connection between two transaction programs using an LU 6.2 session. Conversations are delimited by brackets to gain exclusive use of a session.
LU 6.2 Protocol Boundary
The logical interface between LU 6.2 and SNADS, across which information is passed.
Mailbox
A mailbox belongs to a user and displays an index of memos that a user sends and receives.
Memo
A mail message.
Memo database
A dataset of all memos.
MEMO/API
The MEMO Application Programming Interface.
Memo-ID
The name of a user’s mailbox.
Message
The text of a message, the length of which can be from 0 to 500,000 characters.
Profile
A collection of user attributes.
Receive Time
The amount of time required by a DSU to receive a DMU.
Recipient Name
The name of a message recipient.
Route
The path to another system.
Routing Element Name (REN)
The second part of the Distribution Service Unit (DSU) name. The Routing Element Name (REN) must be unique within its particular Routing Group Name (RGN).
Routing Group Name (RGN)
The first part of the Distribution Service Unit (DSU) name.
Routing Table
A table that defines the connection used to forward a distribution to a particular destination at a particular level of service.
Send Time
The amount of time required by a DSU to send a DMU.
SNA Distribution Services (SNADS)
A connectionless communications service that distributes objects over a network of LU6.2 connections.
User Directory
Within a particular DSU, a local table of entries that relates a remote user name to the name of the DSU that receives the user’s distributions.