x400_msasync.c

/*  Copyright (c) 2005-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@
 */
 
#include <stdio.h>
 
#ifdef _WIN32
 
int main(int argc, char **argv) {
    fprintf(stderr, "This example is not available on Windows\n");
    exit(1);
}
 
#else
 
static void usage(void);
 
#include <errno.h>
#include <string.h>
 
#if defined(__hpux)
#include <sys/types.h>
#else
#include <sys/select.h>
#endif
#include "example.h"
 
#include <signal.h>
#include <sys/time.h>
#include <x400_ms_async.h>
#include <x400_msapi.h>
 
/* Define IC_ATTRIBUTE
 * For gcc/g++ this becomes __attribute__ and is used for the printf type
 * format checking.
 * Defined to be empty for other compilers
 */
 
#if defined(__GNUC__) || defined(__GNUG__)
#ifndef IC_ATTRIBUTE
#define IC_ATTRIBUTE(x) __attribute__(x)
#endif
#else
#define IC_ATTRIBUTE(x)
#endif
 
/* To annotate function parameters which are known not to be used
 * Not in gcc/g++ prior to v4 (I think)
 */
#if (defined(__GNUG__) && __GNUG__ >= 4) || (!defined(__GNUG__) && defined(__GNUC__) && __GNUC__ >= 3)
#define ARGNOTUSED IC_ATTRIBUTE((unused))
#else
#define ARGNOTUSED
#endif
 
static void connection_established(struct X400msSession *session, int status, int num_messages_waiting);
 
static void connection_lost(struct X400msSession *session, int reason_code, char *diagnostic);
 
static void submission_complete(struct X400msSession *session, struct X400msMessage *message, int errorcode);
 
static void fetch_complete(struct X400msSession *session, struct X400msMessage *message, int type, int seq, int errorcode);
 
static void delete_complete(struct X400msSession *session, int seqnum, int errorcode);
 
static void wait_complete(struct X400msSession *session, int num_messages_waiting, int errorcode);
 
static void list_complete(struct X400msSession *session, struct X400msListResult *listres, int errorcode);
 
static void register_complete(struct X400msSession *session, int errorcode);
 
static void alert_event(struct X400msSession *session);
 
static void event_loop(void);
 
static int manage_callback(struct X400msSession *session, int fd, int eventmask);
 
static int unmanage_callback(struct X400msSession *session, int fd, int eventmask);
 
struct SessionTable {
    char *oraddr;
    char *psw;
    char *pa;
    int fd;
    int eventmask;
    struct X400msSession *sp;
};
 
#define MAX_SESSIONS 10
 
struct SessionTable st[MAX_SESSIONS + 1];
static int dosubmit = 1;
int millisecs = 10000;
int numcons = 1;
int nummsgs = 9999999;
static char *optstr = "u371m:p:w:l:sc:o:";
int contype;
 
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 : P3 connection \n");
    printf("\t -7 : P7 connection \n");
    printf("\t -m : OR Address 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 -s : Don't do submission\n");
    printf("\t -l : Sleep time (milliseconds)\n");
    printf("\t -c : Num associations\n");
    printf("\t -o : Exit after retrieving n messages\n");
    return;
}
 
char *credentials = NULL;
 
