x400_ms_common.c

/*  Copyright (c) 2014-2025, 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@
 *
 * Set of MS functions to get and display attribute from MS messages
 */
 
#include <stdio.h>
#include <x400_msapi.h>
#include <amhs_att.h>
#include <errno.h>
#include <seclabel_api.h> /* For security labels */
#include "example.h"
 
#include "ms_example.h"
 
static int get_bp(
    struct X400msMessage *mp,
    struct X400Bodypart **bp,
    int att_num
);
 
static int get_msgbp(
    struct X400msMessage *mp,
    struct X400Message **x400_mp,
    int att_num
);
 
static int do_xmsg_content_as_bp(
    struct X400Message *x400_mp
);
 
static int do_xrep_content_as_bp(
    struct X400Message *x400_mp
);
 
static int do_xrep_headers(
    struct X400Message *x400_mp
);
 
static int do_xmsg_headers(
    struct X400Message *x400_mp
);
 
static int do_redirection_hist (
    struct X400Recipient *rp
);
 
 
int get_recips(
    struct X400Message  *x400_mp,
    int                 type
)
{
 
    struct X400Recipient        *rp;
    int                         status;
    int                         recip_num;
 
    for (recip_num = 1; ; recip_num++ ) {
 
        char    buf[INIT_BUFFER_SIZE];
        int             buflen = sizeof buf;
        size_t  ret_len;
 
        status = X400MsgGetRecip(x400_mp, type, recip_num, &rp);
        if (status == X400_E_NO_RECIP) {
            if (recip_num == 1) {
                printf("no recips of type %x\n", type);
                return X400_E_NOERROR;
            } else {
                printf("no more recips of type %x\n", type);
            }
            return X400_E_NOERROR;
        }
        else if (status != X400_E_NOERROR) {
            fprintf(stderr, "X400MsgGetRecip (%d) failed %s\n",
                     X400_S_OBJECTTYPE, X400msError (status));
            return status;
        }
        printf("got recip number %d of type %s (%x)\n", recip_num,
                type == X400_RECIP_PRIMARY ? "Primary" : 
                type == X400_RECIP_CC ? "CC" : 
                type == X400_RECIP_BCC ? "BCC" : 
                type == X400_ORIGINATOR ? "Originator" : 
                type == X400_AUTH_ORIG ? "Auth Orig" : 
                type == X400_RECIP_REPLY ? "Reply" : 
                type == X400_RECIP_REPORT ? "Reported Recip" : 
                type == X400_RECIP_INTENDED ? "Intended" : 
                type == X400_RECIP_ENVELOPE ? "Envelope" : 
                "Unknown",
                type);
        if (type == X400_RECIP_ENVELOPE) {
            // These aren't expected as the message will be forwarded
            // message with no envelope
            status = X400RecipGetStrParam(rp, X400_S_OR_ADDRESS, buf, buflen, 
                    &ret_len);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "X400MsgGetStrParam (%d) failed %s\n",
                         X400_S_OBJECTTYPE, X400msError (status));
            } else {
                printf("Originator OR Address'%.*s'\n", (int)ret_len, buf);
            }
        } else {
            status = X400RecipGetStrParam(rp, X400_S_OR_ADDRESS, buf, buflen, 
                    &ret_len);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "X400MsgGetStrParam (%d) failed %s\n",
                         X400_S_OBJECTTYPE, X400msError (status));
            } else {
                printf("Originator OR Address'%.*s'\n", (int)ret_len, buf);
            }
 
        }
 
#define USE_REDIRECTION_HISTORY 1
#ifdef  USE_REDIRECTION_HISTORY
 {
     status = do_redirection_hist(rp);
     if ( status == X400_E_NO_VALUE ) {
         /* do nothing */
     } else if (status == X400_E_MISSING_ATTR ) {
         printf("There is no Redirection History\n");
     } else if (status == X400_E_NOERROR ) {
         printf("Found some Redirection History\n");
     } else {
         printf("error getting Redirection History\n");
         fprintf (stderr, "Error fetching Redirection History: %s\n", 
                  X400msError (status));
         return status;
     }  
 }
#endif
    }
 
}
 
