x400_mssend.c

/*
 *  Copyright (c) 2003-2026, 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.
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#ifndef _WIN32
#include <unistd.h>
#endif
#include "example.h"
#include "ms_example.h"
#include "time.h"
 
#include <errno.h>
#include <fcntl.h>
#include <seclabel_api.h> /* For security labels */
#include <x400_msapi.h>
 
static char *optstr = "u371m:d:p:w:M:D:P:W:o:O:r:l:R:y:C:iaqsAvf:kK:B:";
 
/* These are the data items used to construct the message for submission */
static char *default_recip = "/CN=P7User1/O=attlee/PRMD=TestPRMD/ADMD=TestADMD/C=GB/";
char *recip;
static const char text[] = "First line\r\nSecond line\r\n";
static char *binary_data;
 
static char *fwd_subject = "Forwarded message subject";
 
static int add_binary_attachment(struct X400msMessage *mp, char *filename_to_send);
static int add_fwd_bp(struct X400msMessage *mp, char *recip_orn, char *recip_dn);
static int add_ftbp(struct X400msMessage *mp);
static void usage(void);
 
int main(int argc, char **argv) {
    char creds[BUFSIZ];
    char pa[BUFSIZ];
    char orn[BUFSIZ];
    char tmp[BUFSIZ];
    int status;
    struct X400msSession *sp;
    struct X400msMessage *mp;
    struct X400Recipient *rp;
    int contype;
    char *def_oraddr;
    char *def_dn;
    char *def_pa;
 
    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 ((strlen(orn) > 0) && (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(creds, sizeof(creds), stdin) == NULL) {
        exit(1);
    }
 
    if ((strlen(creds) > 0) && (creds[strlen(creds) - 1] == '\n')) {
        creds[strlen(creds) - 1] = '\0';
    }
    if (creds[0] == '\0') {
        strcpy(creds, contype == 0 ? x400_p7_password : x400_p3_password);
    }
 
    // Presentation Address.
    printf("Presentation Address [%s] > ", def_pa);
    ic_fgets(pa, sizeof pa, stdin);
 
    if ((strlen(pa) > 0) && (pa[strlen(pa) - 1] == '\n')) {
        pa[strlen(pa) - 1] = '\0';
    }
 
    if (pa[0] == '\0') {
        strcpy(pa, def_pa);
    }
 
    if (talking_to_marben_ms) {
        X400msSetConfigRequest(0);
    }
 
    /*
    By default (an industry norm) the simple bind response password (mtaPassword) for the MTA is never checked.
    We can force this checking by setting the mtaPassword parameter when building the simple authentication credentials.
    If we tokenise the credentials and the mtaPassword is NULL or empty, we skip the test, and just accept whatever is returned.
    Example 1:
            char* creds = X400msBuildCredentials(0, pass, "MTAPassword", NULL, NULL, NULL, NULL, NULL);
        and passing creds as the credentials argument to X400msOpen() will check if the returned password matches "MTAPassword".
    Example 2:
            char* creds = X400msBuildCredentials(0, pass, NULL, NULL, NULL, NULL, NULL, NULL);
        and passing creds as the credentials argument to X400msOpen(), or just passing the plain pass as the credentials argument to x400_ms_open() will skip the test.
 
    The creds pointer must be freed in both cases.
    */
    // We've got what we need - now open an API session.
    status = X400msOpen(contype, orn, def_dn, creds, pa, NULL, &sp);
 
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "Error in Open: %s\n", X400msError(status));
        exit(status);
    }
 
    if (talking_to_marben_ms) {
        X400msSetIntDefault(sp, X400_N_STRICT_P7_1988, 1);
    }
 
    /* setup logging */
    X400msSetStrDefault(sp, X400_S_LOG_CONFIGURATION_FILE, "x400api.xml", 0);
 
    /* Turn on generation of extended-subject heading extension */
    X400msSetIntDefault(sp, X400_N_USE_EXTENDED_SUBJECT, 1);
 
    /* Turn on error on duplicate string attribute setting */
    X400msSetIntDefault(sp, X400_N_ERROR_DUPLICATE_ATTRIBUTE, 1);
 
    /* Configure the character sets to be used for Teletex syntax fields
       (X400_S_FREE_FORM_NAME, X400_T_TELETEX, X400_S_SUBJECT). If not
       explicitly configured, the default set of 102, 103, 106, 107
       will be assumed. The string below adds Cyrillic (8859-5) into the list. */
    X400msSetStrDefault(sp, X400_S_TELETEX_CHARSETS, "102 103 106 107 144", -1);
 
    /* Configure the character sets to be used for Graphic string syntax fields
       (X400_S_FTBP_APPLICATION_REFERENCE_STR, X400_S_FTBP_CONTENT_DESCRIPTION,
       X400_S_FTBP_FILENAME). If not explicitly configured, a default of 
       character set 6 (US-ASCII) will be assumed. 
       The string below adds Cyrillic (8859-5) into the list. */
    X400msSetStrDefault(sp, X400_S_GRAPHIC_CHARSETS, "6 144", -1);
 
    if (x400_default_recipient != NULL) {
        recip = x400_default_recipient;
    }
    else {
        recip = default_recip;
    }
 
    printf("Message recipient [%s]: ", recip);
    ic_fgets(tmp, sizeof tmp, stdin);
 
    if ((strlen(tmp) > 0) && (tmp[strlen(tmp) - 1] == '\n')) {
        tmp[strlen(tmp) - 1] = '\0';
    }
    if (strlen(tmp) != 0) {
        recip = strdup(tmp);
    }
 
    printf("Subject [%s]: ", subject);
    ic_fgets(tmp, sizeof tmp, stdin);
 
    if ((strlen(tmp) > 0) && (tmp[strlen(tmp) - 1] == '\n')) {
        tmp[strlen(tmp) - 1] = '\0';
    }
    if (strlen(tmp) != 0) {
        subject = strdup(tmp);
    }
 
    status = X400msMsgNew(sp, X400_MSG_MESSAGE, &mp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msMsgNew returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    status = X400msRecipNew(mp, X400_RECIP_STANDARD, &rp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msRecipNew returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    status = X400msRecipAddStrParam(rp, X400_S_OR_ADDRESS, recip, -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msRecipAddStrParam returned error: %s\n", X400msError(status));
        exit(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));
        exit(status);
    }
 
    status = X400msMsgAddStrParam(mp, X400_S_OR_ADDRESS, orn, -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msMsgAddStrParam returned error: %s\n", X400msError(status));
        exit(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));
        exit(status);
    }
 
    /* Ask for delivery reports */
    printf("delivery report request %d ( 1 - No, 2 - Yes)\n", x400_dr_req);
    status = X400msRecipAddIntParam(rp, X400_N_REPORT_REQUEST, x400_dr_req);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msRecipAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    /* Ask for read receipts */
    printf("read notification request %d ( 1 - RN, 2 - NRN, 4 - return of IPM with NRN )\n", x400_rn_req);
    status = X400msRecipAddIntParam(rp, X400_N_NOTIFICATION_REQUEST, x400_rn_req);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msRecipAddIntParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    if (1) {
        char *contid = "ContID00001";
 
        /* Content identifier so we can correlate with submission result */
        status = X400msMsgAddStrParam(mp, X400_S_CONTENT_IDENTIFIER, contid, -1);
        if (status != X400_E_NOERROR) {
            fprintf(stderr, "X400msMsgAddIntParam %d returned error: %s\n", X400_S_CONTENT_IDENTIFIER, X400msError(status));
            exit(status);
        }
    }
 
    /* content return request on report - 0 = no */
    status = X400msMsgAddIntParam(mp, X400_N_CONTENT_RETURN_REQUEST, 0);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400msMsgAddIntParam %d returned error: %s\n", X400_N_CONTENT_RETURN_REQUEST, X400msError(status));
        exit(status);
    }
 
    /* Priority: 0 - normal, 1 - non-urgent, 2 - urgent */
    printf("message priority is %d ( 0 - normal, 1 - non-urgent, 2 - urgent)\n", x400_default_priority);
    status = X400msMsgAddIntParam(mp, X400_N_PRIORITY, x400_default_priority);
    if (status != X400_E_NOERROR) {
        return (status);
    }
 
    /* Priority: 0 - normal, 1 - non-urgent, 2 - urgent */
    printf("military message priority is %d ( 0 - low, 1 - high)\n", x400_default_priority);
    status = X400msMsgAddIntParam(mp, X400_N_MMTS_PRIORITY_QUALIFIER, 1);
    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);
        }
    }
 
    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");
    }
 
    /* content type */
    status = X400msMsgAddStrParam(mp, X400_S_EXTERNAL_CONTENT_TYPE, "1.3.26.0.4406.0.4.1", -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msMsgAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
    /* 8859-1 attachment */
    status = X400msMsgAddStrParam(mp, X400_T_ISO8859_1, text, -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400ms returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    /* now an IA5 body part using the bodypart func  */
    status = X400msMsgAddAttachment(mp, X400_T_IA5TEXT, text, strlen(text));
    if (status != X400_E_NOERROR) {
        printf("failed to add X400_T_IA5TEXT BP\n");
        return (status);
    }
 
    /*  or a Binary body part using the bodypart func */
    if (filename_to_send != NULL) {
        status = add_binary_attachment(mp, filename_to_send);
        if (status != X400_E_NOERROR) {
            printf("failed to add X400_T_BINARY BP\n");
            return (status);
        }
        status = add_fwd_bp(mp, orn, def_dn);
        if (status != X400_E_NOERROR) {
            printf("failed to add forwarded BP\n");
            return (status);
        }
    }
    else {
        printf("no binary file set - not sending X400_T_BINARY\n");
        printf("no binary file set - not sending forwarded BP\n");
    }
 
    /*  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);
    }
 
#ifdef USE_SEC_LABEL
    {
#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;
 
        /* 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 = X400msMsgAddStrParam(mp, X400_S_SECURITY_LABEL, str_content, str_len);
        if (status != X400_E_NOERROR) {
            fprintf(stderr, "x400msMsgAddStrParam returned error: %s\n", X400msError(status));
            exit(status);
        }
    }
#endif
 
    status = X400msMsgSend(mp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msMsgSend returned error: %s\n", X400msError(status));
 
        if (status == X400_E_RECIPIENT_ERROR) {
            int n = 1;
            struct X400Recipient *irp;
            int ss = X400_E_NOERROR;
 
            while (ss == X400_E_NOERROR) {
                ss = X400msRecipGet(mp, X400_RECIP_INVALID, n, &irp);
                if (ss == X400_E_NOERROR) {
                    char buf[1024];
                    size_t retlen;
                    int s;
 
                    fprintf(stderr, "A recipient with ");
 
                    s = X400msRecipGetStrParam(irp, X400_S_OR_ADDRESS, buf, 1024, &retlen);
                    if (s == X400_E_NOERROR) {
                        buf[retlen] = '\0';
                        fprintf(stderr, "ORAddress %s ", buf);
                    }
 
                    s = X400msRecipGetStrParam(irp, X400_S_DIRECTORY_NAME, buf, 1024, &retlen);
                    if (s == X400_E_NOERROR) {
                        buf[retlen] = '\0';
                        fprintf(stderr, " and DN %s", buf);
                    }
                    fprintf(stderr, " was rejected\n");
                    n++;
                }
            }
        }
    }
    else {
        char buf[1024];
        size_t retlen;
        char *databuf = buf;
 
        printf("Message submitted successfully\n");
 
        status = X400msMsgGetStrParam(mp, X400_S_MESSAGE_IDENTIFIER, buf, 1024, &retlen);
        if (status != X400_E_NOERROR) {
            fprintf(stderr, "No MessageId present from submission result: error %d\n", status);
        }
        else {
            buf[retlen] = '\0';
            printf("MessageId from Submission Result = %s\n", buf);
        }
 
        status = X400msMsgGetStrParam(mp, X400_S_MESSAGE_SUBMISSION_TIME, buf, 1024, &retlen);
        if (status != X400_E_NOERROR) {
            fprintf(stderr, "No MessageSubmissionTime present from submission result: error %d\n", status);
        }
        else {
            buf[retlen] = '\0';
            printf("MessageSubmissionTime from Submission Result = %s\n", buf);
        }
 
        status = X400msMsgGetStrParam(mp, X400_S_CONTENT_IDENTIFIER, buf, 1024, &retlen);
        if (status != X400_E_NOERROR) {
            fprintf(stderr, "No ContentIdentifier present from submission result: error %d\n", status);
        }
        else {
            buf[retlen] = '\0';
            printf("ContentIdentifier from Submission Result = %s\n", buf);
        }
 
        /* Get binary representation and store to file */
 
        /* First pass to find out how big it needs to be */
        status = X400msMsgGetRaw(sp, mp, databuf, 0, &retlen);
        if (status != X400_E_NOSPACE) {
            fprintf(stderr, "Failed to get raw message length: error %d\n", status);
        }
        else {
            struct X400msMessage *newmsg;
            int newtype;
 
            databuf = (char *)malloc(retlen);
            printf("Data buffer length required = %d\n", (int)retlen);
            status = X400msMsgGetRaw(sp, mp, databuf, retlen, &retlen);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "Failed to get raw message: error %d\n", status);
            }
            else {
                /* Dump to file */
                FILE *fd = fopen("message.dump", "w");
                if (fd == NULL) {
                    fprintf(stderr, "Failed to open file message.dump\n");
                }
                else {
                    if (fwrite(databuf, 1, retlen, fd) < retlen) {
                        fprintf(stderr, "Failed to write message to file message.dump\n");
                    }
                    else {
                        fprintf(stdout, "Dumped message to file message.dump\n");
                    }
                    fclose(fd);
                }
            }
 
            /* And try to reconstruct message from bytes */
            status = X400msMsgFromRaw(sp, databuf, retlen, &newmsg, &newtype);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "Failed to create message from bytes: error %d\n", status);
            }
 
            free(databuf);
        }
    }
 
    status = X400msMsgDelete(mp, 0);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msMsgDelete returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    mp = NULL;
    rp = NULL;
 
    status = X400msClose(sp);
    exit(status);
    /* NOTREACHED */
}
 