int main(int argc, char **argv) {
    int i;
    int status;
    char *def_oraddr;
    char *def_pa;
    char buffer[BUFSIZ];
    char pa[BUFSIZ];
    char ora[BUFSIZ];
 
    x400_default_alternate_recipient_allowed = 1;
    x400_channel = "1";
    x400_default_originator = "1000000";
 
    for (i = 0; i <= MAX_SESSIONS; i++) {
        st[i].oraddr = NULL;
    }
 
    if (get_args(argc, argv, optstr)) {
        usage();
        exit(-1);
    }
 
    def_oraddr = x400_ms_user_addr;
    def_pa = x400_ms_presentation_address;
    if (x400_logline != NULL) {
        millisecs = atoi(x400_logline);
    }
 
    dosubmit = x400_default_disclosure_of_recipients;
    numcons = atoi(x400_channel);
    nummsgs = atoi(x400_default_originator);
 
    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';
    }
 
    for (i = 0; i < numcons; i++) {
        printf("ORAddress [%s] > ", def_oraddr);
        ic_fgets(ora, sizeof ora, stdin);
 
        if (ora[strlen(ora) - 1] == '\n') {
            ora[strlen(ora) - 1] = '\0';
        }
 
        if (ora[0] == '\0') {
            strcpy(ora, def_oraddr);
        }
 
        /* Prompt for password; note: reflected. */
        printf("Password [%s]: ", contype == 0 ? x400_p7_password : x400_p3_password);
        if (ic_fgets(buffer, sizeof buffer, stdin) == NULL) {
            exit(1);
        }
 
        if (buffer[strlen(buffer) - 1] == '\n') {
            buffer[strlen(buffer) - 1] = '\0';
        }
        if (buffer[0] == '\0') {
            strcpy(buffer, contype == 0 ? x400_p7_password : x400_p3_password);
        }
        // Only handle simple (password) credentials.
        credentials = strdup(buffer);
 
        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);
        }
 
        st[i].oraddr = strdup(ora);
        st[i].psw = strdup(buffer);
        st[i].pa = strdup(pa);
    }
 
    if (talking_to_marben_ms) {
        X400msSetConfigRequest(0);
    }
 
    /* Open our connections */
    for (i = 0; (st[i].oraddr != NULL) && (i < numcons); i++) {
        status = X400msOpenAsync(contype,
                                 st[i].oraddr,
                                 NULL,
                                 st[i].psw,
                                 st[i].pa,
                                 NULL,
                                 connection_established,
                                 connection_lost,
                                 submission_complete,
                                 fetch_complete,
                                 delete_complete,
                                 wait_complete,
                                 list_complete,
                                 register_complete,
                                 alert_event,
                                 manage_callback,
                                 unmanage_callback,
                                 &(st[i].sp));
 
        if (status != X400_E_WAIT_WRITE) {
            fprintf(stderr, "Error in Open for %s: %s\n", st[i].oraddr, X400msError(status));
        }
        else {
            printf("Sent off connection request for session %p\n", st[i].sp);
            X400msSetStrDefault(st[i].sp, X400_S_LOG_CONFIGURATION_FILE, "x400api.xml", 0);
 
            if (talking_to_marben_ms) {
                X400msSetIntDefault(st[i].sp, X400_N_STRICT_P7_1988, 1);
            }
 
            st[i].fd = X400msGetHandle(st[i].sp);
        }
    }
 
    event_loop();
 
    return 0;
}
 
static int unmanage_callback(struct X400msSession *session, int fd ARGNOTUSED, int eventmask) {
    int i;
 
    printf("unmanage_callback, session = %p, mask = %d\n", session, eventmask);
 
    for (i = 0; st[i].oraddr != NULL; i++) {
        if (st[i].sp == session) {
            st[i].eventmask &= ~eventmask;
            return 0;
        }
    }
    return -1;
}
 
static int manage_callback(struct X400msSession *session, int fd, int eventmask) {
    int i;
 
    printf("manage_callback, session = %p, fd = %d, eventmask = %d\n", session, fd, eventmask);
 
    for (i = 0; st[i].oraddr != NULL; i++) {
        if (st[i].sp == session) {
            st[i].eventmask |= eventmask;
            return 0;
        }
    }
    return -1;
}
 
static void send_messages(void) {
    int status;
    int i;
    struct X400msMessage *mp;
    struct X400Recipient *rp;
    char buf[1024];
    char contid[1024];
    static int num = 0;
    char *s;
 
    for (i = 0; st[i].oraddr != NULL; i++) {
        if (st[i].fd != -1) {
 
            status = X400msMsgNew(st[i].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, st[i].oraddr, -1);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "x400msRecipAddStrParam returned error: %s\n", X400msError(status));
                exit(status);
            }
 
            sprintf(buf, "Subject for session %p", st[i].sp);
            status = X400msMsgAddStrParam(mp, X400_S_SUBJECT, buf, -1);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "x400msMsgAddStrParam returned error: %s\n", X400msError(status));
                exit(status);
            }
 
            status = X400msMsgAddStrParam(mp, X400_T_IA5TEXT, "body text", -1);
            if (status != X400_E_NOERROR) {
                fprintf(stderr, "x400ms returned error: %s\n", X400msError(status));
                exit(status);
            }