int get_body_parts(
    struct X400msMessage *mp
)
{
#define INIT_BUFFER_SIZE 10000
#define INIT_BUFFER2_SIZE 256
    int         status;
    int         num_atts = 0;
    int         type;
    char        *buf;
    size_t      buflen;
    size_t      ret_len;
    int         i;
    size_t      j;
    struct X400Message *x400_mp;
    struct X400Bodypart *bp;
 
 
    printf ("Getting Body Parts\n");
 
    status = X400msMsgGetIntParam (mp, X400_N_NUM_ATTACHMENTS, &num_atts);
    if ( status != X400_E_NOERROR ) {
        fprintf (stderr, "Error in X400msMsgGetIntParam attachments %s\n",
                 X400msError (status));
        return status;
    }
    printf ("Number of attachments is %d\n", num_atts);
 
    buf = (char *) malloc(INIT_BUFFER_SIZE);
    if (buf == NULL) {
        fprintf(stderr, "can't alloc %d bytes\n", INIT_BUFFER_SIZE);
        return X400_E_NOMEMORY;
    }
    buflen = INIT_BUFFER_SIZE;
 
    for (i = 0; i <= num_atts ; i++) {
        printf ("\n----- Get attachment ----- %d\n", i);
        status = X400msMsgGetAttachment(mp, i, &type, buf, buflen, &ret_len);
        if (status == X400_E_NOSPACE) {
            char *newbuf;
            fprintf(stderr, "realloc %ld bytes\n", (long)ret_len);
            newbuf = (char *) realloc(buf, ret_len + 1);
            if (newbuf == NULL) {
                fprintf(stderr, "can't alloc %d bytes\n", INIT_BUFFER_SIZE);
                free (buf);
                return X400_E_NOMEMORY;
            }
            buf = newbuf;
            buflen = ret_len;
            status = X400msMsgGetAttachment(
                mp, i, &type, buf, buflen, &ret_len);
            /* fall through with status set */
        }
        /* for some attachments you must use the BodyPart functions */
        if (status == X400_E_COMPLEX_BODY) {
            printf("got complex bodypart\n");
            status = get_bp(mp, &bp, i);
            if (status != X400_E_NOERROR ) {
                free (buf);
                return status;
            }
        }
        /* for forwarded messages you must use the BodyPart functions */
        else if (status == X400_E_MESSAGE_BODY) {
            printf("got forwarded message bodypart\n");
            status = get_msgbp(mp, &x400_mp, i);
            if (status != X400_E_NOERROR ) {
                free (buf);
                return status;
            }
        }
        else if (status == X400_E_NOERROR) {
            /* process text or binary attachment */
            printf("got FTBP, text or binary attachment\n");
            switch (type) {
                case X400_T_FTBP:
 
                /* Could retrieve these here: */
                    /* Content Description */
                    /* Filename */
                    /* Creation Date Description */
                    /* Modification Date */
 
                // Fall Thru
                case X400_T_BINARY:
                    printf("First 1000 bytes of Binary Data for %s BP is:",
                        type == X400_T_BINARY ? "Binary" : "FTBP");
                    for (j = 0; j < ret_len && j < 1000; j++)
                        printf("%x ", buf[j]);
                    printf("\n");
                    break;
                case X400_T_IA5TEXT:
                    printf("IA5 BP is:\n%.*s", (int)ret_len, buf);
                    break;
                default: 
                    printf("Printable Data for BP is:\n%.*s", (int)ret_len, buf);
                    break;
            }
        }
        else if (status == X400_E_MISSING_ATTR) {
            printf("attachment %d not found\n", i);
        }           
        else {
            /* got an error */
            fprintf (stderr, "Error in X400msMsgGetAttachment %s\n",
                     X400msError (status));
            break;
        }
    }
    free (buf);
    return status;
}
 
