x400_mtsend.c

/*  Copyright (c) 2003-2013, Isode Limited, London, England.
 *  All rights reserved.
 *                                                                       
 *  Acquisition and use of this software and related materials for any      
 *  purpose requires a written licence agreement from Isode Limited,
 *  or a written licence from an organisation licenced by Isode Limited
 *  to grant such a licence.
 *
 */

/* 
 *
 * @VERSION@
 * Simple example program for transferring a message into the MTA
 */

/* If you want to use raw content, remove the undef.
 * NB you will then need to put some content into <cwd>/p22
 */
#define USE_RAW_CONTENT 1
#undef USE_RAW_CONTENT

#include <stdio.h>
#include <stdlib.h>


#include <x400_mtapi.h>
#include <seclabel_api.h> /* For security labels */
#include "example.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <time.h>


/* local functions */
static int send_msgs(
    int         argc,
    char      **argv
) ;
static int send_msg(
    struct X400mtSession *sp
);
static int add_single_recip(
    struct X400mtMessage *mp
);
static int add_primary_recip(
    struct X400mtMessage *mp
);
static int add_exempt_address(
    struct X400mtMessage *mp
);
static int add_address_list_indicator(
    struct X400mtMessage *mp
);

static int add_handling_instructions(
    struct X400mtMessage *mp
);

#ifdef add_multi_recips
static int add_multi_recips(
    struct X400mtMessage *mp
);
static int add_content_recip_info(
    struct X400Recipient     *rp,
    const char               *free_form_name
);
#endif
static int build_env(
    struct X400mtMessage *mp
);
static int build_content(
    struct X400mtMessage *mp
);
static int add_binary_bp(
    struct X400mtMessage *mp
);
static int add_gen_txt_bp(
    struct X400mtMessage *mp
);
static int add_env_recip_info(
    struct X400Recipient *rp
);
static void usage(void);

static char * set_latest_del_time(void);
static int rno = 1;
static int fwd_rno = 1;

static int load_ber(
    char *filename,
    char **output_buffer,
    int *buf_len
);
#define ADD_FWD_BODYPART 1
#ifdef ADD_FWD_BODYPART
static int add_fwd_bodypart(
    struct X400mtMessage *mp
);

static int build_fwd_env (
    struct X400Message *mp
);

static int build_fwd_content (
    struct X400Message *mp
);

static int add_fwd_recip(
    struct X400Message *mp,
    const char *oraddress,
    int type
);

static int create_fw_message(
    struct X400Message *mp
);

static int add_fwd_content_bodypart (
    struct X400mtMessage *mp
);

static int add_dl_exempted_recip_list (
    struct X400mtMessage *mp
);

#endif


/* These are the data items used */

/* The O/R addresses used are intended to be compatible with those
 * used in the quick install scripts mktailor.tcl, and createmhs.tcl.
 * (createmhs.tcl is used by x400quick).
 * Change this value to the name of your host.  */
#define HOSTNAME "dhcp-165"

/* define USE_P772_EXTS here, if you want to send a message using P772
 * military messaging extensions.
 */
#define USE_P772_EXTS  1
#ifdef USE_P772_EXTS
/* P772 extensions use an external content type */
#define WANT_EXTERNAL_CONTENT_TYPE 1
#endif
static char *optstr = "uG:O:r:g:G:c:l:R:y:C:iaqsAvf:X:S:";

/* this value is used for the originator of the message */
/* static const char orig[] = "/S=x400test-orig/OU="HOSTNAME"/O=GatewayMTA/PRMD=TestPRMD/ADMD=TestADMD/C=GB/"; */
static const char *orig;

static const char *fwd_orig;
static const char *fwd_recip;

static const char orig_ret_addr[] = "/S=x400test-orig/OU="HOSTNAME"/O=GatewayMTA/PRMD=TestPRMD/ADMD=TestADMD/C=GB/";

/* default recipients */
/* static const char recip[] = "/S=x400test-recip/OU="HOSTNAME"/O=GatewayMTA/PRMD=TestPRMD/ADMD=TestADMD/C=GB/"; */
static char *recip;
static char *exemp_recip;

static const char recip2[] = "/S=x400test-recip2/OU="HOSTNAME"/O=GatewayMTA/PRMD=TestPRMD/ADMD=TestADMD/C=GB/";
/* This recip will cause a report to be generated */
static const char badrecip[] = "/S=x400test-recip2/OU=badhost/O=TestOrg/PRMD=TestPRMD/ADMD=TestADMD/C=GB/";
static const char auth_orig[] = "/S=x400test-auth-orig/OU="HOSTNAME"/O=TestOrg/PRMD=TestPRMD/ADMD=TestADMD/C=GB/";

/* envelope recip values */
static const char orar[] = "/S=x400test-orig-orar/OU="HOSTNAME"/O=TestOrg/PRMD=TestPRMD/ADMD=TestADMD/C=GB/";

static const char orardn[] = "CN=alternative,c=gb";

/* default envelope integer values */
#ifdef WANT_EXTERNAL_CONTENT_TYPE
static char *def_ext_content_type = "1.3.26.0.4406.0.4.1";
#endif
static int def_bool = 0;
static int def_priority = 2;

/* default envelope string values */
static const char def_msgid[] = "P772 MessageType identifier";
static const char def_utc[] = "050924120000";
/* Make sure the second part of msg_id (after ";") is less than 32 chars in length */
static const char msg_id[] = "/PRMD=TestPRMD/ADMD=TestADMD/C=GB/;"HOSTNAME".2810401";
static const char content_id[] = "030924.140212";
static const char fwd_msg_id[] = "/PRMD=TestFWDPRMD/ADMD=TestADMD/C=GB/;"HOSTNAME".2810401";


static const char distvalue1[] = { 0x02, 0x01, 0x0a };

static const char distvalue2[] = { 0x13, 0x0a, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a};

static const char corr_octet[] = { 0x02, 0x01, 0x0a };

/* default content integer types */
static const int importance = 2;
static const int sensitivity = 3;
static const int autoforwarded = 1;

/* default content string types */
static const char text[] = "First line\r\nSecond line\r\n";
static const char ipm_id[] = "1064400656.24922*";
static const char ipm_rep_id[] = "1064400656.24923*";
static const char ipm_obs_id[] = "1064400656.24924*";
static const char ipm_rel_id[] = "1064400656.24925*";
static const char orig_ref[] = "orig-ref-val";


#define XML_BUFSIZE 1024
#define STRING_BUFSIZE 1024

int main ( 
    int         argc,
    char      **argv
) 
{
    return send_msgs (argc, argv);
}

static int send_msgs (
    int         argc,
    char      **argv
) 
{
    int status;
    struct X400mtSession *sp;

    if (get_args(argc, argv, optstr)) {
        usage();
        exit(-1);
    }

    orig = strdup(x400_default_gw_originator);
    recip = strdup(x400_default_gw_recipient);
    exemp_recip = strdup(x400_default_exempted_recipient);
    fwd_orig = strdup(x400_default_fwd_originator);
    fwd_recip = strdup(x400_default_fwd_recipient);
        
    if (x400_channel == NULL) {
        fprintf (stderr, "No x400_channel value set in x400tailor file");
        exit(1);
    }

    /* open a new session */
    status = X400mtOpen (x400_channel, &sp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "Error in Open: %s\n", X400mtError (status));
        exit (status);
    }

    /* setup logging from $(ETCDIR)x400api.xml or $(SHAREDIR)x400api.xml */
    X400mtSetStrDefault(sp, X400_S_LOG_CONFIGURATION_FILE, "x400api.xml", 0);

    /* Set the ADatP3 seperator */
    X400mtSetStrDefault(sp, X400_ADATP3_SEP,"\r\n",-1);
    
    /* Turn on error on duplicate string attribute setting */
    X400mtSetIntDefault(sp, X400_N_ERROR_DUPLICATE_ATTRIBUTE, 1);
    
    while (num_msgs_to_send-- > 0)
    {
        status = send_msg(sp);
        if ( status != X400_E_NOERROR ) {
            fprintf (stderr, "Error in send_msg: %s\n", X400mtError (status));
            exit (status);
        }
    }

    /* close the API session */
    return X400mtClose (sp);
}