#define BINSIZE 6000000
            s = (char *)malloc(BINSIZE);
            memset(s, 0, BINSIZE);
            X400msMsgAddAttachment(mp, X400_T_BINARY, s, BINSIZE);
            free(s);
 
            sprintf(contid, "CONTID%d", num);
            num++;
 
            /* 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);
            }
 
            printf("Sending message from & to %s\n", st[i].oraddr);
            status = X400msMsgSend(mp);
 
            if ((status != X400_E_WAIT_READ) && (status != X400_E_WAIT_READ_WRITE)) {
                fprintf(stderr, "Error sending message: %d\n", status);
            }
 
            X400msMsgDelete(mp, 0);
        }
    }
}
 
static void connection_established(struct X400msSession *session, int status, int alert) {
    int retval;
    int count;
 
    if (status == X400_E_NOERROR) {
        printf("Connection established for session %p, alert = %d\n", session, alert);
 
        if (contype == 0) {
#ifdef notdef
            printf("Sending Register request\n");
            retval = X400msRegisterAutoAction(session, X400_AUTO_ALERT, 9, NULL);
            if ((retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
                fprintf(stderr, "Failed to issue Register for session %p, err = %d\n", session, retval);
            }
            printf("Registered AutoAlert autoaction (id = 9) OK\n");
 
            printf("Sending Deregister request\n");
            retval = X400msDeregisterAutoAction(session, X400_AUTO_ALERT, 5);
            if ((retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
                fprintf(stderr, "Failed to issue Deregister for session %p, err = %d\n", session, retval);
            }
            printf("Deegistered AutoAlert autoaction (id = 5) OK\n");
#endif
            printf("Sending List request\n");
            retval = X400msList(session, NULL, NULL);
            if ((retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
                fprintf(stderr, "Failed to issue List for session %p, err = %d\n", session, retval);
            }
        }
        else {
            /* If P3 connection, we just need to wait until we get invoked */
            retval = X400msWait(session, 0, &count);
 
            if ((retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
                fprintf(stderr, "Failed to issue Wait for session %p, err = %d\n", session, retval);
            }
        }
    }
    else {
        int i;
 
        fprintf(stderr, "Connection failed for session %p\n", session);
        for (i = 0; st[i].oraddr != NULL; i++) {
            if (st[i].sp == session) {
                st[i].fd = -1;
                break;
            }
        }
    }
}
 
static void connection_lost(struct X400msSession *session ARGNOTUSED, int reason_code, char *diagnostic) {
    fprintf(stderr, "Connection lost callback, reason = %d, diag = %s\n", reason_code, (diagnostic == NULL) ? "NULL" : diagnostic);
}
 
static void submission_complete(struct X400msSession *session ARGNOTUSED, struct X400msMessage *message, int errorcode) {
    if (errorcode == X400_E_NOERROR) {
        char buf[1024];
        size_t len;
        int status;
 
        memset(buf, 0, 1024);
        if (X400msMsgGetStrParam(message, X400_S_MESSAGE_IDENTIFIER, buf, 1024, &len) == X400_E_NOERROR) {
            printf("Submission successful, identifier = %s\n", buf);
        }
        else {
            fprintf(stderr, "Submission successful but failed to get ID\n");
        }
 
        status = X400msMsgGetStrParam(message, X400_S_MESSAGE_SUBMISSION_TIME, buf, 1024, &len);
        if (status != X400_E_NOERROR) {
            fprintf(stderr, "No MessageSubmissionTime present from submission result: error %d\n", status);
        }
        else {
            buf[len] = '\0';
            printf("MessageSubmissionTime from Submission Result = %s\n", buf);
        }
 
        status = X400msMsgGetStrParam(message, X400_S_CONTENT_IDENTIFIER, buf, 1024, &len);
        if (status != X400_E_NOERROR) {
            fprintf(stderr, "No ContentIdentifier present from submission result: error %d\n", status);
        }
        else {
            buf[len] = '\0';
            printf("ContentIdentifier from Submission Result = %s\n", buf);
        }
 
        X400msMsgDelete(message, 0);
    }
    else {
        fprintf(stderr, "Submission failed, errorcode = %d\n", errorcode);
    }
}
 