static int get_bp(
    struct      X400msMessage *mp,
    struct      X400Bodypart **bpp,
    int         att_num
)
{
    int         status;
    int         type;
    int         bp_type;
    size_t      j;
    char        *buf;
    size_t      buflen;
    char        buf2[INIT_BUFFER2_SIZE];
    int         buf2len = sizeof buf2;
    size_t      ret_len;
 
#define INIT_BUFFER_SIZE 10000
    printf ("Get Bodypart %d\n", att_num);
 
    /* firstly get the Bodypart */
    status = X400msMsgGetBodypart(mp, att_num, &type, bpp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400msMsgGetBodypart %d failed %s\n", att_num,
                 X400msError (status));
        return status;
    }
    printf("got Bodypart %d, type = %d\n", att_num, type);
 
    /* What kind of Bodypart using a attribute of the BP */
    status = X400BodypartGetIntParam(*bpp, X400_N_BODY_TYPE, &bp_type);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400msMsgGetBodypart failed %s\n",
                 X400msError (status));
        return status;
    }
    printf("got Bodypart %d, type = %s\n", att_num, 
            bp_type == X400_T_IA5TEXT ? "IA5" : 
            bp_type == X400_T_ISO8859_1 ? "ISO8859-1" :
            bp_type == X400_T_ISO8859_2 ? "ISO8859_2" :
            bp_type == X400_T_BINARY ? "Binary" : 
            bp_type == X400_T_MESSAGE ? "Message" : 
            bp_type == X400_T_FTBP ? "File Transfer BP" :
            bp_type == X400_T_GENERAL_TEXT ? "General Text" : "Unknown"
            );
 
    /* setup buffer to use to return BP data */
    buf = (char *) malloc(INIT_BUFFER_SIZE);
    if (buf == NULL) {
        fprintf(stderr, "can't alloc %d bytes\n", INIT_BUFFER_SIZE);
        return X400_E_NOMEMORY;
    }
    buflen = INIT_BUFFER_SIZE;
    /* Read data from the Bodypart */
    status = X400BodypartGetStrParam(*bpp, X400_S_BODY_DATA, buf, 
        buflen, &ret_len);
    if (status == X400_E_NOSPACE) {
        char *newbuf;
        fprintf(stderr, "realloc %ld bytes\n", (long)ret_len);
        newbuf = (char *) realloc(buf, ret_len + 1);
        if (newbuf == NULL) {
            free (buf);
            fprintf(stderr, "can't alloc %d bytes\n", INIT_BUFFER_SIZE);
            return X400_E_NOMEMORY;
        }
        buf = newbuf;
        buflen = ret_len;
        status = X400BodypartGetStrParam(*bpp, X400_S_BODY_DATA, buf, 
            buflen, &ret_len);
        /* fall through with status set */
    }
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400msMsgGetBodypart failed %s\n",
                 X400msError (status));
        return status;
    }
    printf("got %ld bytes of Bodypart data\n", (long)ret_len);
    switch (bp_type) {
        case X400_T_FTBP:
 
            /* Content Description */
            status = X400BodypartGetStrParam(*bpp, 
                X400_S_FTBP_CONTENT_DESCRIPTION, buf2, buf2len, &ret_len);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "X400BodypartGetStrParam (%d) failed %s\n",
                    X400_S_FTBP_CONTENT_DESCRIPTION, X400msError (status));
            } else {
                printf("FTBP Content Description '%.*s'\n", 
                    (int)ret_len, buf2);
            }
            /* Filename */
            status = X400BodypartGetStrParam(*bpp, 
                X400_S_FTBP_FILENAME, buf2, buf2len, &ret_len);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "X400BodypartGetStrParam (%d) failed %s\n",
                    X400_S_FTBP_FILENAME, X400msError (status));
            } else {
                printf("FTBP Filename '%.*s'\n", 
                    (int)ret_len, buf2);
            }
            /* Creation Date Description */
            status = X400BodypartGetStrParam(*bpp, 
                X400_S_FTBP_CREATION_DATE, buf2, buf2len, &ret_len);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "X400BodypartGetStrParam (%d) failed %s\n",
                    X400_S_FTBP_CREATION_DATE, X400msError (status));
            } else {
                printf("FTBP Content Description '%.*s'\n", 
                    (int)ret_len, buf2);
            }
            /* Modification Date */
            status = X400BodypartGetStrParam(*bpp, 
                X400_S_FTBP_MODIFICATION_DATE, buf2, buf2len, &ret_len);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "X400BodypartGetStrParam (%d) failed %s\n",
                    X400_S_FTBP_MODIFICATION_DATE, X400msError (status));
            } else {
                printf("FTBP Modification Date '%.*s'\n", 
                    (int)ret_len, buf2);
            }
 
            // Fall Thru
        case X400_T_BINARY:
            printf("First 1000 bytes of Binary Data for %s BP is:",
                type == X400_T_BINARY ? "Binary" : "FTBP");
            for (j = 0; j < ret_len && j < 1000; j++)
                printf("%x ", buf[j]);
            printf("\n");
            break;
        case X400_T_IA5TEXT:
            printf("IA5 BP is:\n%s", buf);
            break;
        default: 
            printf("Printable Data for BP is:\n%.*s", (int)ret_len, buf);
            break;
    }
 
    free (buf);
    return X400_E_NOERROR;
}
 