static int send_msg(
    struct X400mtSession *sp
)
{
    int status;
    struct X400mtMessage *mp;

    /* start preparing a new message */
    status = X400mtMsgNew (sp, X400_MSG_MESSAGE, &mp);
    /* Should report all errors as above */
    if ( status != X400_E_NOERROR ) exit (status);

    /* setup originator using a single string */
    printf("originator of msg is %s\n", orig);
    status = X400mtMsgAddStrParam (mp, X400_S_OR_ADDRESS, orig, -1);
    if ( status != X400_E_NOERROR ) exit (status);

    /* add various envelope and header recipients into the message */
    /* status = add_multi_recips(mp); */
    status = add_single_recip(mp);
    if ( status != X400_E_NOERROR ) exit (status);

    status = add_primary_recip(mp);
    if ( status != X400_E_NOERROR ) exit (status);
    
    /* build rest of the message envelope */
    status = build_env(mp);
    if ( status != X400_E_NOERROR ) exit (status);

    /* build the message content */
    status = build_content(mp);
    if ( status != X400_E_NOERROR ) exit (status);

#ifdef HANDLING_MILITARY_IPN
 /* Add ACP127 Notification response. This is only valid in a Military Notification */
 {
     struct X400ACP127Resp *resp = NULL;
     struct X400ALI *ali1 = NULL;
     struct X400ALI *ali2 = NULL;
     
     /* Create new ACP127 Response object */
     status = X400mtACP127RespNew(mp,&resp);
     if ( status != X400_E_NOERROR ) return (status);     
     
     /* Add Response type */
     status = X400ACP127RespAddIntParam(resp,X400_ACP127_NOTI_TYPE_NEG);
     if ( status != X400_E_NOERROR ) return (status);
     
        
     status = X400ACP127RespAddIntParam(resp,X400_ACP127_NOTI_TYPE_POS);
     if ( status != X400_E_NOERROR ) return (status);

     
     status = X400ACP127RespAddIntParam(resp,X400_ACP127_NOTI_TYPE_TRANS);
     if ( status != X400_E_NOERROR ) return (status);
     
     
     /* Add ACP127 response time*/
     status = X400ACP127RespAddStrParam (resp,
                                         X400_S_ACP127_NOTI_RESP_TIME,
                                         "080101120000+0100",
                                         -1);
     if ( status != X400_E_NOERROR ) return (status); 
     
     
     /* Add ACP127 response recipient*/
     status = X400ACP127RespAddStrParam (resp,
                                         X400_S_ACP127_NOTI_RESP_RECIPIENT,
                                         "ACP127 Recipient",
                                         -1);
     if ( status != X400_E_NOERROR ) return (status); 

     /* Add ACP127 supplimentry info*/
     status = X400ACP127RespAddStrParam (resp,
                                         X400_S_ACP127_NOTI_RESP_SUPP_INFO,
                                         "ACP127 supp info",
                                         -1);
     if ( status != X400_E_NOERROR ) return (status); 
     
     /* Add ACP127 Address List Indicator */
     status = X400ACP127RespNewALI (resp,&ali1);
     if ( status != X400_E_NOERROR ) return (status); 

     status = X400ALIAddIntParam (ali1,X400_N_ALI_TYPE,0);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddIntParam (ali1,X400_N_ALI_NOTIFICATION_REQUEST,0);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddIntParam (ali1,X400_N_ALI_REPLY_REQUEST,1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddStrParam (ali1, X400_S_OR_ADDRESS,
                  "/cn=acp127ali1/PRMD=TestPRMD/ADMD=TestADMD/C=GB", -1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddStrParam (ali1, X400_S_DIRECTORY_NAME,
                                  "cn=acp127ali1,c=gb", -1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddStrParam (ali1, X400_S_FREE_FORM_NAME,
                                  "ACP127 Mr Address List Indicator1", -1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddStrParam (ali1, X400_S_TELEPHONE_NUMBER,"1270123456789",-1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     /*Add a second ACP127 Address List indicator */
     status = X400ACP127RespNewALI (resp,&ali2);
     if ( status != X400_E_NOERROR ) return (status); 
     
     status = X400ALIAddIntParam (ali2,X400_N_ALI_TYPE,1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddIntParam (ali2,X400_N_ALI_NOTIFICATION_REQUEST,1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddIntParam (ali2,X400_N_ALI_REPLY_REQUEST,0);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddStrParam (ali2, X400_S_OR_ADDRESS,
                 "/cn=acp127ali2/PRMD=TestPRMD/ADMD=TestADMD/C=GB", -1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddStrParam (ali2, X400_S_DIRECTORY_NAME,
                                  "cn=acp127ali2,c=gb", -1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddStrParam (ali2, X400_S_FREE_FORM_NAME,
                                  "ACP127 Mr Address List Indicator2", -1);
     if ( status != X400_E_NOERROR ) return  (status);
     
     status = X400ALIAddStrParam (ali2, X400_S_TELEPHONE_NUMBER,"1270123456789",-1);
     if ( status != X400_E_NOERROR ) return  (status);
     
 }
#endif 
    /* send the message */
 status = X400_E_TEMPORARY_ERROR;

 while (status == X400_E_TEMPORARY_ERROR) {
     status = X400mtMsgSend (mp);
     if (status == X400_E_TEMPORARY_ERROR) {
         char foo[100];
         fprintf (stderr, "Temporary error in MsgSend: %s\n", X400mtError (status));
         printf("Press return to try again > ");
         ic_fgets (foo, sizeof foo, stdin);
     } else if ( status != X400_E_NOERROR ) {
         fprintf (stderr, "Error in MsgSend: %s\n", X400mtError (status));
         exit (status);
     }
 }

    /* delete the message structure */
    status = X400mtMsgDelete (mp);
    if ( status != X400_E_NOERROR ) exit (status);

    return status;
}

static int add_primary_recip(
    struct X400mtMessage *mp
)
{
    struct X400Recipient *rp;
    int status;

    printf("Adding primary recip with only FreeForm name\n");
    /* add new recipient to message */
    X400mtRecipNew (mp, X400_RECIP_PRIMARY, &rp);

    status = X400mtRecipAddStrParam (rp, X400_S_FREE_FORM_NAME, "Fred Bloggs", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    return status;
}

static int add_single_recip(
    struct X400mtMessage *mp
)
{
    struct X400Recipient *rp;
    int status;

    printf("Adding single recip %s\n", recip);
    /* add new recipient to message */
    status = X400mtRecipNew (mp, X400_RECIP_STANDARD, &rp);
    if ( status != X400_E_NOERROR ) return  (status);
    /* give recip an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS, recip, -1);
    if ( status != X400_E_NOERROR ) return  (status);
    /* add other values to recip */
    status = add_env_recip_info (rp);
    if ( status != X400_E_NOERROR ) return  (status);

    /* Add an X.411 DL exempted recipient list */
    status = add_dl_exempted_recip_list (mp);
    if ( status != X400_E_NOERROR ) return  (status);
    

#define USE_REDIRECTION_HISTORY 1
#ifdef  USE_REDIRECTION_HISTORY
 {
     struct X400RediHist *hist1; 
     struct X400RediHist *hist2; 

     status = X400RediHistNew(rp,&hist1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,"Failed to allocate new redirection history object \n");
         exit(status);
     }
     
     /* Add Redirection History time */
     status =  X400RediHistAddStrParam (hist1,
                                        X400_S_REDIRECTION_TIME,
                                        "071121125704Z",
                                        -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_REDIRECTION_TIME to Redirection Hist\n");
         exit(status);
     }

     status =  X400RediHistAddStrParam (hist1,
                                        X400_S_OR_ADDRESS,
                                        "/cn=redihist/prmd=TestPRMD/admd=TestPRMD/C=gb",
                                        -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add  X400_S_OR_ADDRESS to Redirection Hist\n");
         exit(status);
     }

     status =  X400RediHistAddStrParam (hist1,
                                        X400_S_DIRECTORY_NAME,
                                        "CN=redihist,c=GB",
                                        -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_DIRECTORY_NAME to Redirection Hist\n");
         exit(status);
     }
     
     
     status = X400RediHistAddIntParam(hist1,
                                      X400_N_REDIRECTION_REASON,
                                      X400_RR_ALIAS);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add  X400_N_REDIRECTION_REASON to trace info\n");
         exit(status);
     }

     /*hist2*/
     
     status = X400RediHistNew(rp,&hist2);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,"Failed to allocate new trace info object \n");
         exit(status);
     }
     
     /* Add Redirection History time */
     status =  X400RediHistAddStrParam (hist2,
                                        X400_S_REDIRECTION_TIME,
                                        "071121125714Z",
                                        -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_REDIRECTION_TIME to Redirection Hist\n");
         exit(status);
     }

     status =  X400RediHistAddStrParam (hist2,
                                        X400_S_OR_ADDRESS,
                                        "/cn=redihist2/prmd=TestPRMD/admd=TestPRMD/C=gb",
                                        -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add  X400_S_OR_ADDRESS to Redirection Hist\n");
         exit(status);
     }

     status =  X400RediHistAddStrParam (hist2,
                                        X400_S_DIRECTORY_NAME,
                                        "CN=redihist2,c=GB",
                                        -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_DIRECTORY_NAME to Redirection Hist\n");
         exit(status);
     }
     
     
     status = X400RediHistAddIntParam(hist2,
                                      X400_N_REDIRECTION_REASON,
                                      X400_RR_RECIP_ASSIGNED_ALT_RECIP);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add  X400_N_REDIRECTION_REASON to "
                 "Redirection Hist\n");
         exit(status);
     }
     
}   
#endif

#ifdef USE_P772_EXTS   
  /* Add ACP 127 Notification types */
 status = X400mtRecipAddIntParam (rp,
                                  X400_N_ACP127_NOTI_TYPE,
                                  X400_ACP127_NOTI_TYPE_NEG);
 if ( status != X400_E_NOERROR ) return (status);

 
 status =  X400mtRecipAddIntParam (rp,
                                   X400_N_ACP127_NOTI_TYPE,
                                   X400_ACP127_NOTI_TYPE_POS);
 if ( status != X400_E_NOERROR ) return (status);

 status =  X400mtRecipAddIntParam (rp,
                                   X400_N_ACP127_NOTI_TYPE,
                                   X400_ACP127_NOTI_TYPE_TRANS);
 if ( status != X400_E_NOERROR ) return (status);

#endif
    
    return X400_E_NOERROR;
}

static int add_exempt_address(
    struct X400mtMessage *mp
)
{
    struct X400Recipient *rp;
    struct X400Recipient *rp2;
    int status;
     printf("Adding exempted recip %s\n", exemp_recip);
    /* add new recipient to message */
    status = X400mtRecipNew (mp, X400_EXEMPTED_ADDRESS, &rp);
    if ( status != X400_E_NOERROR ) return  (status);
    /* give exempted recip an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS,
                                     exemp_recip, -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddStrParam (rp, X400_S_DIRECTORY_NAME,
                                     "cn=exemprecip,c=gb", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddStrParam (rp, X400_S_FREE_FORM_NAME,
                                     "Mr Exempted", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddStrParam (rp, X400_S_TELEPHONE_NUMBER,
                                     "0123456789", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    /* Add second exempted recipient */
    status = X400mtRecipNew (mp, X400_EXEMPTED_ADDRESS, &rp2);
    if ( status != X400_E_NOERROR ) return  (status);
    
    status = X400mtRecipAddStrParam (rp2, X400_S_OR_ADDRESS,
                                     "/CN=exemp2/PRMD=TestPRMD/ADMD=TestADMD/C=GB", -1);
    if ( status != X400_E_NOERROR ) return  (status);
    
    return X400_E_NOERROR;
}
static int add_address_list_indicator(
    struct X400mtMessage *mp
)
{
    struct X400ALI *ali  = NULL;
    struct X400ALI *ali2 = NULL;
    int status;
    
    printf("Adding address list indicators\n");
    
    /* add new Address List Indicator to message */
    status = X400mtALINew (mp,&ali);
    if ( status != X400_E_NOERROR ) return  (status);
    
    status = X400ALIAddIntParam (ali,X400_N_ALI_TYPE,0);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400ALIAddIntParam (ali,X400_N_ALI_NOTIFICATION_REQUEST,0);
    if ( status != X400_E_NOERROR ) return  (status);
    
    status = X400ALIAddIntParam (ali,X400_N_ALI_REPLY_REQUEST,1);
    if ( status != X400_E_NOERROR ) return  (status);
    
    status = X400ALIAddStrParam (ali, X400_S_OR_ADDRESS,
                                     "/cn=ALI1/PRMD=TestPRMD/ADMD=TestADMD/C=GB", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400ALIAddStrParam (ali, X400_S_DIRECTORY_NAME,
                                     "cn=ali1,c=gb", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400ALIAddStrParam (ali, X400_S_FREE_FORM_NAME,
                                     "Mr Address List Indicator1", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400ALIAddStrParam (ali, X400_S_TELEPHONE_NUMBER,"0123456789", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    /* Add second exempted recipient */
    status = X400mtALINew (mp, &ali2);
    if ( status != X400_E_NOERROR ) return  (status);
    
    status = X400ALIAddStrParam (ali2, X400_S_OR_ADDRESS,
                                 "/CN=ALI2/PRMD=TestPRMD/ADMD=TestADMD/C=GB", -1);
    if ( status != X400_E_NOERROR ) return  (status);
    
    status = X400ALIAddIntParam (ali2,X400_N_ALI_TYPE,1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400ALIAddStrParam (ali2, X400_S_DIRECTORY_NAME,
                                     "cn=ali2,c=gb", -1);
    if ( status != X400_E_NOERROR ) return  (status);
    
   
    
    return X400_E_NOERROR;
}

static int add_handling_instructions(
    struct X400mtMessage *mp
)
{
    struct X400PSS *pss  = NULL; /* Printable String Sequence object */
    struct X400PSS *pss2 = NULL;
    int status;
    
    printf("Adding handling instructions\n");
    
    /* add new Address List Indicator to message */
    status = X400mtPSSNew (mp,X400_S_HANDLING_INSTRUCTIONS,&pss);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400PSSAddStrParam (pss,
                                 "Handling instruction1",
                                 -1);
    if ( status != X400_E_NOERROR ) return  (status);


    status = X400mtPSSNew (mp,X400_S_HANDLING_INSTRUCTIONS,&pss2);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400PSSAddStrParam (pss2,
                                 "Handling instruction2",
                                 -1);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    return X400_E_NOERROR;
}

static int add_message_instructions(
    struct X400mtMessage *mp
)
{
    struct X400PSS *pss  = NULL; /* Printable String Sequence object */
    struct X400PSS *pss2 = NULL;
    int status;
    
    printf("Adding Message instructions\n");
    
    /* add new Address List Indicator to message */
    status = X400mtPSSNew (mp,X400_S_MESSAGE_INSTRUCTIONS,&pss);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400PSSAddStrParam (pss,
                                 "Message instruction1",
                                 -1);
    if ( status != X400_E_NOERROR ) return  (status);


    status = X400mtPSSNew (mp,X400_S_MESSAGE_INSTRUCTIONS,&pss2);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400PSSAddStrParam (pss2,
                                 "Message instruction2",
                                 -1);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    return X400_E_NOERROR;
}

static int add_dist_codes_sic(
    struct X400mtMessage *mp
)
{
    struct X400PSS *pss  = NULL; /* Printable String Sequence object */
    struct X400PSS *pss2 = NULL;
    struct X400DistField *distfield1 = NULL;
    struct X400DistField *distfield2 = NULL;
    int status;
    
    printf("Adding Distribution Codes\n");
    
    /* Add new SIC */
    status = X400mtPSSNew (mp,X400_S_DIST_CODES_SIC,&pss);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400PSSAddStrParam (pss,
                                 "dist code 1",
                                 -1);
    if ( status != X400_E_NOERROR ) return  (status);

    /* Add second SIC */
    status = X400mtPSSNew (mp,X400_S_DIST_CODES_SIC,&pss2);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400PSSAddStrParam (pss2,
                                 "dist code 2",
                                 -1);
    if ( status != X400_E_NOERROR ) return  (status);
    
    /* Add new Distribution Extension Field */
    status = X400mtDistFieldNew (mp,&distfield1);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400DistFieldAddStrParam (distfield1,
                                       X400_S_DIST_CODES_EXT_OID,
                                       "1.2.3.4.5",
                                       -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400DistFieldAddStrParam (distfield1,
                                       X400_S_DIST_CODES_EXT_VALUE,
                                       distvalue1, 3);
    if ( status != X400_E_NOERROR ) return  (status);

    /* Add second SIC */
     status = X400mtDistFieldNew (mp,&distfield2);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400DistFieldAddStrParam (distfield2,
                                       X400_S_DIST_CODES_EXT_OID,
                                       "1.2.3.4.5.6",
                                       -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400DistFieldAddStrParam (distfield2,
                                       X400_S_DIST_CODES_EXT_VALUE,
                                       distvalue2, 12);
    if ( status != X400_E_NOERROR ) return  (status);

    
    return X400_E_NOERROR;
}

static int add_other_recipient_indicator(
    struct X400mtMessage *mp
)
{
    struct X400OtherRecip *rp  = NULL; 
    struct X400OtherRecip *rp2 = NULL;
    int status;
    
    printf("Adding Other Recipient Indicators\n");
    
    /* Add new Other recipient */
    status = X400mtOtherRecipNew (mp,&rp);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400OtherRecipAddStrParam (rp,"other recip 1",-1);
    if ( status != X400_E_NOERROR ) return  (status);

    
    status = X400OtherRecipAddIntParam (rp,1);
    if ( status != X400_E_NOERROR ) return  (status);

    
    /* Add second Other recipient */
    status = X400mtOtherRecipNew (mp,&rp2);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    status = X400OtherRecipAddStrParam (rp2,"other recip 2",-1);
    if ( status != X400_E_NOERROR ) return  (status);

    
    status = X400OtherRecipAddIntParam (rp2,0);
    if ( status != X400_E_NOERROR ) return  (status);
    
    
    
    return X400_E_NOERROR;
}
#ifdef add_multi_recips
static int add_multi_recips(
    struct X400mtMessage *mp
)
{
    struct X400Recipient *rp;
    int status;

    printf("Adding multiple recips\n");
    /* add new recipient to message */
    status = X400mtRecipNew (mp, X400_RECIP_STANDARD, &rp);
    if ( status != X400_E_NOERROR ) return  (status);
    /* give recip an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS, recip, -1);
    if ( status != X400_E_NOERROR ) return  (status);
    /* add other values to recip */
    status = add_env_recip_info (rp);
    if ( status != X400_E_NOERROR ) return  (status);

    /* add second recipient to message */
    status = X400mtRecipNew (mp, X400_RECIP_STANDARD, &rp);
    if ( status != X400_E_NOERROR ) exit (status);
    /* give recip an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS, recip2, -1);
    if ( status != X400_E_NOERROR ) return  (status);
    status = X400mtRecipAddIntParam (rp, X400_N_ORIGINAL_RECIPIENT_NUMBER, rno);
    rno++;
    if ( status != X400_E_NOERROR ) return  (status);

    /* add bad recipient to message */
    status = X400mtRecipNew (mp, X400_RECIP_STANDARD, &rp);
    if ( status != X400_E_NOERROR ) exit (status);
    /* give recip an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS, badrecip, -1);
    if ( status != X400_E_NOERROR ) return  (status);
    status = X400mtRecipAddIntParam (rp, X400_N_ORIGINAL_RECIPIENT_NUMBER, rno);
    rno++;
    if ( status != X400_E_NOERROR ) return  (status);

    /* add cc recipient to message */
    status = X400mtRecipNew (mp, X400_RECIP_CC, &rp);
    if ( status != X400_E_NOERROR ) exit (status);
    /* give recip an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS, recip, -1);
    if ( status != X400_E_NOERROR ) return  (status);
    /* add other values to recip */
    status = add_content_recip_info (rp, recip);
    if ( status != X400_E_NOERROR ) return  (status);

    /* add second cc recipient to message */
    status = X400mtRecipNew (mp, X400_RECIP_CC, &rp);
    if ( status != X400_E_NOERROR ) exit (status);
    /* give recip an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS, recip2, -1);
    if ( status != X400_E_NOERROR ) return  (status);
    /* add other values to recip */
    status = add_content_recip_info (rp, recip2);
    if ( status != X400_E_NOERROR ) return  (status);

    /* add bcc recipient to message */
    status = X400mtRecipNew (mp, X400_RECIP_BCC, &rp);
    if ( status != X400_E_NOERROR ) exit (status);
    /* give recip an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS, recip2, -1);
    if ( status != X400_E_NOERROR ) return  (status);

    /* add reply recipient to message */
    status = X400mtRecipNew (mp, X400_RECIP_REPLY, &rp);
    if ( status != X400_E_NOERROR ) exit (status);
    /* give recip an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS, recip2, -1);
    if ( status != X400_E_NOERROR ) return  (status);

    /* add auth user to message */
    status = X400mtRecipNew (mp, X400_AUTH_ORIG, &rp);
    if ( status != X400_E_NOERROR ) return (status);
    /* give auth user an address */
    status = X400mtRecipAddStrParam (rp, X400_S_OR_ADDRESS, auth_orig, -1);
    if ( status != X400_E_NOERROR ) return  (status);

    return X400_E_NOERROR;
}
#endif

static int build_env(
    struct X400mtMessage *mp
)
{
    int status;

    /* Envelope Attributes */

#ifdef WANT_EXTERNAL_CONTENT_TYPE
    status = X400mtMsgAddStrParam (mp, X400_S_EXTERNAL_CONTENT_TYPE, 
                                   def_ext_content_type, -1);
    if ( status != X400_E_NOERROR ) return (status);
#endif
    
#ifdef WANT_DL_EXP_HIST
    /*Add a DL expansion history*/
    {
        struct X400DLExpHist *hist;
        status = X400mtDLExpHistNew (mp, &hist);
        if ( status != X400_E_NOERROR ) return (status);

        status = X400DLExpHistAddStrParam (hist,
                                           X400_S_OR_ADDRESS,
                                           x400_default_gw_dlexphist1_or,
                                           -1);
        if ( status != X400_E_NOERROR ) return  (status);

        status = X400DLExpHistAddStrParam (hist,
                                           X400_S_DIRECTORY_NAME,
                                           x400_default_gw_dlexphist1_dn,
                                           -1);
        if ( status != X400_E_NOERROR ) return  (status);
        
        status = X400DLExpHistAddStrParam (hist,
                                           X400_S_DLEXP_TIME,
                                           "070801120000+0100",
                                           -1);
        if ( status != X400_E_NOERROR ) return  (status);

        
        status = X400mtDLExpHistNew (mp, &hist);
        if ( status != X400_E_NOERROR ) return (status);

        status = X400DLExpHistAddStrParam (hist,
                                           X400_S_OR_ADDRESS,
                                           x400_default_gw_dlexphist2_or,
                                           -1);
        if ( status != X400_E_NOERROR ) return  (status);

        status = X400DLExpHistAddStrParam (hist,
                                           X400_S_DIRECTORY_NAME,
                                           x400_default_gw_dlexphist2_dn,
                                           -1);
        if ( status != X400_E_NOERROR ) return  (status);
        
        status = X400DLExpHistAddStrParam (hist,
                                           X400_S_DLEXP_TIME,
                                           "070801120000+0100",
                                           -1);
        if ( status != X400_E_NOERROR ) return  (status);
        
        
    }
#endif
    

#ifdef USE_SEC_LABEL
    {
        /*If you are going to use security labels,
         *make sure the following variable points to the relevant xml file
         */
        const char* xml_filename = "seclabel.xml";
        char xml_content[XML_BUFSIZE];
        char str_content[STRING_BUFSIZE];
        int str_len = STRING_BUFSIZE;
        FILE *fd = NULL;
        
        /* Read in the security label XML file */
        fd = fopen(xml_filename,"r");
        if(fd == NULL) {
            fprintf(stderr,"Failed to open %s : %s\n",
                    xml_filename,strerror(errno));
        }
        
        fread(&xml_content,XML_BUFSIZE,1,fd);

        fclose(fd);

        status = SecLabelInit("Example program");
        if (status != SECLABEL_E_NOERROR) {
            fprintf(stderr, "SecLabelInit returned error %d\n", status);
            exit(1);
        }
        
        /* Use SecLabelParse to turn the XML into an octet string */
        status = SecLabelParse(xml_content,
                               str_content,
                               STRING_BUFSIZE,
                               &str_len);
        
        if (status != SECLABEL_E_NOERROR) {
            fprintf(stderr, "SecLabelParse returned error %d\n", status);
            exit(1);
        }
            
        /* Add the octet string to the message pointer */
        status = X400mtMsgAddStrParam (mp, X400_S_SECURITY_LABEL,
                                       str_content,str_len);
        if ( status != X400_E_NOERROR ) {
            fprintf (stderr, "x400mtMsgAddStrParam returned error: %s\n", X400mtError (status));
            exit (status);
        }
        
    }
#endif

#define ADD_TRACE_INFO 1
#ifdef ADD_TRACE_INFO
 {
     struct X400TraceInfo *info1; /*Will contain all trace information */
     struct X400TraceInfo *info2; /*Will only contain mandatory trace information*/

     status = X400mtTraceInfoNew(mp,&info1,X400_TRACE_INFO);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,"Failed to allocate new trace info object \n");
         exit(status);
     }
     
     
     status =  X400TraceInfoAddStrParam (info1,
                                         X400_S_GLOBAL_DOMAIN_ID,
                                         "/PRMD=wibble/ADMD=TestADMD/C=GB/",
                                         -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_GLOBAL_DOMAIN_ID to trace info\n");
         exit(status);
     }

     status =  X400TraceInfoAddStrParam (info1,
                                         X400_S_DSI_ARRIVAL_TIME,
                                         "071121125704Z",
                                         -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_DSI_ARRIVAL_TIME to trace info\n");
         exit(status);
     }
     
     /*Add optional*/
     status =  X400TraceInfoAddStrParam (info1,
                                         X400_S_DSI_ATTEMPTED_DOMAIN,
                                         "/PRMD=atmpdom/ADMD=TestADMD/C=GB/",
                                         -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_DSI_ATTEMPTED_DOMAIN to trace info\n");
         exit(status);
     }
     
     
     /*Add optional*/
     status =  X400TraceInfoAddStrParam (info1,
                                         X400_S_DSI_AA_DEF_TIME,
                                         "071122125704Z",
                                         -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_DSI_AA_DEF_TIME to trace info\n");
         exit(status);
     }

     /* Add optional*/
     status =  X400TraceInfoAddStrParam (info1,
                                         X400_S_DSI_AA_CEIT,
                                         "ia5-text",
                                         -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_DSI_AA_CEIT to trace info\n");
         exit(status);
     }
     
     status = X400TraceInfoAddIntParam(info1,
                                       X400_N_DSI_ROUTING_ACTION,
                                       1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_N_DSI_ROUTING_ACTION to trace info\n");
         exit(status);
     }

     status = X400TraceInfoAddIntParam(info1,
                                       X400_N_DSI_AA_REDIRECTED,
                                       1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_N_DSI_AA_REDIRECTED to trace info\n");
         exit(status);
     }

     status = X400TraceInfoAddIntParam(info1,
                                       X400_N_DSI_AA_DLOPERATION,
                                       1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_N_DSI_AA_DLOPERATION to trace info\n");
         exit(status);
     }

     /* Trace 2 */
     
     status = X400mtTraceInfoNew(mp,&info2,X400_TRACE_INFO);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,"Failed to allocate new trace info object \n");
         exit(status);
     }
     
     
     status =  X400TraceInfoAddStrParam (info2,
                                         X400_S_GLOBAL_DOMAIN_ID,
                                         "/PRMD=fluffy/ADMD=TestADMD/C=GB/",
                                         -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_GLOBAL_DOMAIN_ID to trace info\n");
         exit(status);
     }

     status =  X400TraceInfoAddStrParam (info2,
                                         X400_S_DSI_ARRIVAL_TIME,
                                         "071121125704Z",
                                         -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_DSI_ARRIVAL_TIME to trace info\n");
         exit(status);
     }
     
     status = X400TraceInfoAddIntParam(info2,
                                       X400_N_DSI_AA_REDIRECTED,
                                       1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_N_DSI_AA_REDIRECTED to trace info\n");
         exit(status);
     }

     status = X400TraceInfoAddIntParam(info2,
                                       X400_N_DSI_AA_DLOPERATION,
                                       1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_N_DSI_AA_DLOPERATION to trace info\n");
         exit(status);
     }
     
     
 }
#endif

#define USE_INTERNAL_TRACE_INFO 1
#ifdef  USE_INTERNAL_TRACE_INFO
{
    struct X400InternalTraceInfo *int_info1;
    
    status = X400mtInternalTraceInfoNew(mp,&int_info1);
    if (status !=X400_E_NOERROR) {
        fprintf(stderr,"Failed to allocate new trace info object \n");
        exit(status);
    }

    /*GDI*/
    status =  X400InternalTraceInfoAddStrParam (int_info1,
                                                X400_S_GLOBAL_DOMAIN_ID,
                                                "/PRMD=intprmd/ADMD=TestADMD/C=GB/",
                                                -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_GLOBAL_DOMAIN_ID to trace info\n");
         exit(status);
     }
    
    /*MTA Name*/
     status =  X400InternalTraceInfoAddStrParam (int_info1,
                                                 X400_S_MTA_NAME,
                                                 "MTA test MTA1",
                                                -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_MTA_NAME to trace info\n");
         exit(status);
     }
     
    /*MTA Supplied info*/

     status =  X400InternalTraceInfoAddStrParam (int_info1,
                                                 X400_S_MTA_SI_TIME,
                                                 "081121125704Z",
                                                 -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_MTA_SI_TIME to trace info\n");
         exit(status);
     }
     
     /*Routing Action could be X400_MTA_SI_ROUTING_ACTION_RELAYED or
      * X400_MTA_SI_ROUTING_ACTION_REROUTED*/
     status = X400InternalTraceInfoAddIntParam(int_info1,
                                               X400_N_MTA_SI_ROUTING_ACTION,
                                               X400_MTA_SI_RA_MTA);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add  X400_N_MTA_SI_ROUTING_ACTION to trace info\n");
         exit(status);
     }


     status =  X400InternalTraceInfoAddStrParam (int_info1,
                                                 X400_S_MTA_SI_ATTEMPTED_MTA,
                                                 "Attempted MTA name 1",
                                                 -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_MTA_SI_ATTEMPTED_MTA to trace info\n");
         exit(status);
     }

     /*
       You can either set the Attempted MTA or the Attempted Domain, but not
       both*/
     /*
     status =  X400InternalTraceInfoAddStrParam (int_info1,
                                                 X400_S_MTA_SI_ATTEMPTED_DOMAIN,
                                                 "/PRMD=int_attmped_prmd/ADMD=TestADMD/C=GB/",
                                                 -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_MTA_SI_ATTEMPTED_DOMAIN to trace info\n");
         exit(status);
     }

     */
     status =  X400InternalTraceInfoAddStrParam (int_info1,
                                                 X400_S_MTA_SI_DEFERRED_TIME,
                                                 "081121125714Z",
                                                 -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_MTA_SI_DEFERRED_TIME to trace info\n");
         exit(status);
     }
     
     status =  X400InternalTraceInfoAddStrParam (int_info1,
                                                 X400_S_MTA_SI_CEIT,
                                                 "ia5-text",
                                                 -1);
     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_S_MTA_SI_DEFERRED_TIME to trace info\n");
         exit(status);
     }

     status = X400InternalTraceInfoAddIntParam(int_info1,
                                               X400_N_MTA_SI_OTHER_ACTIONS,
                                               X400_MTA_SI_OTHER_ACTION_REDIRECTED);

     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_N_MTA_SI_OTHER_ACTIONS to trace info\n");
         exit(status);
     }
     
     status = X400InternalTraceInfoAddIntParam(int_info1,
                                               X400_N_MTA_SI_OTHER_ACTIONS,
                                               X400_MTA_SI_OTHER_ACTION_DLOPERATION);

     if (status !=X400_E_NOERROR) {
         fprintf(stderr,
                 "Failed to add X400_N_MTA_SI_OTHER_ACTIONS to trace info\n");
         exit(status);
     }


     
}
#endif
 
    /* X400_N_CONTENT_LENGTH is probe only */

    /* Priority: 0 - normal, 1 - non-urgent, 2 - urgent */
    status = X400mtMsgAddIntParam (mp, X400_N_PRIORITY, def_priority);
    if ( status != X400_E_NOERROR ) return (status);

    /*  Disclosure of recipients: 0 - no, 1 - yes */
    status = X400mtMsgAddIntParam (mp, X400_N_DISCLOSURE, 1);
    if ( status != X400_E_NOERROR ) return (status);

    /* Implicit conversion prohibited: 0 - no, 1 - yes */
    status = X400mtMsgAddIntParam (mp, X400_N_IMPLICIT_CONVERSION_PROHIBITED, def_bool);
    if ( status != X400_E_NOERROR ) return (status);

    /* Alternate recipient allowed: 0 - no, 1 - yes */
    status = X400mtMsgAddIntParam (mp, X400_N_ALTERNATE_RECIPIENT_ALLOWED, def_bool);
    if ( status != X400_E_NOERROR ) return (status);

    /* Content return request: 0 - no, 1 - yes */
    status = X400mtMsgAddIntParam (mp, X400_N_CONTENT_RETURN_REQUEST, 1);
    if ( status != X400_E_NOERROR ) return (status);

    /* Recipient reassignment prohibited: 0 - no, 1 - yes */
    status = X400mtMsgAddIntParam (mp, X400_N_RECIPIENT_REASSIGNMENT_PROHIBITED, def_bool);
    if ( status != X400_E_NOERROR ) return (status);

    /* Distribution List expansion prohibited: 0 - no, 1 - yes */
    status = X400mtMsgAddIntParam (mp, X400_N_DL_EXPANSION_PROHIBITED, def_bool);
    if ( status != X400_E_NOERROR ) return (status);

    /* Conversion with loss prohibited: 0 - no, 1 - yes */
    status = X400mtMsgAddIntParam (mp, X400_N_CONVERSION_WITH_LOSS_PROHIBITED, def_bool);
    if ( status != X400_E_NOERROR ) return (status);

    /* string params */

    /* Message Identifier. In RFC 2156 String form */
    status = X400mtMsgAddStrParam (mp, X400_S_MESSAGE_IDENTIFIER, msg_id, -1);
    if ( status != X400_E_NOERROR ) return (status);

    /* Content Identifier */
    status = X400mtMsgAddStrParam (mp, X400_S_CONTENT_IDENTIFIER, content_id, -1);
    if ( status != X400_E_NOERROR ) return (status);

    /* 
     * X400_S_ORIGINAL_ENCODED_INFORMATION_TYPES 
     * X400_S_MESSAGE_SUBMISSION_TIME 
     * X400_S_MESSAGE_DELIVERY_TIME 
     * are read only, so don't add them 
     */
    {
        char *latest_time = set_latest_del_time();
        /*  Latest Delivery Time: UTCTime format YYMMDDHHMMSS<zone> */
        status = X400mtMsgAddStrParam (mp, X400_S_LATEST_DELIVERY_TIME, latest_time, -1);
        free(latest_time);
        if ( status != X400_E_NOERROR ) return (status);
    
    }
    
    /* Originator Return Address (X.400 String format) */
    status = X400mtMsgAddStrParam (mp, X400_S_ORIGINATOR_RETURN_ADDRESS, 
                                   orig_ret_addr, -1);
    if ( status != X400_E_NOERROR ) return (status);

     /* Content Correlator */
#define CC_IA5TEXT
#ifdef CC_IA5TEXT
    status = X400mtMsgAddStrParam (mp, X400_S_CONTENT_CORRELATOR_IA5_STRING, 
                                   "ABCDEFGH", -1);
    if ( status != X400_E_NOERROR ) return (status);
#else
    status = X400mtMsgAddStrParam (mp, X400_S_CONTENT_CORRELATOR_OCTET_STRING, 
                                   corr_octet, 3);
    if ( status != X400_E_NOERROR ) return (status);
#endif
    
    
    /* all OK */
    return X400_E_NOERROR;
}


static int build_content(
    struct X400mtMessage *mp
)
{
    int status;
#ifdef USE_RAW_CONTENT
#ifdef USE_STRING
    int fd;
    char buf[10 * 1024];
    int len;

    fd = open("./p22", O_RDONLY);
    if (fd == -1) {
        printf("Failed to open p22 file in cwd");
        return X400_E_SYSERROR;
    }

    len = read(fd, buf, 10 * 1024);
    close(fd);
    
    if (len == 10 * 1024) {
        printf("p22 file too long to read");
        return X400_E_SYSERROR;
    }

    status = X400mtMsgAddStrParam (mp, X400_S_CONTENT_STRING, buf , len);
    if ( status != X400_E_NOERROR ) return (status);
#else
    status = X400mtMsgAddStrParam (mp, X400_S_CONTENT_FILENAME, "./p22", 5);
    if ( status != X400_E_NOERROR ) return (status);
#endif
#else
    /* content string params */
    status = X400mtMsgAddStrParam (mp, X400_S_IPM_IDENTIFIER, ipm_id, -1);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddStrParam (mp, X400_S_SUBJECT, subject, -1);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddStrParam (mp, X400_S_REPLIED_TO_IDENTIFIER, ipm_rep_id, -1);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddStrParam (mp, X400_S_OBSOLETED_IPMS, ipm_obs_id, -1);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddStrParam (mp, X400_S_RELATED_IPMS, ipm_rel_id, -1);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddStrParam (mp, X400_S_EXPIRY_TIME, def_utc, -1);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddStrParam (mp, X400_S_REPLY_TIME, def_utc, -1);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddStrParam (mp, X400_S_PRECEDENCE_POLICY_ID, "1.3.27.8.0.14", -1);
    if ( status != X400_E_NOERROR ) return (status);

#ifdef X400_1999_SUPPORTED
    /* we don't support these yet */
    status = X400mtMsgAddStrParam (mp, X400_S_AUTHORIZATION_TIME, def_utc, -1);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddStrParam (mp, X400_S_ORIGINATORS_REFERENCE, orig_ref, -1);
    if ( status != X400_E_NOERROR ) return (status);
#endif

    /* content int params */
    status = X400mtMsgAddIntParam (mp, X400_N_IMPORTANCE, importance);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddIntParam (mp, X400_N_SENSITIVITY, sensitivity);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400mtMsgAddIntParam (mp, X400_N_AUTOFORWARDED, autoforwarded);
    if ( status != X400_E_NOERROR ) return (status);

    /* now an IA5 body part */
    status = X400mtMsgAddStrParam (mp, X400_T_IA5TEXT, text, -1);
    if ( status != X400_E_NOERROR ) return (status);

    /* now a binary body part */
    status = add_binary_bp(mp);
    if ( status != X400_E_NOERROR ) return (status);

    /* and general text body part */
    status = add_gen_txt_bp(mp);
    if ( status != X400_E_NOERROR ) return (status);

    
#ifdef ADD_FWD_BODYPART
    /* Now add a forwarded bodypart (So envelope + message)*/
    status = add_fwd_bodypart(mp);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Now add a forwarded content bodypart (so just the message content)
     * This is specified within X.420
     * */
    status = add_fwd_content_bodypart(mp);
    if ( status != X400_E_NOERROR ) return (status);
    
#endif
    
#endif
    
#ifdef USE_P772_EXTS    
    status = add_exempt_address(mp);
    if ( status != X400_E_NOERROR ) exit (status);
    
    /* Add extended Auth Info */
    status = X400mtMsgAddStrParam (mp, X400_S_EXT_AUTH_INFO, 
                                   def_utc, -1);
    if ( status != X400_E_NOERROR ) return (status);

    /* Add Message Coderess */
    status = X400mtMsgAddIntParam (mp, X400_N_EXT_CODRESS, 0);
    if ( status != X400_E_NOERROR ) return (status);

    /* Add P772 Message Type "type" field */
    status = X400mtMsgAddIntParam (mp, X400_N_EXT_MSG_TYPE, 0);
    if ( status != X400_E_NOERROR ) return (status);

    /* Add P772 MessageType "identifier" field*/
    status = X400mtMsgAddStrParam (mp, X400_S_EXT_MSG_IDENTIFIER, 
                                   def_msgid, -1);
    if ( status != X400_E_NOERROR ) return (status);

    /* Add Primary Precedence */
    status = X400mtMsgAddIntParam (mp, X400_N_EXT_PRIM_PREC, 5);
    if ( status != X400_E_NOERROR ) return (status);

    /* Add Copy Precedence */
    status = X400mtMsgAddIntParam (mp, X400_N_EXT_COPY_PREC, 4);
    if ( status != X400_E_NOERROR ) return (status);

    /* Add Address List Indicator */
    status = add_address_list_indicator(mp);
    if ( status != X400_E_NOERROR ) exit (status);

    /* Add Handling instructions */
    status = add_handling_instructions(mp);
    if ( status != X400_E_NOERROR ) exit (status);
    
    /* Add Message instructions */
    status = add_message_instructions(mp);
    if ( status != X400_E_NOERROR ) exit (status);

    /* Add Distribution codes SIC */
    status = add_dist_codes_sic(mp);
    if ( status != X400_E_NOERROR ) exit (status);
    
    /* Add Originator Ref */
    status = X400mtMsgAddStrParam (mp,X400_S_ORIG_REF,"orig_ref", -1);
    if ( status != X400_E_NOERROR ) exit (status);
    
    /* Add Originator PLAD */
    status = X400mtMsgAddStrParam (mp,X400_S_ORIG_PLAD,"orig_plad", -1);
    if ( status != X400_E_NOERROR ) exit (status);

    /* Add Other Recipient Indicator */
    status = add_other_recipient_indicator(mp);
    if ( status != X400_E_NOERROR ) exit (status);

    /* Add ACP127 Message identifier */
    status = X400mtMsgAddStrParam (mp,X400_S_ACP127_MSG_ID,"ACP127 msg id", -1);
    if ( status != X400_E_NOERROR ) exit (status);
    
    /* Add Pilot Forwarding information */
    {
        /* This is treated a a binary blob.
         * You need to pass in the correct BER encoded series of bytes.
         * 
         */
        int buf_len = 0;
        char *pilot_ber = NULL;

        if (load_ber("pilot_fwd_info.ber",&pilot_ber,&buf_len) == 0) {
            printf("Adding pilot forwarding info\n");
            status = X400mtMsgAddStrParam (mp,X400_S_PILOT_FWD_INFO,
                                           pilot_ber,buf_len);
            free(pilot_ber);
            if ( status != X400_E_NOERROR ) exit (status);
        } else {
            printf("unable to add pilot forwarding info\n");
            free(pilot_ber);
        }
        
    }

   




    /* Add Information Security Label. (This is the P772 / STANAG 4406 A1.16)
     * */
    {
        /* This is treated a a binary blob.
         * You need to pass in the correct BER encoded series of bytes.
         */
        int buf_len = 0;
        char *sec_label_ber = NULL;

        if (load_ber("info_sec_label.ber",&sec_label_ber,&buf_len) == 0) {
            printf("Adding information security label\n");
            status = X400mtMsgAddStrParam (mp,X400_S_INFO_SEC_LABEL,
                                           sec_label_ber,buf_len);
            free(sec_label_ber);
            if ( status != X400_E_NOERROR ) exit (status);
        } else {
            printf("unable to add information security labels\n");
            free(sec_label_ber);
        }
        
    }

    
    /* Add P772 ADatP3 object */
    {
        struct X400Bodypart *ADatP3 = NULL;
        
        status = X400BodypartNew(X400_T_ADATP3,&ADatP3);
        if (status != X400_E_NOERROR) return status;
        
        status = X400mtMsgAddBodypart(mp,ADatP3);
        if (status != X400_E_NOERROR) return status;
        
        status = X400BodypartAddIntParam(ADatP3,X400_N_ADATP3_PARM,1);
        if (status != X400_E_NOERROR) return status;

        status = X400BodypartAddIntParam(ADatP3,X400_N_ADATP3_CHOICE,0);
        if (status != X400_E_NOERROR) return status;
        
        status = X400BodypartAddStrParam (ADatP3,X400_S_ADATP3_DATA,
                                          "The first ADatP3 Data value",
                                          -1);
        if (status != X400_E_NOERROR) return status;
        
    }
    
    /* Add P772 ADatP3 object with a sequence of IA5Strings */
    {
        struct X400Bodypart *ADatP3 = NULL;
        
        status = X400BodypartNew(X400_T_ADATP3,&ADatP3);
        if (status != X400_E_NOERROR) return status;
        
        status = X400mtMsgAddBodypart(mp,ADatP3);
        if (status != X400_E_NOERROR) return status;
        
        status = X400BodypartAddIntParam(ADatP3,X400_N_ADATP3_PARM,2);
        if (status != X400_E_NOERROR) return status;

        status = X400BodypartAddIntParam(ADatP3,X400_N_ADATP3_CHOICE,1);
        if (status != X400_E_NOERROR) return status;
        
        status = X400BodypartAddStrParam (ADatP3,X400_S_ADATP3_DATA,
                                          "The second ADatP3 Data value\r\n"
                                          "The third ADatP3 Data value\r\n"
                                          "The fourth ADatP3 Data value\r\n",
                                          -1);
        if (status != X400_E_NOERROR) return status;
    }

    /* Add new P772 Corrections bodypart */

    {
        struct X400Bodypart *corrections = NULL;
        
        status = X400BodypartNew(X400_T_CORRECTIONS,&corrections);
        if (status != X400_E_NOERROR) return status;
        
        status = X400mtMsgAddBodypart(mp,corrections);
        if (status != X400_E_NOERROR) return status;

        status = X400BodypartAddIntParam(corrections,X400_N_CORREC_PARM,1);
        if (status != X400_E_NOERROR) return status;

        status = X400BodypartAddStrParam(corrections,
                                         X400_S_CORREC_DATA,
                                         "A simple P772 correction",
                                         -1);
        if (status != X400_E_NOERROR) return status;
            
    }

    /* Add new ACP127Data bodypart */
    {
        struct X400Bodypart *acp127data = NULL;
        
        status = X400BodypartNew(X400_T_ACP127DATA,&acp127data);
        if (status != X400_E_NOERROR) return status;
        
        status = X400mtMsgAddBodypart(mp,acp127data);
        if (status != X400_E_NOERROR) return status;

        status = X400BodypartAddIntParam(acp127data,X400_N_ACP127DATA_PARM,1);
        if (status != X400_E_NOERROR) return status;

        status = X400BodypartAddStrParam(acp127data,
                                         X400_S_ACP127_DATA,
                                         "A simple P772 ACP127 Data IA5Text",
                                         -1);
        if (status != X400_E_NOERROR) return status;
            
    }
    
#ifdef ADD_FWD_BODYPART
    /* Add MM Message bodypart */
    {
        struct X400Message *msg = NULL;
        
        /* We now need to add a message envelope, and the message body
         * to do this, we create a X400Message, and add that as the bodypart
         */

        status = X400MsgNew (X400_MSG_MESSAGE,&msg);
        if ( status != X400_E_NOERROR ) return (status);

        status = create_fw_message(msg);
        if ( status != X400_E_NOERROR ) return (status);

        status = X400MsgAddStrParam (msg, X400_S_EXTERNAL_CONTENT_TYPE, 
                                     def_ext_content_type, (size_t)-1);
        if ( status != X400_E_NOERROR ) return (status);
        
        
        status = X400mtMsgAddMessageBodyWType (mp,msg,X400_T_MM);
        if ( status != X400_E_NOERROR ) return (status);
    }

    /* Add MM Forwarded Encrypted bodypart */
    {
        char *encrypted_data = NULL;
        int encrypted_data_len;
        struct X400Message *msg = NULL;
        
        /* Slightly confusing name here.
         * Since encrypted data just looks like a bunch of random bits,
         * then for simplicity that's what we are really using.
         * (It's not actually ber encoded.)
         */
        if (load_ber("pilot_fwd_info.ber",&encrypted_data,&encrypted_data_len)
            == 1) {
            fprintf(stderr,"Failed to load Fwd Enc data\n");
            free(encrypted_data);
        } else {
        
            /* This is similar to the Forwarded MM message bodypart above
             * A new X400Message object is used to manipulate envelope
             * information. However for the data side of things,
             * an octet string is used.
             */
        
            status = X400MsgNew (X400_MSG_MESSAGE,&msg);
            if ( status != X400_E_NOERROR ) {
                free(encrypted_data);
                return (status);
            }
            
            /* create_fw_message
             * Adds envelope and content information to the message object.
             * We will ignore the content information, and rely on the 
             * contents of X400_S_ENCRYPTED_DATA 
             */
            status = create_fw_message(msg);
            if ( status != X400_E_NOERROR ) {
                free(encrypted_data);
                return (status);
            }
 
            /* NB create_fw_message sets the X400_CONTENT_TYPE to 2
             * IE interpersonal-messaging-1984
             * It's possible to set this to 1 which then means the content
             * type is externally defined
             */
            
            status = X400MsgAddStrParam (msg, X400_S_EXTERNAL_CONTENT_TYPE, 
                                         def_ext_content_type, (size_t)-1);
            if ( status != X400_E_NOERROR ) {
                free(encrypted_data);
                return (status);
            }
            
            
            status = X400MsgAddStrParam (msg, X400_S_ENCRYPTED_DATA_BYTES_ONLY, 
                                         encrypted_data, encrypted_data_len);
            free(encrypted_data);
            if ( status != X400_E_NOERROR ) return (status);
            
            status = X400mtMsgAddMessageBodyWType (mp,msg,X400_T_FWDENC);
            if ( status != X400_E_NOERROR ) return (status);
        }
    }

    
#endif
    
#endif

    /* Add originators certificate */
     {
         /* This is treated a a binary blob.
          * You need to pass in the correct BER encoded series of bytes.
          * 
          */
         int buf_len = 0;
         char *cert_ber = NULL;

        if (load_ber("1137492922.p12",&cert_ber,&buf_len) == 0) {
            printf("Adding sample originator cert\n");
            status = X400mtMsgAddStrParam (mp,X400_S_ORIG_CERT,
                                           cert_ber,buf_len);
            free(cert_ber);
            if ( status != X400_E_NOERROR ) exit (status);
        } else {
            printf("unable to add originator certificate\n");
            free(cert_ber);
        }
        
    }

     /* Add MOAC */
     {
         /* This is treated a a binary blob.
          * You need to pass in the correct BER encoded series of bytes.
          */
         int buf_len = 0;
         char *moac_ber = NULL;

        if (load_ber("MOAC.ber",&moac_ber,&buf_len) == 0) {
            printf("Adding MOAC\n");
            status = X400mtMsgAddStrParam (mp,X400_S_MOAC,
                                           moac_ber,buf_len);
            free(moac_ber);
            if ( status != X400_E_NOERROR ) exit (status);
        } else {
            printf("unable to add originator certificate\n");
            free(moac_ber);
        }
        
    }

     
    return X400_E_NOERROR;
}


static int add_gen_txt_bp(
    struct X400mtMessage *mp
)
{
    int status;
    struct X400Bodypart *GenTxt = NULL;

    /* Create empty bodypart object */
    status = X400BodypartNew(X400_T_GENERAL_TEXT, &GenTxt);
    if (status != X400_E_NOERROR) return status;

    /* Add bodypart to message */
    status = X400mtMsgAddBodypart(mp, GenTxt);
    if (status != X400_E_NOERROR) return status;

    /* Configure parameters for bodypart - indicates iso-8859-0 charset */
    status = X400BodypartAddStrParam (GenTxt,
                                      X400_S_GENERAL_TEXT_CHARSETS,
                                      "1 6 100",
                                      -1);

    /* Add data to bodypart */
    status = X400BodypartAddStrParam (GenTxt,
                                      X400_S_BODY_DATA,
                                      "This is some General Text data",
                                      -1);
    return status;
}

static int add_binary_bp(
    struct X400mtMessage *mp
)
{
    FILE *fp = NULL;
    int fs=0;
    char *binary_data;
    int status;

    /*  or a Binary body part using the bodypart func */
    if (filename_to_send != NULL) {
        fp = fopen(filename_to_send, "rb");
        if (fp == (FILE *)NULL) {
            printf("Cannot open binary file\n");
            return (X400_E_SYSERROR);
        }
        binary_data = (char *) malloc(bin_bp_size);
        if ( binary_data == NULL )
            return X400_E_NOMEMORY;
        if ((fs = fread (binary_data, sizeof(char), 
                bin_bp_size/sizeof(char), fp) ) == -1) {
            printf("Cannot read from binary file\n");
            free (binary_data);
            fclose(fp);
            return (X400_E_SYSERROR);
        }
        fclose(fp);
        if (fs < bin_bp_size) {
            printf("Cannot read %d bytes from binary file (got %d)\n",
                bin_bp_size, fs);
            free (binary_data);
            return (X400_E_SYSERROR);
        }

        status = X400mtMsgAddAttachment (mp, X400_T_BINARY, binary_data, fs);
        free (binary_data);
        if ( status != X400_E_NOERROR ) {
            printf("failed to add X400_T_BINARY BP\n");
            return (status);
        }
    } else {
        printf("no binary file set - not sending X400_T_BINARY\n");
    }
    return X400_E_NOERROR;
}

static int add_env_recip_info(
    struct X400Recipient *rp
)
{
    int status;

    /* add attributes to recipient in envelope */
    status = X400mtRecipAddIntParam (rp, X400_N_RESPONSIBILITY, 1);
    if ( status != X400_E_NOERROR ) return  (status);

    /* NDR only = 1 */
    status = X400mtRecipAddIntParam (rp, X400_N_MTA_REPORT_REQUEST, 1);
    if ( status != X400_E_NOERROR ) return  (status);

    /* none = 0 */
    status = X400mtRecipAddIntParam (rp, X400_N_REPORT_REQUEST, 0);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddIntParam (rp, X400_N_ORIGINAL_RECIPIENT_NUMBER, rno);
    rno++;
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddStrParam (rp, 
        X400_S_ORIGINATOR_REQUESTED_ALTERNATE_RECIPIENT, orar, -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddStrParam (rp, 
        X400_S_ORIGINATOR_REQUESTED_ALTERNATE_RECIPIENT_DN, orardn, -1);
    if ( status != X400_E_NOERROR ) return  (status);

    return X400_E_NOERROR;
}

#ifdef add_multi_recips
static int add_content_recip_info(
    struct X400Recipient     *rp,
    const char               *free_form_name
)
{
    int status;

    /* add attributes to recipient in content */
    status = X400mtRecipAddIntParam (rp, X400_N_NOTIFICATION_REQUEST, 7);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddIntParam (rp, X400_N_REPLY_REQUESTED, 1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddStrParam (rp, 
        X400_S_FREE_FORM_NAME, free_form_name, -1);
    if ( status != X400_E_NOERROR ) return  (status);

    return X400_E_NOERROR;
}
#endif

static void usage(void) {
    printf("usage: %s\n", optstr);
    printf("\t where:\n");
    printf("\t -u : Don't prompt to override defaults \n");
    printf("\t -G : Originator \n");
    printf("\t -O : Originator Return Address \n");
    printf("\t -g : Recipient\n");
    printf("\t -c : X.400 passive channel\n");
    printf("\t -l : Logline\n");
    printf("\t -R : Reports (0 - never, 1 - always, 2 - always NDR \n");
    printf("\t -y : Priority (0 - normal, 1 - non-urgent, 2 - urgent \n");
    printf("\t -C : Content Type (2/22/772/OID) \n");
    printf("\t -i : Implicit conversion prohibited = TRUE \n");
    printf("\t -a : Alternate Recipient Prohibited = TRUE \n");
    printf("\t -q : Content Return Request = TRUE \n");
    printf("\t -s : Disclosure of Recipient = FALSE \n");
    printf("\t -A : Recipient Reassignment Prohibited = FALSE \n");
    printf("\t -v : Conversion with Loss Prohibited = FALSE \n");
    printf("\t -f : Filename to transfer as binary bp\n");
    printf("\t -X : Number of messages to send\n");
    printf("\t -S : Size of binary attachment (requires -f)\n");
    return;
}


char *set_latest_del_time(
    void
)
{
    static char latest_del_time[BUFSIZ];
    time_t now_secs;
    
    time(&now_secs);
    now_secs += 60*60*24*2; /* 2 days in the future */
    
    strftime(latest_del_time,
             BUFSIZ,
             "%y%m%d%H%M%SZ",
             gmtime(&now_secs));
    return strdup(latest_del_time);
}


/* This function is used to load up pre-created BER files
 * E.G P772 Pilot forwarding information*/
static int load_ber(
    char *filename,
    char **output_buffer,
    int *buf_len
)
{
    FILE *fd = NULL;
    

    struct stat stat_info;
    
    if (stat(filename, &stat_info)!=0) {
        fprintf(stderr,"Failed to stat %s : %s\n",
                filename,strerror(errno));
        return 1;
    }
    
    *output_buffer = (char*) malloc (sizeof(char) * stat_info.st_size);
    /* Read in the security label XML file */
    fd = fopen(filename,"r");
    if(fd == NULL) {
        fprintf(stderr,"Failed to open %s : %s\n",
                filename,strerror(errno));
        return 1;
    }
    
    fread(*output_buffer,stat_info.st_size,1,fd);
    
    fclose(fd);
    *buf_len = stat_info.st_size;
    
    return 0;
}

#ifdef ADD_FWD_BODYPART
static int add_fwd_bodypart(
    struct X400mtMessage *mp
)
{
    int status;
    struct X400Message *mbp;
    /* Create an X.400 Message */
    status = X400MsgNew (X400_MSG_MESSAGE,&mbp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr,"add_fwd_bodypart: %s\n",X400mtError(status));
        return status;
    }
    
    status = create_fw_message(mbp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr,"failed to create fwd message\n");
        return status;
    }
    
    /* Append that to the extisting message */
    return X400mtMsgAddMessageBody (mp,mbp);
}

static int build_fwd_env (
    struct X400Message *mp
)
{
    int status;
    /* Build envelope */

    /* 
     * X400_S_ORIGINAL_ENCODED_INFORMATION_TYPES 
     * X400_S_MESSAGE_SUBMISSION_TIME 
     * X400_S_MESSAGE_DELIVERY_TIME
     */

    /* Add X400_S_ORIGINAL_ENCODED_INFORMATION_TYPES */
    status = X400MsgAddStrParam (mp,
                                 X400_S_ORIGINAL_ENCODED_INFORMATION_TYPES,
                                 "ia5-text",
                                 (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);

    status = X400MsgAddStrParam (mp,
                                 X400_S_MESSAGE_SUBMISSION_TIME,
                                 "070801120000+0100",
                                 (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    status = X400MsgAddStrParam (mp,
                                 X400_S_MESSAGE_DELIVERY_TIME,
                                 "070801120000+0100",
                                 (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Priority */
    status = X400MsgAddIntParam (mp, X400_N_PRIORITY, 1);
    if ( status != X400_E_NOERROR ) return (status);

    /* Add recipient disclosure */
    status = X400MsgAddIntParam (mp, X400_N_DISCLOSURE, 0);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add implicit conversion prohibited */
    status = X400MsgAddIntParam (mp,
                                 X400_N_IMPLICIT_CONVERSION_PROHIBITED,
                                 1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add alt recipient allowed */
    status = X400MsgAddIntParam (mp,X400_N_ALTERNATE_RECIPIENT_ALLOWED,1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Content return request */
    status = X400MsgAddIntParam (mp, X400_N_CONTENT_RETURN_REQUEST, 1);
    if ( status != X400_E_NOERROR ) return (status);
    
    
    /* Add Content return request */
    status = X400MsgAddIntParam (mp, X400_N_CONTENT_RETURN_REQUEST, 1);
    if ( status != X400_E_NOERROR ) return (status);

    
    /* Add Recipient reassignment prohibited */
    status = X400MsgAddIntParam (mp,
                                 X400_N_RECIPIENT_REASSIGNMENT_PROHIBITED,0);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Distribution list expansion prohibited */
    status = X400MsgAddIntParam (mp,X400_N_DL_EXPANSION_PROHIBITED,1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Conversion with loss prohibited */
    status = X400MsgAddIntParam (mp,
                                 X400_N_CONVERSION_WITH_LOSS_PROHIBITED,
                                 1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Message Identifier */
    status = X400MsgAddStrParam (mp,
                                 X400_S_MESSAGE_IDENTIFIER,
                                 fwd_msg_id,
                                 (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Content Identifier */
    status = X400MsgAddStrParam (mp,
                                 X400_S_CONTENT_IDENTIFIER, content_id, (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Latest Delivery Time */
    {
        char *latest_time = set_latest_del_time();
        /*  Latest Delivery Time: UTCTime format YYMMDDHHMMSS<zone> */
        status = X400MsgAddStrParam (mp,
                                     X400_S_LATEST_DELIVERY_TIME,
                                     latest_time, (size_t)-1);
        free(latest_time);
        if ( status != X400_E_NOERROR ) return (status);
    }
    return X400_E_NOERROR;
}

static int build_fwd_content (
    struct X400Message *mp
)
{
    int status;
    /* Build content */
    /* Add IPM Identifier */
    status = X400MsgAddStrParam (mp, X400_S_IPM_IDENTIFIER, ipm_id, (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Subject */
    status = X400MsgAddStrParam (mp, X400_S_SUBJECT,"Forwarded test message", (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Replied to identifer */
    status = X400MsgAddStrParam (mp, X400_S_REPLIED_TO_IDENTIFIER, ipm_rel_id, (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Obseleted IPMs */
    status = X400MsgAddStrParam (mp, X400_S_OBSOLETED_IPMS, ipm_obs_id, (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Related IPMs */
    status = X400MsgAddStrParam (mp, X400_S_RELATED_IPMS, ipm_rel_id, (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Expiry times */
    status = X400MsgAddStrParam (mp, X400_S_EXPIRY_TIME, def_utc, (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Reply times */
    status = X400MsgAddStrParam (mp, X400_S_REPLY_TIME, def_utc, (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Importance */
    status = X400MsgAddIntParam (mp, X400_N_IMPORTANCE, importance);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Sensitivity */
    status = X400MsgAddIntParam (mp, X400_N_SENSITIVITY, sensitivity);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add Autoforwarded */
    status = X400MsgAddIntParam (mp, X400_N_AUTOFORWARDED, autoforwarded);
    if ( status != X400_E_NOERROR ) return (status);
    
    /* Add IA5text  */
    status = X400MsgAddStrParam (mp, X400_T_IA5TEXT,
                                 "This is a forwarded test message", (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);
    
    return X400_E_NOERROR;
}

static int add_fwd_recip(
    struct X400Message *mp,
    const char *oraddress,
    int type
)
{
    struct X400Recipient *rp;
    int status;

    status = X400RecipNew (type,&rp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr,"Failed to create new \n");
        return status;
    }
    
    status = X400MsgAddRecip(mp, type, rp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr,"Failed to add fwd recipient\n");
        return status;
    }
        
    status = X400RecipAddStrParam (rp, X400_S_OR_ADDRESS, oraddress, -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400RecipAddIntParam (rp, X400_N_RESPONSIBILITY, 1);
    if ( status != X400_E_NOERROR ) return  (status);
    
    status = X400RecipAddIntParam (rp, X400_N_MTA_REPORT_REQUEST, 1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400RecipAddIntParam (rp, X400_N_REPORT_REQUEST, 0);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400RecipAddIntParam (rp, X400_N_ORIGINAL_RECIPIENT_NUMBER,
                                   fwd_rno);
    fwd_rno++;
    if ( status != X400_E_NOERROR ) return  (status);
    
    return X400_E_NOERROR;
}

static int create_fw_message(
    struct X400Message *mp
)
{
    int status;
    /* Add Originator Address */
    status = X400MsgAddStrParam (mp, X400_S_OR_ADDRESS, fwd_orig, (size_t)-1);
    if ( status != X400_E_NOERROR ) exit (status);
    
    /* Add Recipient Address */
    status = add_fwd_recip(mp,fwd_orig,X400_ORIGINATOR);
    if (status != X400_E_NOERROR) {
        fprintf(stderr,"Failed to added forwarded originator\n");
        return status;
    }
    
    status = add_fwd_recip(mp,fwd_recip,X400_RECIP_STANDARD);
    if (status != X400_E_NOERROR) {
        fprintf(stderr,"Failed to added forwarded originator\n");
        return status;
    }
    
    status = build_fwd_env(mp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr,"Failed to build forwarded message envelope\n");
        return status;
    }
   
    status = build_fwd_content(mp);
    if (status != X400_E_NOERROR){
        fprintf(stderr,"Failed to build forwarded message content\n");
        return status;
    }

   
    /* Add external content type */
    
    return X400_E_NOERROR;
}

static int add_fwd_content_bodypart (
    struct X400mtMessage *mp
)
{
    
    int buf_len = 0;
    char *fwd_content_ber = NULL;
    struct X400Message *mbp;
    int status;
    
/* Create an X.400 Message */
    status = X400MsgNew (X400_MSG_MESSAGE,&mbp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr,"add_fwd_bodypart: %s\n",X400mtError(status));
        return status;
    }
    
    status = create_fw_message(mbp);
    if ( status != X400_E_NOERROR ) return (status);
    
    status = X400MsgAddStrParam (mbp, X400_S_EXTERNAL_CONTENT_TYPE, 
                                 def_ext_content_type, (size_t)-1);
    if ( status != X400_E_NOERROR ) return (status);

    if (load_ber("example_fwd_content.ber",&fwd_content_ber,&buf_len) == 0) {
        printf("Adding forwarded content string\n");

        status = X400MsgAddStrParam (mbp, X400_S_FWD_CONTENT_STRING, 
                                     fwd_content_ber, buf_len);
        free(fwd_content_ber);
        if ( status != X400_E_NOERROR ) exit (status);

        status = X400mtMsgAddMessageBodyWType (mp,mbp,X400_T_FWD_CONTENT);
        if ( status != X400_E_NOERROR ) return (status);
    } else {
        printf("unable to add forwarded content info\n");
        free(fwd_content_ber);
    }

    
    
    return X400_E_NOERROR;
}

#endif



static int add_dl_exempted_recip_list (
    struct X400mtMessage *mp
)
{
    struct X400Recipient *rp1;
    struct X400Recipient *rp2;
    struct X400Recipient *rp3;
    int status;
    
    status = X400mtRecipNew (mp,X400_DL_EXEMPTED_RECIP, &rp1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddStrParam (rp1, X400_S_OR_ADDRESS,
                                     "/cn=x411exempted1/PRMD=TestPRMD/"
                                     "ADMD=TestADMD/C=GB", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipNew (mp,X400_DL_EXEMPTED_RECIP, &rp2);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddStrParam (rp2, X400_S_OR_ADDRESS,
                                     "/cn=x411exempted2/PRMD=TestPRMD/"
                                     "ADMD=TestADMD/C=GB", -1);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipNew (mp,X400_DL_EXEMPTED_RECIP, &rp3);
    if ( status != X400_E_NOERROR ) return  (status);

    status = X400mtRecipAddStrParam (rp3, X400_S_OR_ADDRESS,
                                     "/cn=x411exempted3/PRMD=TestPRMD/"
                                     "ADMD=TestADMD/C=GB", -1);
    if ( status != X400_E_NOERROR ) return  (status);
    
    return X400_E_NOERROR;
}