x400_mssend_msg_tok_sign.c

/*  Copyright (c) 2009-2014, 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 submitting a message via a message store.
 * The security environment is set up so that messages are signed with
 * a per recipient message token.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#ifndef _WIN32
#include <unistd.h>
#endif
#include <fcntl.h>
#include <errno.h>
 
#include <x400_msapi.h>
#include <seclabel_api.h> /* For security labels */
#include "example.h"
#include "ms_example.h"
#include "time.h"
 
/* uncomment this if you want a second recipient.
 * NB as the recipient name is the same, M-Switch 
 * removes the duplicate envelope recips */
/*
#define tworecips 1
*/
 
/* uncomment this to cause the API to generate msg_seq_nums which
 * increment by 1 per message per session */
#define FIRST_SEQ_NUM 2
 
#ifdef FIRST_SEQ_NUM
int seq_num_val_1 = FIRST_SEQ_NUM;
int seq_num_val_2 = FIRST_SEQ_NUM + 100;
#endif
 
/* set this to non zero to cause the IA5 body part to be an attachment */
int send_ia5_as_att = 0;
 
/*
#define ADD_MOAC
*/
 
static char *optstr = "u37m:d:p:w:M:D:P:W:r:o:O:r:g:G:c:l:R:y:C:iaqsAve:x:b:f:Y:S:j:";
 
/* These are the data items used to construct the message for submission */
static char *default_recip = "/CN=P7User1/OU=sales/O=attlee/PRMD=TestPRMD/ADMD=TestADMD/C=GB/";
char *recip;
char *recip2;
static char *content_id = "030924.140212";
static const char text[] = "First line\r\nSecond line\r\n";
 
int adding_sec_label = 1;
 
/* local functions */
 
static void usage(void) ;
static int send_msg(
    int contype, 
    char *orn, 
    char *def_dn, 
    char *pa, 
    char *password);
 
static int submit_msg(
    char *orn, 
    struct X400msSession *sp    /* session object */
);
 
static int setup_default_new_sec_env(
    struct X400msSession *sp, 
    char *identity_filename,
    char *pw
);
 
 
static int setup_default_old_sec_env(
    struct X400msSession *sp, 
    char *id, 
    char *dn, 
    char *pw
);
 
#ifdef notused
static int setup_msg_new_sec_env(
    struct X400msMessage *mp,   /* message object */
    char *identity_filename,
    char *pw
);
 
 
static int setup_msg_old_sec_env(
    struct X400msMessage *mp,   /* message object */
    char *id, 
    char *dn, 
    char *pw
);
 
static int setup_recip_new_sec_env(
    struct X400Recipient *rp,   /* recipient object */
    char *identity_filename,
    char *pw    /* passphrase for private key in pkcs12 file */
);
 
static int setup_recip_old_sec_env(
    struct X400Recipient *rp,   /* recipient object */
    char *id,   /* x509 identity (directory with x509 subdir) */
    char *dn,   /* DN to use as subject of the X.509 identity */
    char *pw    /* passphrase for private key in pkcs12 file */
);
 
#endif
 
 
static int add_sec_label(
    struct X400msMessage *mp    /* message object */
);
 
static int add_recip(
    struct X400msMessage *mp,   /* message object */
    char *recip
);
 
static int add_content(
    struct X400msMessage *mp    /* message object */
);
 
static int add_binary_bp(
    struct X400msMessage *mp
);
 
static int add_ftbp(
    struct X400msMessage *mp
);
 
static int add_ia5_str(
    struct X400msMessage *mp
);
 