/*
 * Extract and return a Bodypart from an MS Message
 */
static int get_msgbp(
    struct X400msMessage *mp,
    struct X400Message **x400_mpp,
    int bp_num
)
{
    struct X400Message *x400_mp;
    int         status;
    char        buf[INIT_BUFFER_SIZE];
    int         buflen = sizeof buf;
    size_t      ret_len;
 
    status = X400msMsgGetMessageBody(mp, bp_num, x400_mpp);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400MsgGetMessageBody (%d) failed %s\n",
                 bp_num, X400msError (status));
        return status;
    }
    printf("Got Message BP from BP %d\n", bp_num);
    x400_mp = *x400_mpp;
 
    status = X400MsgGetStrParam(x400_mp, X400_S_OBJECTTYPE, buf, buflen, 
            &ret_len);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400MsgGetStrParam (%d) failed %s\n",
                 X400_S_OBJECTTYPE, X400msError (status));
        return status;
    }
    printf("Message BP from BP is '%.*s'\n", (int)ret_len, buf);
    if (strncmp(buf, "message", ret_len) == 0 ) {
        status = do_xmsg_headers(x400_mp);
        if (status != X400_E_NOERROR) 
            return status;
        status = do_xmsg_content_as_bp(x400_mp);
        if (status != X400_E_NOERROR) 
            return status;
    }
    else if (strncmp(buf, "report", ret_len) == 0 ) {
        status = do_xrep_headers(x400_mp);
        if (status != X400_E_NOERROR) 
            return status;
        status = do_xrep_content_as_bp(x400_mp);
        if (status != X400_E_NOERROR) 
            return status;
    }
    else if (strncmp(buf, "probe", ret_len) == 0 ) {
        status = do_xmsg_headers(x400_mp);
        if (status != X400_E_NOERROR) 
            return status;
    }
    else {
        fprintf(stderr, "got unknown object: %s\n", buf);
        return X400_E_BADPARAM;
    }
 
 
    return X400_E_NOERROR;
}
 
static int do_xmsg_content_as_bp(
    struct X400Message *x400_mp
#ifdef __GNUC__
    __attribute__((unused))
#endif
)
{
    printf("do_xmsg_content_as_bp NYI\n");
    return X400_E_NOERROR;
}
 
 
static int do_xrep_headers(
    struct X400Message *x400_mp
#ifdef __GNUC__
    __attribute__((unused))
#endif
)
{
    printf("do_xrep_headers NYI\n");
    return X400_E_NOERROR;
}
 
 
static int do_xrep_content_as_bp(
    struct X400Message *x400_mp
#ifdef __GNUC__
    __attribute__((unused))
#endif
)
{
    printf("do_xrep_content_as_bp NYI\n");
    return X400_E_NOERROR;
}
 
static int do_xmsg_headers(
    struct X400Message *x400_mp
)
{
    int         status;
    char        buf[INIT_BUFFER_SIZE];
    int         buflen = sizeof buf;
    size_t      ret_len;
    int         num_atts;
 
    printf("do_xmsg_headers\n");
    status = X400MsgGetStrParam(x400_mp, X400_S_IPM_IDENTIFIER, buf, buflen, 
            &ret_len);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400MsgGetStrParam (%d) failed %s\n",
                 X400_S_OBJECTTYPE, X400msError (status));
        return status;
    }
    printf("IPM Identifier from Message BP '%.*s'\n", (int)ret_len, buf);
 
    status = X400MsgGetStrParam(x400_mp, X400_S_SUBJECT, buf, buflen, 
            &ret_len);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400MsgGetStrParam (%d) failed %s\n",
                 X400_S_OBJECTTYPE, X400msError (status));
        return status;
    }
    printf("Subject from Message BP '%.*s'\n", (int)ret_len, buf);
 
    status = X400MsgGetIntParam(x400_mp, X400_N_NUM_ATTACHMENTS, &num_atts);
    if (status != X400_E_NOERROR) {
        fprintf(stderr, "X400MsgGetStrParam (%d) failed %s\n",
                 X400_S_OBJECTTYPE, X400msError (status));
        return status;
    }
    printf("Number of attachments in Message BP %d'\n", num_atts);
 
    status = get_recips(x400_mp, X400_ORIGINATOR);
    if (status != X400_E_NOERROR) {
        return status;
    }
 
    status = get_recips(x400_mp, X400_RECIP_PRIMARY);
    if (status != X400_E_NOERROR) {
        return status;
    }
 
    status = get_recips(x400_mp, X400_RECIP_ENVELOPE);
    if (status != X400_E_NOERROR) {
        return status;
    }
 
    return X400_E_NOERROR;
}
 