static int add_binary_attachment(struct X400msMessage *mp, char *filename) {
    int fd;
    int file_size;
    struct stat buf;
    int fs = 0;
    int status;
 
    printf("sending file %s\n", filename);
    if ((fd = open(filename_to_send, O_RDONLY)) == -1) {
        printf("Failed to open content file %s: ", filename);
        return X400_E_BADPARAM;
    }
 
    if (fstat(fd, &buf) != 0) {
        close(fd);
        printf("Can't fstat file %s %d", filename, errno);
        return X400_E_BADPARAM;
    }
 
    file_size = buf.st_size;
    printf("Content file size = %d\n", file_size);
 
    binary_data = (char *)malloc(file_size);
    if (binary_data == NULL) {
        return X400_E_NOMEMORY;
    }
 
    if ((fs = read(fd, binary_data, file_size)) == -1) {
        printf("Cannot read from binary file %d\n", errno);
        return (X400_E_SYSERROR);
    }
    close(fd);
 
    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);
    }
    return (status);
}
 
static int add_fwd_bp(struct X400msMessage *mp, char *orig_orn, char *orig_dn) {
    struct X400Message *x400_mp;
    struct X400Recipient *rp;
    int status;
    int num_atts = 0;
 
    printf("sending fwd bp \n");
 
    status = X400MsgNew(X400_MSG_MESSAGE, &x400_mp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400MsgNew returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    status = X400MsgAddStrParam(x400_mp, X400_S_MESSAGE_DELIVERY_TIME, "090909090909Z", (size_t)-1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400MsgAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    status = X400MsgAddStrParam(x400_mp, X400_S_MESSAGE_SUBMISSION_TIME, "090909090909Z", (size_t)-1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400MsgAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    /* envelope originator OR address */
    status = X400MsgAddStrParam(x400_mp, X400_S_OR_ADDRESS, orig_orn, (size_t)-1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400MsgAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
    status = X400MsgAddStrParam(x400_mp, X400_S_DIRECTORY_NAME, orig_dn, (size_t)-1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400MsgAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    /* add originator into headers */
    status = X400RecipNew(X400_ORIGINATOR, &rp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400RecipNew returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    /* put in OR Address part of OR Name */
    status = X400RecipAddStrParam(rp, X400_S_OR_ADDRESS, recip, -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400RecipAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    /* put in DN part of OR Name */
    status = X400RecipAddStrParam(rp, X400_S_DIRECTORY_NAME, orig_dn, -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msRecipAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    /* put originator into message */
    status = X400MsgAddRecip(x400_mp, X400_ORIGINATOR, rp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400MsgAddRecip returned error: %s\n", X400msError(status));
        exit(status);
    }
    printf("Put %s in as originator\n", orig_orn);
 
    /* add a recipient */
    status = X400RecipNew(X400_RECIP_STANDARD, &rp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400RecipNew returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    status = X400RecipAddStrParam(rp, X400_S_OR_ADDRESS, recip, -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400RecipAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    status = X400RecipAddStrParam(rp, X400_S_DIRECTORY_NAME, "CN=recipient;c=gb", -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msRecipAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    status = X400MsgAddRecip(x400_mp, X400_RECIP_STANDARD, rp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400MsgAddRecip returned error: %s\n", X400msError(status));
        exit(status);
    }
    printf("Put %s in as reipient\n", recip);
 
    /* Add 2nd recipient */
    status = X400RecipNew(X400_RECIP_STANDARD, &rp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400RecipNew returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    status = X400RecipAddStrParam(rp, X400_S_OR_ADDRESS, recip, -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400RecipAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    status = X400RecipAddStrParam(rp, X400_S_DIRECTORY_NAME, "CN=second recipient;c=gb", -1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msRecipAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    /* put recipient into message */
    status = X400MsgAddRecip(x400_mp, X400_RECIP_STANDARD, rp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400MsgAddRecip returned error: %s\n", X400msError(status));
        exit(status);
    }
    printf("Put %s in as reipient\n", recip);
 
    /* envelope */
 
    /* Priority: 0 - normal, 1 - non-urgent, 2 - urgent */
    printf("message priority is %d ( 0 - normal, 1 - non-urgent, 2 - urgent)\n", x400_default_priority);
    status = X400MsgAddIntParam(x400_mp, X400_N_PRIORITY, x400_default_priority);
    if (status != X400_E_NOERROR) {
        return (status);
    }
 
    /* Priority: 0 - normal, 1 - non-urgent, 2 - urgent */
    printf("military message priority is %d ( 0 - low, 1 - high)\n", x400_default_priority);
    status = X400MsgAddIntParam(x400_mp, X400_N_MMTS_PRIORITY_QUALIFIER, 1);
    if (status != X400_E_NOERROR) {
        return (status);
    }
 
    /* content */
    /* subject */
    status = X400MsgAddStrParam(x400_mp, X400_S_SUBJECT, fwd_subject, (size_t)-1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400msMsgAddStrParam returned error: %s\n", X400msError(status));
        exit(status);
    }
 
    /* now an IA5 body part using the bodypart func  */
    status = X400MsgAddAttachment(x400_mp, X400_T_IA5TEXT, text, strlen(text));
    if (status != X400_E_NOERROR) {
        printf("failed to add X400_T_IA5TEXT BP\n");
        return (status);
    }
    num_atts++;
 
    /* 8859-1 attachment */
    status = X400MsgAddStrParam(x400_mp, X400_T_ISO8859_1, text, (size_t)-1);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "x400ms returned error: %s\n", X400msError(status));
        exit(status);
    }
    num_atts++;
 
    status = X400MsgAddIntParam(x400_mp, X400_N_NUM_ATTACHMENTS, num_atts);
    if (status != X400_E_NOERROR) {
        return (status);
    }
 
    status = X400msMsgAddMessageBody(mp, x400_mp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400msMsgAddMessageBody returned error: %s\n", X400msError(status));
        return (status);
    }
 
    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;
 
    /*  Add FTBP using the bodypart func */
    if (filename_to_send == NULL) {
        printf("no file set - not sending X400_T_FTBP\n");
        return X400_E_NOERROR;
    }
    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 */
    /* And 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, "20230801060101.0Z", -1);
    X400BodypartAddStrParam(bp, X400_S_FTBP_MODIFICATION_DATE, "20230801060202.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);
    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 -1 : Use Marben-compatibility mode for 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 setting: 0=none, 1=-ve, 2=+ve\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 -f : Filename to transfer as binary bp\n");
    printf("\t -k : Request Delivery Report\n");
    printf("\t -K : Request Read Notification ( 1 - RN, 2 - NRN, 4 - return of IPM with NRN )\n");
    printf("\t -B : Set alternative subject line \n");
    return;
}