/* start here */
int main (
    int         argc,
    char      **argv
) 
{
    char        pa[BUFSIZ];
    char        orn[BUFSIZ];
    char        *def_oraddr;
    char        *def_dn;
    char        *def_pa;
    int         contype;
    int         status;
    char        password[BUFSIZ];
 
    if (get_args(argc, argv, optstr)) {
        usage();
        exit(-1);
    }
 
    printf("Connection type (0 = P7, 1 = P3 submit only, 2 = P3 both directions) [%d]: ", x400_contype);
    contype = ic_fgetc(x400_contype, stdin); 
    if (contype != 10)
        ic_fgetc(x400_contype, stdin);
 
    if ( contype < '0' || '2' < contype )
      contype = x400_contype;
    else 
        contype -= '0';
 
    if (contype == 0) {
        def_oraddr = x400_ms_user_addr;
        def_dn = x400_ms_user_dn;
        def_pa = x400_ms_presentation_address;
    } else {
        def_oraddr = x400_mta_user_addr;
        def_dn = x400_mta_user_dn;
        def_pa = x400_mta_presentation_address;
    }
 
    printf("Your ORAddress [%s] > ", def_oraddr);
    ic_fgets (orn, sizeof orn, stdin);
 
    if ( orn[strlen(orn)-1] == '\n' )
        orn[strlen(orn)-1] = '\0';
        
    if (orn[0] == '\0') 
        strcpy(orn, def_oraddr);
 
    /* Prompt for password; note: reflected. */
    printf ("Password [%s]: ", 
            contype == 0 ? x400_p7_password : x400_p3_password);
    if ( ic_fgets (password, sizeof password, stdin) == NULL )
        exit (1);
 
    if (password[strlen(password)-1] == '\n' )
        password[strlen(password)-1] = '\0';
    if (password[0] == '\0') 
        strcpy(password, contype == 0 ? x400_p7_password : x400_p3_password);
 
    /* Presentation Address */
    printf("Presentation Address [%s] > ", def_pa);
    ic_fgets (pa, sizeof pa, stdin);
 
    if ( pa[strlen(pa)-1] == '\n' )
        pa[strlen(pa)-1] = '\0';
 
    if (pa[0] == '\0') 
        strcpy(pa, def_pa);
 
    printf("sending message using session 1\n");
    if ((status = send_msg(contype, orn, def_dn, pa, password)) 
            != X400_E_NOERROR ) {
        fprintf (stderr, "Error in sending message\n");
        exit (status);
    }
 
#ifdef notdef
    printf("sending message using session 2\n");
    if ((status = send_msg(contype, orn, def_dn, pa, password)) 
            != X400_E_NOERROR ) {
        fprintf (stderr, "Error sending message\n");
        exit (status);
    }
#endif
 
    return (status);
}
 
static int send_msg(
    int contype, 
    char *orn, 
    char *def_dn, 
    char *pa, 
    char *password
)
{
    struct X400msSession *sp;   /* session object */
 
    int         status;
    int         nummsg;
 
 
    /* Open an API session */
    status = X400msOpen (contype, orn, def_dn, password, pa, &nummsg, &sp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "Error in Open: %s\n", X400msError (status));
        fprintf (stderr, "%s %s %s\n", orn, def_dn, pa);
        return (status);
    }
 
    /* setup logging */
    X400msSetStrDefault(sp, X400_S_LOG_CONFIGURATION_FILE, "x400api.xml", 0);
 
    /* Set up the security environment.
     *
     * In R15.0 this need only be the name of a trusted certificate directory.
     *
     * Prior to R15.0, the ID is specified as a pathname, in which the 
     * subdirectory "x509" is expected to contain one or more PKCS12
     * files. The appropriate Digital Identity is determined from the 
     * DN of the subject, and the passphrase is used to decrypt the
     * private key. NB even though we're not going to use our cert,
     * (as we're going to use the cert in the message to check the MOAC
     * we need to do this due to a limitation in the underlying X.509
     * layer. 
     */
 
    if (use_new_sec_env) {
        status = setup_default_new_sec_env(sp, identity_filename, passphrase);
    } else {
        status = setup_default_old_sec_env(sp, security_id, 
            identity_dn, passphrase);
    }
 
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "Can't setup security environment\n");
        return (status);
    }
 
    printf("sending message 1\n");
    status = submit_msg(orn, sp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "Can't submit\n");
        return (status);
    }
 