static int do_redirection_hist (
    struct X400Recipient *rp
)
{
    char  redirection_time [BUFSIZ];
    char  or_address       [BUFSIZ];
    char  dn               [BUFSIZ];
    int   rr;
    
    size_t length;
    int n;
    int status;
    
    struct X400RediHist *hist = NULL;
    
    for ( n=1; ;n++ ) {
 
        status = X400RediHistGet (rp,n,&hist);
        if (status != X400_E_NOERROR)
            break;
        
        status = X400RediHistGetStrParam (hist, X400_S_REDIRECTION_TIME,
                                          redirection_time, BUFSIZ,&length);
        
        if (status == X400_E_NO_VALUE) {
            return X400_E_NO_VALUE;
        }
        
        if ( status == X400_E_NOERROR ) {
            redirection_time[length] = '\0';
            printf ("Redirection time: %i %s\n",n,redirection_time);
        } else {
            fprintf (stderr, "Error in do_redirection_hist: %s\n",
                     X400msError (status));
        }
 
        status = X400RediHistGetStrParam (hist, X400_S_OR_ADDRESS,
                                          or_address, BUFSIZ , &length);
        if ( status == X400_E_NOERROR ) {
            or_address[length] = '\0';
            printf ("Redirection OR address %i  :%s\n",n,or_address);
        } else {
            fprintf (stderr, "Error in do_redirection_hist: %s\n",
                     X400msError (status));
        }
 
        status = X400RediHistGetStrParam (hist, X400_S_DIRECTORY_NAME,
                                          dn, BUFSIZ , &length);
        if ( status == X400_E_NOERROR ) {
            dn[length] = '\0';
            printf ("Redirection DN %i  :%s\n",n,dn);
        } else {
            fprintf (stderr, "Error in do_redirection_hist: %s\n",
                     X400msError (status));
        }
        
        status = X400RediHistGetIntParam (hist, X400_N_REDIRECTION_REASON,&rr);
        if ( status == X400_E_NOERROR ) {
            printf ("DSI routing action %d  :%s\n",n,X400RediReason(rr));
        } else {
            fprintf (stderr, "Error in do_redirection_hist: %s\n",
                     X400msError (status));
        }
        
    }
    if (n == 1) {
        printf("No Redirection histories found in message\n");
    } else {
        printf("%d Redirection histories found in message\n", n - 1);
    }
    return X400_E_NOERROR;
    
}
 
/* Military priority utilities */
char * get_x400_pty_str_from_4406(int s4406_pty) {
    switch (s4406_pty) {
        case 0 : return "deferred";
        case 1 : return "routine";
        case 2 : return "priority";
        case 3 : return "immediate";
        case 4 : return "flash";
        case 5 : return "override";
        default: return "priority";
    }
}
 
 
int get_x400_pty_qual_from_4406(int s4406_pty) {
    switch (s4406_pty) {
        case 0 :
        case 2 :
        case 4 :
                return 0;
        case 1 :
        case 3 :
        case 5 :
                return 1;
        default:
                return 0;
    }
 
}
 
 
int get_x400_pty_from_4406(int s4406_pty) {
        switch (s4406_pty) {
        case 0 :
        case 1 :
                return 1;
        case 2 :
        case 3 :
                return 0;
        case 4 :
        case 5 :
                return 2;
        default:
                return 0;
    }
 
}
 
 
 
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;
    }
    
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
    fread(&xml_content,XML_BUFSIZE,1,fd);
#pragma GCC diagnostic pop
 
    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;
}