static void list_complete(struct X400msSession *session, struct X400msListResult *lr, int errorcode) {
    int i = 1;
    int status = X400_E_NOERROR;
 
    printf("list_complete, errorcode = %d\n", errorcode);
 
    if (errorcode == X400_E_NOERROR) {
        /* Traverse list result, extracting information about each message */
        while (status == X400_E_NOERROR) {
            int seqnum = 0;
            char buf[1024];
            char *type;
            char *subj;
            char *sender;
            size_t len;
            int length;
            int pri;
            int entry_status;
            char *msgid;
            char *subjid;
 
            type = NULL;
            subj = NULL;
            sender = NULL;
            msgid = NULL;
            subjid = NULL;
            length = -1;
            pri = -1;
            entry_status = -1;
 
            /* Get sequence number */
            if ((status = X400msListGetIntParam(lr, X400_N_MS_SEQUENCE_NUMBER, i, &seqnum)) == X400_E_NO_MORE_RESULTS) {
                break;
            }
 
            if (X400msListGetStrParam(lr, X400_S_OBJECTTYPE, i, buf, 1024, &len) == X400_E_NOERROR) {
                type = strdup(buf);
            }
 
            if (X400msListGetStrParam(lr, X400_S_SUBJECT, i, buf, 1024, &len) == X400_E_NOERROR) {
                subj = strdup(buf);
            }
 
            if (X400msListGetStrParam(lr, X400_S_OR_ADDRESS, i, buf, 1024, &len) == X400_E_NOERROR) {
                sender = strdup(buf);
            }
 
            if (X400msListGetStrParam(lr, X400_S_MESSAGE_IDENTIFIER, i, buf, 1024, &len) == X400_E_NOERROR) {
                msgid = strdup(buf);
            }
 
            if (X400msListGetStrParam(lr, X400_S_SUBJECT_IDENTIFIER, i, buf, 1024, &len) == X400_E_NOERROR) {
                subjid = strdup(buf);
            }
 
            X400msListGetIntParam(lr, X400_N_PRIORITY, i, &pri);
 
            X400msListGetIntParam(lr, X400_N_CONTENT_LENGTH, i, &length);
 
            /* Entry status */
            X400msListGetIntParam(lr, X400_N_MS_ENTRY_STATUS, i, &entry_status);
 
            printf("S=%d, P=%d, len=%d, stat=%d, type=%s, subj=%s, orig=%s, msgid=%s, subjid=%s\n",
                   seqnum,
                   pri,
                   length,
                   entry_status,
                   (type == NULL) ? "NULL" : type,
                   (subj == NULL) ? "NULL" : subj,
                   (sender == NULL) ? "NULL" : sender,
                   (msgid == NULL) ? "NULL" : msgid,
                   (subjid == NULL) ? "NULL" : subjid);
            i++;
            if (sender != NULL) {
                free(sender);
            }
            if (subj != NULL) {
                free(subj);
            }
            if (type != NULL) {
                free(type);
            }
            if (msgid != NULL) {
                free(msgid);
            }
            if (subjid != NULL) {
                free(subjid);
            }
 
            if (seqnum != 0) {
                int retval;
 
                /* Ask for the whole message */
                printf("Session %p, issing MsgGet\n", session);
                retval = X400msMsgGet(session, seqnum, NULL, NULL, NULL);
                if ((retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
                    fprintf(stderr, "MsgGet failed !\n");
                    exit(1);
                }
            }
        }
        X400msListFree(lr);
    }
    else {
        fprintf(stderr, "List failed, errorcode = %d\n", errorcode);
    }
}
 
static void fetch_complete(struct X400msSession *session, struct X400msMessage *message, int type, int seqno, int errorcode) {
    printf("Fetch complete callback, session=%p, seqno=%d, type=%d, errorcode = %d\n", session, seqno, type, errorcode);
 
    if (errorcode == X400_E_NOERROR) {
        char buf[1024];
        size_t len;
        int retval;
        char buffer[30000];
        int status;
        size_t length;
 
        status = X400msMsgGetStrParam(message, X400_S_CONTENT_FILENAME, buffer, sizeof buffer, &length);
        if (status == X400_E_NOERROR) {
            printf("Read raw content into file %s\n", buffer);
        }
        else {
            fprintf(stderr, "Failed to read raw content into file, error %d\n", status);
        }
 
        status = X400msMsgGetStrParam(message, X400_S_CONTENT_STRING, buffer, sizeof buffer, &length);
        if (status == X400_E_NOERROR) {
            printf("Read raw content into buffer, length = %ld\n", (long)length);
        }
        else {
            fprintf(stderr, "Failed to read raw content into buffer, error %d\n", status);
        }
 
        memset(buf, 0, 1024);
        if (X400msMsgGetStrParam(message, X400_S_OBJECTTYPE, buf, 1024, &len) == X400_E_NOERROR) {
            printf("Object type = %s\n", buf);
        }
 
        memset(buf, 0, 1024);
        if (X400msMsgGetStrParam(message, X400_S_SUBJECT, buf, 1024, &len) == X400_E_NOERROR) {
            printf("Subject = %s\n", buf);
        }
 
        if (contype != 0) {
            retval = X400msMsgGetFinish(message, X400_E_NOERROR, 0);
            if (retval != X400_E_NOERROR) {
                fprintf(stderr, "MsgGetFinish failed !\n");
            }
        }
 
        /* Now delete it */
        retval = X400msMsgDelete(message, 0);
        if ((retval != X400_E_NOERROR) && (retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
            fprintf(stderr, "MsgDelete failed !\n");
        }
        else {
            printf("Session %p, issued MsgDelete for %d\n", session, seqno);
        }
#ifdef notdef
        /* Ask for the next one */
        retval = X400msMsgGet(session, 0, NULL, NULL, NULL);
        fprintf(stderr, "MsgGet failed !\n");
        if ((retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
            else printf("Session %p, issued MsgGet\n", session);
        }
#endif
    }
    else {
        fprintf(stderr, "Fetch failed, errcode = %d\n", errorcode);
    }
}
 
static void delete_complete(struct X400msSession *session, int seqnum, int errorcode) {
    if (errorcode == X400_E_NOERROR) {
        printf("Session %p, - delete complete callback for seqnum %d\n", session, seqnum);
    }
    else {
        fprintf(stderr, "******* SESSION %p, - DELETE FAILED %d **********\n", session, errorcode);
    }
}
 
static void register_complete(struct X400msSession *session, int errorcode) {
    if (errorcode == X400_E_NOERROR) {
        printf("Session %p, - register complete callback\n", session);
    }
    else {
        fprintf(stderr, "******* SESSION %p, - REGISTER FAILED %d **********\n", session, errorcode);
    }
}
 
static void wait_complete(struct X400msSession *session, int num_messages_waiting, int errorcode) {
    printf("Wait complete callback, errorcode = %d, num = %d\n", errorcode, num_messages_waiting);
 
    if (num_messages_waiting > 0) {
        int retval;
 
        /* Get first available message */
        printf("Session %p, issuing MsgGet OK\n", session);
        retval = X400msMsgGet(session, 0, NULL, NULL, NULL);
        if ((retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
            fprintf(stderr, "MsgGet failed !\n");
        }
    }
}
 
static void alert_event(struct X400msSession *session) {
    int retval;
 
    printf("Got an alert !\n");
 
    printf("Issuing List op for session %p\n", session);
    retval = X400msList(session, NULL, NULL);
    if ((retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
        fprintf(stderr, "Failed to issue List op for session %p, error %d\n", session, retval);
    }
}
 
static void event_loop() {
    fd_set rfds, wfds, efds;
    struct timeval timeout, *tp;
    int n;
    int i;
 
    while (1) {
        int num_fds = 0;
 
        FD_ZERO(&rfds);
        FD_ZERO(&efds);
        FD_ZERO(&wfds);
 
        for (i = 0; st[i].oraddr != NULL; i++) {
            if (st[i].fd != -1) {
 
                printf("Expecting ");
                if (st[i].eventmask & X400_EVENT_READ) {
                    printf("read ");
                    FD_SET(st[i].fd, &rfds);
                }
 
                if (st[i].eventmask & X400_EVENT_WRITE) {
                    printf("write ");
                    FD_SET(st[i].fd, &wfds);
                }
 
                if (st[i].eventmask & X400_EVENT_ERROR) {
                    printf("error ");
                    FD_SET(st[i].fd, &efds);
                }
                printf("on fd %d\n", st[i].fd);
            }
 
            if (st[i].fd > num_fds) {
                num_fds = st[i].fd;
            }
        }
 
        if (millisecs >= 0) {
            timeout.tv_sec = millisecs / 1000;
            timeout.tv_usec = (millisecs % 1000) * 1000;
            tp = &timeout;
        }
        else {
            tp = 0;
        }
        //printf("num fds = %d\n", num_fds);
        n = select(num_fds + 1, &rfds, &wfds, &efds, tp);
 
        if (n < 0) {
            fprintf(stderr, "select returned %d: errno = %d\n", n, errno);
            exit(1);
        }
        else if (n == 0) {
            if (nummsgs < 0) {
                printf("Exiting now\n");
                for (i = 0; st[i].oraddr != NULL; i++) {
                    if (st[i].fd != -1) {
                        X400msClose(st[i].sp);
                    }
                }
                exit(0);
            }
            else {
                nummsgs--;
            }
 
            printf(">>>>> Timeout\n");
 
            if (contype == 0) {
                for (i = 0; st[i].oraddr != NULL; i++) {
                    int retval;
 
                    if (st[i].fd != -1) {
                        printf("Issuing List for session %p\n", st[i].sp);
                        retval = X400msList(st[i].sp, NULL, NULL);
                        if ((retval != X400_E_WAIT_READ) && (retval != X400_E_WAIT_READ_WRITE)) {
                            fprintf(stderr, "Failed to issue List for session %p, err = %d\n", st[i].sp, retval);
                        }
                    }
                }
            }
 
            if (dosubmit == 1) {
                // Submit some new message.
                send_messages();
            }
        }
        else {
            X400msProcessEvent(num_fds + 1, &rfds, &wfds, &efds);
        }
    }
}
 
#endif