/*
    printf("sending message 2\n");
    status = submit_msg(orn, sp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "Can't submit\n");
        return (status);
    }
    printf("sending message 3\n");
    status = submit_msg(orn, sp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "Can't submit\n");
        return (status);
    }
*/
    status = X400msClose (sp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "X400msClose returned error: %s\n", X400msError (status));
        return (status);
    }
    return status;
}
 
static int submit_msg(
    char *orn, 
    struct X400msSession *sp    /* session object */
)
{
    struct X400msMessage *mp;   /* message object */
#ifdef tworecips
    struct X400Recipient *rp2;  /* recipient object */
#endif
    char        tmp[BUFSIZ];
    static int msg_num = 0;
    int         status;
 
    msg_num++;
 
    if (x400_default_recipient != NULL)  {
        recip = x400_default_recipient;
        recip2 = x400_default_recipient;
    } else {
        recip = default_recip;
        recip2 = default_recip;
    }
 
    printf("Message recipient [%s]: ", recip);
    ic_fgets (tmp, sizeof tmp, stdin);
 
    if ( tmp[strlen(tmp)-1] == '\n' )
        tmp[strlen(tmp)-1] = '\0';
    if (strlen(tmp) != 0) {
        recip = strdup(tmp);
        recip2 = strdup(tmp);
    }
 
    printf("Subject [%s]: ", subject);
    ic_fgets (tmp, sizeof tmp, stdin);
 
    if ( tmp[strlen(tmp)-1] == '\n' )
        tmp[strlen(tmp)-1] = '\0';
    if (strlen(tmp) != 0)
        subject = strdup(tmp);
 
    printf("\n");
    status = X400msMsgNew (sp, X400_MSG_MESSAGE, &mp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgNew returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
#ifdef use_diff_sec_env_second_msg
    if (msg_num > 1) {
        /* set up a security env for the message - this will be used in 
         * preference to the default security env */
        status = setup_msg_sec_env(mp, "/root", 
            "cn=P7User1,o=Address Book,c=GB", "secret");
        if ( status != X400_E_NOERROR ) {
            fprintf (stderr, "setup_msg_sec_env returned error: %s\n", 
                X400msError (status));
            /* ignore - let's see if the defaults work */
        }
    }
#endif
 
#define S4404_ENCRYPT
#ifdef S4404_ENCRYPT
    /* Instruct the X400msMsgSend() function to generate a
     * an S4406 (PCT) encrypted message.
     * The default attributes will be used unless the attributes are
     * also included in the message eg by calling setup_msg_sec_env() above */
    status = X400msMsgAddIntParam (mp, X400_N_S4406, 1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n",
            X400msError (status));
        return (status);
    } else {
        fprintf (stderr, "encrypting message as S4406 (PCT) \n");
    }
#endif
#ifdef ADD_MOAC
    /* Instruct the X400msMsgSend() function to generate a 
     * MOAC (signature) for
     * the message Instruct the X400msMsgSend() function to generate a MOAC
     * (signature) for the message
     * The default attributes will be used unless the attributes are
     * also included in the message eg by calling setup_msg_sec_env() above */
    status = X400msMsgAddIntParam (mp, X400_B_SEC_GEN_MOAC, 1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    } else {
        fprintf (stderr, "Adding MOAC\n");
    }
#endif
 
 
    /* originator */
    status = X400msMsgAddStrParam (mp, X400_S_OR_ADDRESS, orn, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    status = X400msMsgAddStrParam (mp, X400_S_DIRECTORY_NAME, 
        "CN=originator;c=gb", -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    if (adding_sec_label) {
        status = add_sec_label (mp);
        if ( status != X400_E_NOERROR ) {
            fprintf (stderr, "Failed to add Security Label: %s\n", 
                X400msError (status));
            return (status);
        } else {
            fprintf (stderr, "added Security Label\n"); 
        }
    }
    status = X400msMsgAddStrParam (mp, X400_S_CONTENT_IDENTIFIER, 
            content_id, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /*
    status = X400msMsgAddStrParam (mp, X400_S_SUBJECT, subject, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
*/
 
    /* Priority: X.400 0 - normal, 1 - non-urgent, 2 - urgent */
    /* Military 0 - deferred, 1 - routine, 2 - priority \n"); */
    /*          3 - immediate, 4 - flash, 5 - override \n"); */
    printf("military message priority is %d (%s) \n",
            x400_default_priority,
            get_x400_pty_str_from_4406(x400_default_priority));
    status = X400msMsgAddIntParam (mp, X400_N_PRIORITY, 
            get_x400_pty_from_4406(x400_default_priority));
    if ( status != X400_E_NOERROR ) return (status);
 
    /* Priority qaulifier: 0 - low, 1 - high */
    printf("military message priority qualifer is %d ( 0 - low, 1 - high)\n",
            get_x400_pty_qual_from_4406(x400_default_priority));
    status = X400msMsgAddIntParam (mp, X400_N_MMTS_PRIORITY_QUALIFIER, 
            get_x400_pty_qual_from_4406(x400_default_priority));
    if ( status != X400_E_NOERROR ) return (status);
 
    /* subject */
    {
        time_t t;
        time(&t);
        char tmp_buffer[255];
        // NB strip newline from ctime result
        snprintf(tmp_buffer, 244, "%s '%s' '%.19s'", 
            subject, get_x400_pty_str_from_4406(x400_default_priority), ctime(&t));
        printf("Subject is '%s'\n", tmp_buffer);
        status = X400msMsgAddStrParam (mp, X400_S_SUBJECT, tmp_buffer, -1);
        if ( status != X400_E_NOERROR ) {
            fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
                X400msError (status));
            exit (status);
        }
    }
 
    /* content type */
    //status = X400msMsgAddStrParam (mp, X400_S_EXTERNAL_CONTENT_TYPE, "1.3.26.0.4406.0.4.1", -1);
    status = X400msMsgAddStrParam (mp, X400_S_EXTERNAL_CONTENT_TYPE, "1.2.840.113549.1.9.16.1.6", -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", X400msError (status));
        exit (status);
    }
 
    if (add_recip(mp, recip) != X400_E_NOERROR) {
        fprintf (stderr, "add_recip() returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /*
     * Use this to add a second recip
     *
    if (add_recip(mp, "/G=P7/S=User2/ou=acp127/O=centos64-1/ADMD= /C=GB/") != X400_E_NOERROR) {
        fprintf (stderr, "add_recip() returned error: %s\n", 
            X400msError (status));
        return (status);
    }
    */
 
    if (add_content(mp) != X400_E_NOERROR) {
        fprintf (stderr, "add_content() returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    status = X400msMsgSend (mp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgSend returned error: %s\n", 
            X400msError (status));
        return (status);
    } else {
        printf("Message submitted successfully\n");
    }
 
    status = X400msMsgDelete (mp, 0);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgDelete returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    mp = NULL;
    return (status);
}
 
 
static int add_recip(
    struct X400msMessage *mp,   /* message object */
    char *local_recip
)
{
    int         status;
    struct X400Recipient *rp;   /* recipient object */
 
    /* first recip */
    status = X400msRecipNew (mp, X400_RECIP_STANDARD, &rp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipNew returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /* put precedence extension into primary recipient */
    status = X400msRecipAddIntParam (rp, X400_N_PRECEDENCE, 2);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddIntParam returned error: %s\n",
            X400msError (status));
        return (status);
    }   
 
 
    status = X400msRecipAddStrParam (rp, X400_S_OR_ADDRESS, local_recip, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    status = X400msRecipAddStrParam (rp, X400_S_DIRECTORY_NAME, 
        "CN=recipient;c=gb", -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /* cause a PODR to be added as a recip extension */
    status = X400msRecipAddIntParam (rp, X400_N_PROOF_OF_DEL_REQ, 1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /* cause a Content Integrity Check to be added as a recip extension */
    status = X400msRecipAddIntParam (rp, X400_B_SEC_CONTENT_INTEGRITY_CHECK, 1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "X400msRecipAddIntParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /* Ask for Message Token for this recip */
    fprintf (stderr, "requesting token\n");
    status = X400msRecipAddIntParam (rp, X400_B_SEC_GEN_MESSAGE_TOKEN, 1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
#ifdef FIRST_SEQ_NUM
    /* Add sequence num */
    status = X400msRecipAddIntParam(rp, X400_N_MSGTOK_SEQ_NUM, 
        seq_num_val_1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    } else {
        fprintf (stderr, "Added sequence number %d for token\n", seq_num_val_1);
    }
    seq_num_val_1++;
#endif
 
 
    /* Ask for +ve and -ve delivery reports */
    /* status = X400msRecipAddIntParam (rp, X400_N_REPORT_REQUEST, 2); */
    /* Ask for no +ve and -ve delivery reports */
    status = X400msRecipAddIntParam (rp, X400_N_REPORT_REQUEST, 0);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /* Ask for +ve and -ve read receipts */
    status = X400msRecipAddIntParam (rp, X400_N_NOTIFICATION_REQUEST, 7);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
    return X400_E_NOERROR;
}
 
 
static int setup_default_new_sec_env(
    struct X400msSession *sp, 
    char *idf,
    char *pw
)
{
    int status;
 
    fprintf (stderr, "using new_sec_nv %s\n", idf);
    /* Filename of the Digital Identity (PKCS12 file) 
     * This supersedes the obsolescent X400_S_SEC_IDENTITY,
     * X400_S_SEC_IDENTITY_DN attributes */
    status = X400msSetStrDefault (sp, X400_S_SEC_IDENTITY_FILE, 
            idf, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "X400msSetStrDefault returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /* passphrase used to open the Identity */
    status = X400msSetStrDefault (sp, X400_S_SEC_IDENTITY_PASSPHRASE, pw, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "X400msSetStrDefault returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /* test the sec env */
    status = X400msTestSecurityEnv (sp);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "X400msTestSecurityEnv returned error: %s\n",
            X400msError (status));
        return (status);
    }
 
    return status;
}
 
 
static int setup_default_old_sec_env(
    struct X400msSession *sp, 
    char *id, 
    char *dn, 
    char *pw
)
{
    int status;
 
    fprintf (stderr, "using old_sec_nv\n");
    /* first set a default security identity. This passes in the name of a
     * directory, which contains an x509 subdirectory in which all Identities
     * are held */
    X400msSetStrDefault(sp, X400_S_SEC_IDENTITY, id, -1); 
 
    /* select by DN which Identity is to be used (if there are several) 
     * Currently these must be PKCS12 files */
    status = X400msSetStrDefault (sp, X400_S_SEC_IDENTITY_DN, dn, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "X400msSetStrDefault returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /* passphrase used to open the Identity */
    status = X400msSetStrDefault (sp, X400_S_SEC_IDENTITY_PASSPHRASE, pw, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "X400msSetStrDefault returned error: %s\n", 
            X400msError (status));
        return (status);
    }
    return status;
}
 
#ifdef notused
static int setup_msg_new_sec_env(
    struct X400msMessage *mp,   /* message object */
    char *identity_filename,
    char *pw    /* passphrase for private key in pkcs12 file */
)
{
    int status;
 
    /* Filename of the Digital Identity (PKCS12 file) 
     * This supersedes the obsolescent X400_S_SEC_IDENTITY,
     * X400_S_SEC_IDENTITY_DN attributes */
    status = X400msMsgAddStrParam (mp, X400_S_SEC_IDENTITY_FILE, 
            identity_filename, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "X400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    printf("setting up new message security env %s\n", identity_filename);
 
    /* security additions */
    status = X400msMsgAddStrParam (mp, X400_S_SEC_IDENTITY_PASSPHRASE, pw, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
    return (status);
}
 
static int setup_msg_old_sec_env(
    struct X400msMessage *mp,   /* message object */
    char *id,   /* x509 identity (directory with x509 subdir) */
    char *dn,   /* DN to use as subject of the X.509 identity */
    char *pw    /* passphrase for private key in pkcs12 file */
)
{
    int status;
 
    printf("setting up message security env %s\n", id);
 
    /* overide the default security environment by specifying a new set of
     * attibutes, and put them into the message */
    /* security additions */
    status = X400msMsgAddStrParam (mp, X400_S_SEC_IDENTITY, id, -1); 
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    /* security additions */
    status = X400msMsgAddStrParam (mp, X400_S_SEC_IDENTITY_DN, dn, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    printf("setting up new message security env %s\n", identity_filename);
 
    /* security additions */
    status = X400msMsgAddStrParam (mp, X400_S_SEC_IDENTITY_PASSPHRASE, pw, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
    return (status);
}
 
static int setup_recip_new_sec_env(
    struct X400Recipient *rp,   /* recipient object */
    char *identity_filename,
    char *pw    /* passphrase for private key in pkcs12 file */
)
{
    int status;
 
    printf("setting up recipient security env %s\n", identity_filename);
 
    /* Filename of the Digital Identity (PKCS12 file) 
     * This supersedes the obsolescent X400_S_SEC_IDENTITY,
     * X400_S_SEC_IDENTITY_DN attributes */
    status = X400msRecipAddStrParam (rp, X400_S_SEC_IDENTITY_FILE, 
            identity_filename, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "X400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    status = X400msRecipAddStrParam (rp, 
        X400_S_SEC_IDENTITY_PASSPHRASE, pw, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    return (status);
}
 
 
static int setup_recip_old_sec_env(
    struct X400Recipient *rp,   /* recipient object */
    char *id,   /* x509 identity (directory with x509 subdir) */
    char *dn,   /* DN to use as subject of the X.509 identity */
    char *pw    /* passphrase for private key in pkcs12 file */
)
{
    int status;
 
    printf("setting up recipient security env %s\n", id);
 
    /* overide the default and message security environment 
     * by specifying a new set of attibutes, and put them 
     * into the recipient security attributes */
    status = X400msRecipAddStrParam (rp, X400_S_SEC_IDENTITY, id, -1); 
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    status = X400msRecipAddStrParam (rp, X400_S_SEC_IDENTITY_DN, dn, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    status = X400msRecipAddStrParam (rp, 
        X400_S_SEC_IDENTITY_PASSPHRASE, pw, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msRecipAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
 
    return (status);
}
#endif
 
static int add_sec_label(
    struct X400msMessage *mp    /* message object */
)
{
#define XML_BUFSIZE 1024
#define STRING_BUFSIZE 1024
    
    const char* xml_filename = "seclabel.xml";
    char xml_content[XML_BUFSIZE];
    char str_content[STRING_BUFSIZE];
    int str_len = STRING_BUFSIZE;
    FILE *fd = NULL;
    int status;
   
    /* 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));
        return X400_E_INT_ERROR;
    }
    
    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);
        return(X400_E_INT_ERROR);
    }
    
    /* Use SecLabelParse to turn the XML into an octect string */
    status = SecLabelParse(xml_content,
                           str_content,
                           STRING_BUFSIZE,
                           &str_len);
    
    if (status != SECLABEL_E_NOERROR) {
        fprintf(stderr, "SecLabelParse returned error %d\n", status);
        return(X400_E_INT_ERROR);
    }
        
    /* Add the octect string to the message pointer */
    status = X400msMsgAddStrParam (mp, X400_S_SECURITY_LABEL,
                                   str_content,str_len);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400msMsgAddStrParam returned error: %s\n", 
            X400msError (status));
        return (status);
    }
    return X400_E_NOERROR;
}
 
static int add_content(
    struct X400msMessage *mp    /* message object */
)
{
    FILE        *fp = NULL;
    int         fs = 0;
    int         status;
    char        *binary_data;
 
    /* add some attachments/body parts 
     * Strictly a message simply has a sequence of body parts.
     * However in human terms, it can be useful to treat the Body Parts
     * as  
     * - text, i.e. an IA5 or general text attachment
     * - followed by 0 or more attachments (e.g. documents, images etc)
     *
     * The API allows for either style.
     *
     * Use the AddStrParam() function to add a text attachment
     * Use the X400msMsgAddAttachment() function to add a Body Part
     * Use the X400msMsgAddMessageBodyWType() function to add structured
     * Body Part (e.g. message, FTBP)
     */
 
    status = X400msMsgAddStrParam (mp, X400_T_ISO8859_1, text, -1);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "x400ms returned error: %s\n", X400msError (status));
        return (status);
    }
    printf("Sent 8859 attachment as string:\n%s\n", text);
 
    if (send_ia5_as_att) {
        /* now an IA5 body attachment using the attachment func  */
        status = X400msMsgAddAttachment (mp, X400_T_IA5TEXT, 
            text, strlen(text));
        if ( status != X400_E_NOERROR ) {
           printf("failed to add X400_T_IA5TEXT attachment\n");
           return (status);
        }
        printf("Sent IA5 as first attachment:\n%s\n", text);
    } else {
        /* now an IA5 attachment using the str func  */
        if (num_of_ia5_bytes == 0) {
            status = X400msMsgAddStrParam (mp, X400_T_IA5TEXT, text, -1);
            if ( status != X400_E_NOERROR ){
               printf("failed to add X400_T_IA5TEXT BP\n");
               return (status);
            }
            printf("Sent IA5 as string in message \n%s\n", text);
        } else {
            status = add_ia5_str(mp);
            if ( status != X400_E_NOERROR ) {
                printf("failed to add IA5 str\n");
                return (status);
           }
        } 
    }
 
    /* now an 8859-1 body attachment using the attachment func  */
    status = X400msMsgAddAttachment (mp, X400_T_ISO8859_1, text, strlen(text));
    if ( status != X400_E_NOERROR ) {
       printf("failed to add X400_T_ISO8859_1, attachment\n");
       return (status);
    }
    printf("Sent 8859-1 as attachment:\n%s\n", text);
 
    /*  or a Binary body part using the bodypart func */
    status = add_binary_bp(mp);
    if ( status != X400_E_NOERROR ) {
        printf("failed to add X400_T_BINARY BP\n");
        return (status);
    }
    
    /*  File Transfer Body Part using the bodypart func */
    status = add_ftbp(mp);
    if ( status != X400_E_NOERROR ) {
        printf("failed to add X400_T_BINARY BP\n");
        return (status);
    }
    
    return status;
 
    if (filename_to_send != NULL) {
        binary_data = (char *) malloc(100000);
        if ( binary_data == NULL )
            return X400_E_NOMEMORY;
        fp = fopen(filename_to_send, "r");
        if (fp == (FILE *)NULL) {
            printf("Cannot open binary file\n");
            return (X400_E_SYSERROR);
        }
        if ((fs = fread (binary_data, sizeof(char), 100000/sizeof(char), fp)) 
                == -1) {
            printf("Cannot read from binary file\n");
            return (X400_E_SYSERROR);
        }
        fclose(fp);
 
        status = X400msMsgAddAttachment (mp, X400_T_BINARY, binary_data, fs);
        if ( status != X400_E_NOERROR ) {
            printf("failed to add X400_T_BINARY BP\n");
            return (status);
        }
 
        status = X400msMsgAddStrParam (mp, X400_T_IA5TEXT, text, -1);
        if ( status != X400_E_NOERROR ){
           printf("failed to add X400_T_IA5TEXT BP\n");
           return (status);
        }
        printf("Sent IA5 as string in message \n%s\n", text);
 
        free (binary_data);
 
    } else {
        printf("no binary file set - not sending X400_T_BINARY\n");
    } 
    return status;
}
 
 
static int add_ia5_str(
    struct X400msMessage *mp
)
{
    int         status;
    char *tmp;
    int i;
    char *sample_ia5 = {"Here is some sample text to put into the IA5 attachment."};
 
    if ((tmp = malloc(num_of_ia5_bytes + 1)) == NULL) {
       printf("failed to malloc %d bytes\n", num_of_ia5_bytes); 
       return (X400_E_SYSERROR);
    }
    strcpy(tmp, text);
    for (i = strlen(text) ; i < num_of_ia5_bytes ; i++)
        tmp[i] = sample_ia5[i%strlen(sample_ia5)];
    tmp[i] = '\0';
 
    status = X400msMsgAddStrParam (mp, X400_T_IA5TEXT, tmp, strlen(tmp));
    if ( status != X400_E_NOERROR ) {
       printf("failed to add X400_T_IA5TEXT BP\n");
       return (status);
    }
    printf("Sent %d bytes IA5 as string in message \n%s\n", i, tmp);
    return X400_E_NOERROR;
}
 
 
static int add_binary_bp(
    struct X400msMessage *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 = X400msMsgAddAttachment (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);
        }
        printf("Sent %d bytes as X400_T_BINARY BP\n", fs);
    } else {
        printf("no binary file set - not sending X400_T_BINARY\n");
    }
    return X400_E_NOERROR;
}
 
 
static int add_ftbp(
    struct X400msMessage *mp
)
{
    FILE *fp = NULL;
    int fs=0;
    char *binary_data;
    int status;
    struct X400Bodypart *bp;
 
    /*  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);
        }
 
        X400BodypartNew(X400_T_FTBP, &bp);      
        X400BodypartAddStrParam(bp, X400_S_BODY_DATA, binary_data, fs);
        X400BodypartAddStrParam(bp, X400_S_FTBP_CONTENT_DESCRIPTION, 
                "Test FTBP File", -1);
        /* NB this value should have the filename, but not the full path */
        /* Ad on Windows backslashes must be escaped with a second backslash */
        X400BodypartAddStrParam(bp, X400_S_FTBP_FILENAME, filename_to_send, -1);
        X400BodypartAddStrParam(bp, X400_S_FTBP_CREATION_DATE, 
                "20160801060101.0Z", -1);
        X400BodypartAddStrParam(bp, X400_S_FTBP_MODIFICATION_DATE, 
                "20160801060202.0Z", -1);
        X400BodypartAddIntParam(bp, X400_N_FTBP_OBJECT_SIZE, fs); 
        status = X400msMsgAddBodypart(mp, bp);
        free (binary_data);
 
        if ( status != X400_E_NOERROR ) {
            printf("failed to add X400_T_FTBP BP\n");
            return (status);
        }
        printf("Sent %d bytes as X400_T_FTBP BP\n", fs);
    } else {
        printf("no binary file set - not sending X400_T_FTBP\n");
    }
    return X400_E_NOERROR;
}
 
 
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 -3 : Use P3 connection \n");
    printf("\t -7 : Use P7 connection \n");
    printf("\t -m : OR Address in P7 bind arg \n");
    printf("\t -d : DN in P7 bind arg \n");
    printf("\t -p : Presentation Address of P7 Store \n");
    printf("\t -w : P7 password of P7 user \n");
    printf("\t -M : OR Address in P3 bind arg \n");
    printf("\t -D : DN in P3 bind arg \n");
    printf("\t -P : Presentation Address of P3 server\n");
    printf("\t -W : P3 password of P3 user \n");
    printf("\t -o : Originator \n");
    printf("\t -O : Originator Return Address \n");
    printf("\t -r : Recipient\n");
    printf("\t -l : Logline\n");
    printf("\t -R : Report requests\n");
    printf("\t\t : 0 - none, 1 - non-delivery, 2 - delivery (implies 1)\n");
    printf("\t -y : Military Priority \n");
    printf("\t\t 0 - deferred, 1 - routine, 2 - priority \n");
    printf("\t\t 3 - immediate, 4 - flash, 5 - override \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 -e : Security Environment (dir with x509 subdir): obsolete, use -Y <p12file>\n");
    printf("\t -x : DN of X.509 Digital Identity\n");
    printf("\t -b : Passphrase for private key in PKCS12 file\n");
    printf("\t -f : Filename to transfer as binary bp\n");
    printf("\t -Y : Filename of PKCS12 file containing Digital Identity\n");
    printf("\t -S : Number of bytes to put into Binary BP and FTBP (default 100)\n");
    printf("\t -j : Number of bytes to put into IA5 BP (default 100)\n");
    return;
}