int recv(void *buf, int *size) {
    int  *lbuf;
    int   ferr;
    int   lerr;
    bool  mon_msg;
    int   nid;
    int   pid;

    do {
        do {
            lerr = XWAIT(LREQ, -1);
            TEST_CHK_WAITIGNORE(lerr);
            lerr = XMSG_LISTEN_((short *) &gsre,   // sre
                               0,                 // listenopts
                               0);                // listenertag
        } while (lerr == XSRETYPE_NOWORK);
        mon_msg = (gsre.sre_flags & XSRE_MON);
        if (mon_msg) {
            int msg_size = gsre.sre_reqDataSize;
            char *msg = new char[msg_size];
            ferr = XMSG_READDATA_(gsre.sre_msgId,     // msgid
                                  msg,                // reqdata
                                  (ushort) msg_size); // bytecount
            assert(ferr == XZFIL_ERR_OK);
            check_mon_msg(msg);
            XMSG_REPLY_(gsre.sre_msgId,      // msgid
                        NULL,                // replyctrl
                        0,                   // replyctrlsize
                        NULL,                // replydata
                        0,                   // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
            delete [] msg;
            if (gtakeover)
                return 1;
        } else {
            ferr = XMSG_READDATA_(gsre.sre_msgId,   // msgid
                                  (char *) buf,     // reqctrl
                                  (ushort) *size);  // bytecount
            assert(ferr == XZFIL_ERR_OK);
            *size = gsre.sre_reqDataSize;
            ferr = XMSG_GETREQINFO_(MSGINFO_NID,
                                    gsre.sre_msgId,
                                    &nid);
            assert(ferr == XZFIL_ERR_OK);
            ferr = XMSG_GETREQINFO_(MSGINFO_PID,
                                    gsre.sre_msgId,
                                    &pid);
            assert(ferr == XZFIL_ERR_OK);
            lbuf = (int *) buf;
            myprintf("received from p-id=%d/%d: %d.%d.%d\n",
                     nid, pid, lbuf[0], lbuf[1], lbuf[2]);
        }
    } while (mon_msg);
    return 0;
}
void wait_node_notice() {
    int    ferr;
    int    lerr;
    bool   node_change;
    MS_SRE sre;

    node_change = false;
    while (!node_change) {
        lerr = XWAIT(LREQ, -1);
        TEST_CHK_WAITIGNORE(lerr);
        do {
            lerr = XMSG_LISTEN_((short *) &sre,       // sre
                                XLISTEN_ALLOW_IREQM,  // listenopts
                                0);                   // listenertag
            if (lerr == XSRETYPE_IREQ) {
                bool mon_msg = (sre.sre_flags & XSRE_MON);
                if (gverbose)
                    printf("client LISTEN mon-msg=%d\n", mon_msg);
                assert(mon_msg);
                int msg_size = sre.sre_reqDataSize;
                char *msg = new char[msg_size];
                ferr = XMSG_READDATA_(sre.sre_msgId,      // msgid
                                      msg,                // reqdata
                                      (ushort) msg_size); // bytecount
                assert(ferr == XZFIL_ERR_OK);
                MS_Mon_Msg *msgp = (MS_Mon_Msg *) msg;

                switch (msgp->type) {
                case MS_MsgType_NodeDown:
                    if (gverbose)
                        printf("client mon-msg-type=node-down(%d)\n", msgp->type);
                    node_change = true;
                    break;
                case MS_MsgType_NodeUp:
                    if (gverbose)
                        printf("client mon-msg-type=node-up(%d)\n", msgp->type);
                    node_change = true;
                    break;
                case MS_MsgType_ProcessDeath:
                    if (gverbose)
                        printf("client mon-msg-type=proc-death(%d)\n", msgp->type);
                    break;
                default:
                    if (gverbose)
                        printf("client mon-msg-type=%d\n", msgp->type);
                    break;
                }
                XMSG_REPLY_(sre.sre_msgId,       // msgid
                            NULL,                // replyctrl
                            0,                   // replyctrlsize
                            NULL,                // replydata
                            0,                   // replydatasize
                            0,                   // errorclass
                            NULL);               // newphandle
                delete [] msg;
            }
        } while (lerr);
    }
}
Example #3
0
void *server_thr(void *arg) {
    int                 ferr;
    int                 lerr;
    int                 recv_len;
    BMS_SRE             sre;
    MyThread           *thr;
    int                 thrinx;

    thr = (MyThread *) arg;
    thrinx = thr->inx;
    // process requests
    for (;;) {
        do {
            lerr = XWAIT(LREQ, 100);
            lerr = BMSG_LISTEN_((short *) &sre, // sre
                                0,              // listenopts
                                0);             // listenertag
            if ((lerr == XSRETYPE_NOWORK) &&
                (atomic_read(&msg_count) >= maxmsg))
                return NULL;
        } while (lerr == XSRETYPE_NOWORK);
        if (lerr == XSRETYPE_ABANDON)
            continue;
        if (sre.sre_flags & XSRE_MON) {
            ferr = XMSG_READDATA_(sre.sre_msgId,       // msgid
                                  recv_buffer[thrinx], // reqdata
                                  BUFSIZ);             // bytecount
            util_check("XMSG_READDATA_", ferr);
            MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer[thrinx];
            if (verbose)
                printf("server(%s): mon-msg type=%d\n", my_name, msg->type);
            if (msg->type == MS_MsgType_Close) {
                closes++;
                if (verbose)
                    printf("server(%s): closes=%d\n", my_name, closes);
            }
        } else {
            atomic_inc(&msg_count);
            if (verbose)
                printf("server(%s): msg-count=%d\n",
                       my_name, atomic_read(&msg_count));
        }
        recv_len = rnd(BUFSIZ);
        BMSG_REPLY_(sre.sre_msgId,       // msgid
                    NULL,                // replyctrl
                    0,                   // replyctrlsize
                    recv_buffer[thrinx], // replydata
                    recv_len,            // replydatasize
                    0,                   // errorclass
                    NULL);               // newphandle
        if (closes)
            break;
    }
    return NULL;
}
void *server_thr(void *arg) {
    int       ferr;
    int       lerr;
    int       max_msgs = gmaxc * gloop;
    bool      mon_msg;
    Test_SRE  sre;
    int       status;
    int       whoami = ginxs++;

    arg = arg; // touch
    for (;;) {
        if (gsre_count >= max_msgs)
            break;
        if (gshutdown)
            break;
        do {
            lerr = XWAIT(LREQ, 100);
            lerr = XMSG_LISTEN_((short *) &sre.sre,  // sre
                                0,                   // listenopts
                                0);                  // listenertag
        } while (lerr == XSRETYPE_NOWORK);
        mon_msg = (sre.sre.sre_flags & XSRE_MON);
        if (mon_msg) {
            int msg_size = sre.sre.sre_reqDataSize;
            char *msg = new char[msg_size];
            ferr = XMSG_READDATA_(sre.sre.sre_msgId,     // msgid
                                  msg,                   // reqdata
                                  (ushort) msg_size);    // bytecount
            assert(ferr == XZFIL_ERR_OK);
            pp_check_mon_msg(msg);
            pp_check_mon_msg_shutdown(msg);
            XMSG_REPLY_(sre.sre.sre_msgId,   // msgid
                        NULL,                // replyctrl
                        0,                   // replyctrlsize
                        NULL,                // replydata
                        0,                   // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
            delete [] msg;
            if (gshutdown)
                break;
        } else {
            status = gmutex.lock();
            TEST_CHK_STATUSOK(status);
            gsre_count++;
            status = gmutex.unlock();
            TEST_CHK_STATUSOK(status);
            if (gverbose)
                printf("s-%d: have work, sre-count=%d\n",
                       whoami, gsre_count);
            server(whoami, &sre);
        }
    }
    return NULL;
}
Example #5
0
int main(int argc, char *argv[]) {
    int     ferr;
    int     inx;
    int     len;
    int     lerr;
    int     loop = 10;
    char    my_name[BUFSIZ];
    char    recv_buffer[BUFSIZ];
    short   recv_buffer2[BUFSIZ];
    MS_SRE  sre;
    TAD     zargs[] = {
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init_role(false, &argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    ferr = msg_mon_process_startup(true); // system messages
    TEST_CHK_FEOK(ferr);
    util_gethostname(my_name, sizeof(my_name));

    for (inx = 0; inx < loop/2; inx++) {
        do {
            lerr = XWAIT(LREQ, -1);
            TEST_CHK_WAITIGNORE(lerr);
            lerr = XMSG_LISTEN_((short *) &sre, // sre
                                0,              // listenopts
                                0);             // listenertag
        } while (lerr == XSRETYPE_NOWORK);
        ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                              recv_buffer2,   // reqctrl
                              1);             // bytecount
        util_check("XMSG_READCTRL_", ferr);
        ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                              recv_buffer,    // reqdata
                              BUFSIZ);        // bytecount
        util_check("XMSG_READDATA_", ferr);
        strcat(recv_buffer, "- reply from ");
        strcat(recv_buffer, my_name);
        len = (int) strlen(recv_buffer) + 1;
        XMSG_REPLY_(sre.sre_msgId,       // msgid
                    recv_buffer2,        // replyctrl
                    sre.sre_reqCtrlSize, // replyctrlsize
                    recv_buffer,         // replydata
                    (ushort) len,        // replydatasize
                    0,                   // errorclass
                    NULL);               // newphandle
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    return 0;
}
int main(int argc, char *argv[]) {
    int     exit;
    int     ferr;
    int     lerr;
    char    name[BUFSIZ];
    char    recv_buffer[BUFSIZ];
    MS_SRE  sre;

    msfs_util_init_role(false, &argc, &argv, msg_debug_hook);
    ferr = msg_mon_process_startup(true); // system messages
    TEST_CHK_FEOK(ferr);
    msg_mon_enable_mon_messages(true);
    ferr = msg_mon_get_my_process_name(name, sizeof(name));
    TEST_CHK_FEOK(ferr);
    exit = 0;
    while (!exit) {
        do {
            lerr = XWAIT(LREQ, -1);
            TEST_CHK_WAITIGNORE(lerr);
            lerr = XMSG_LISTEN_((short *) &sre, // sre
                                0,              // listenopts
                                0);             // listenertag
        } while (lerr == XSRETYPE_NOWORK);
        ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                              recv_buffer,    // reqdata
                              BUFSIZ);        // bytecount
        util_check("XMSG_READDATA_", ferr);
        if (sre.sre_flags & XSRE_MON) {
            MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
            printf("srv %s: mon message, type=%d\n", name, msg->type);
            if (msg->type == MS_MsgType_Close)
                exit = 1;
        } else {
            printf("srv %s: NON-mon message\n", name);
        }
        XMSG_REPLY_(sre.sre_msgId,       // msgid
                    NULL,                // replyctrl
                    0,                   // replyctrlsize
                    NULL,                // replydata
                    0,                   // replydatasize
                    0,                   // errorclass
                    NULL);               // newphandle
    }
    printf("server %s shutting down\n", name);
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    return 0;
}
Example #7
0
void Server_Thread::work() {
    bool   done;
    int    ferr;
    int    lerr;
    char   recv_buffer[40000];
    MS_SRE sre;

    if (verbose)
        printf("server-%d thread starting\n", whoami);
    done = false;
    while (!done) {
        do {
            lerr = XWAIT(LREQ, -1);
            TEST_CHK_WAITIGNORE(lerr);
            lerr = XMSG_LISTEN_((short *) &sre, // sre
                                0,              // listenopts
                                0);             // listenertag
        } while (lerr == XSRETYPE_NOWORK);
        if (verbose)
            printf("server-%d thread processing msgid=%d\n",
                   whoami, sre.sre_msgId);
        ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                              NULL,           // reqctrl
                              0);             // bytecount
        util_check("XMSG_READCTRL_", ferr);
        ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                              recv_buffer,    // reqdata
                              40000);         // bytecount
        util_check("XMSG_READDATA_", ferr);
        if (sre.sre_flags & XSRE_MON) {
        } else if (sre.sre_reqDataSize > 0) {
            strcat(recv_buffer, "- reply from ");
            strcat(recv_buffer, my_name);
        } else
            done = true;
        XMSG_REPLY_(sre.sre_msgId,  // msgid
                    NULL,           // replyctrl
                    0,              // replyctrlsize
                    recv_buffer,    // replydata
                    39000,          // replydatasize
                    0,              // errorclass
                    NULL);          // newphandle
        if (delay)
            sleep(1);
    }
    if (verbose)
        printf("server-%d thread stopping\n", whoami);
}
Example #8
0
void server(int whoami, Test_SRE *sre) {
    static int      cnt = 1;
    int             ferr;
    int             len;
    char           *p;
    Util_AA<char>   recv_buffer(BUFSIZ);
    Util_AA<short>  recv_buffer2(BUFSIZ);
    bool            reply = true;

    if (abortserver) {
        cnt++;
        if (cnt >= loop * maxc * maxcp)
            util_abort_core_free();
    }
    ferr = XMSG_READCTRL_(sre->sre.sre_msgId,     // msgid
                          &recv_buffer2,          // reqctrl
                          1);                     // bytecount
    util_check("XMSG_READCTRL_", ferr);
    ferr = XMSG_READDATA_(sre->sre.sre_msgId,     // msgid
                          &recv_buffer,           // reqdata
                          BUFSIZ);                // bytecount
    util_check("XMSG_READDATA_", ferr);
    if (verbose)
        printf("s-%d: received %s\n", whoami, &recv_buffer);
    strcat(&recv_buffer, "- reply from ");
    strcat(&recv_buffer, my_name);
    if (abortserver) {
        p = index(&recv_buffer, '=');
        if (atoi(&p[1]) == (loop - 1))
            reply = false;
    }
    if (reply) {
        len = 100;
        if (verbose)
            printf("s-%d: sending %s\n", whoami, &recv_buffer);
        XMSG_REPLY_(sre->sre.sre_msgId,          // msgid
                    &recv_buffer2,               // replyctrl
                    sre->sre.sre_reqCtrlSize,    // replyctrlsize
                    &recv_buffer,                // replydata
                    (ushort) len,                // replydatasize
                    0,                           // errorclass
                    NULL);                       // newphandle
    }
}
int main(int argc, char *argv[]) {
    bool    client = false;
    int     count;
    int     ferr;
    int     inx;
    int     len;
    int     lerr;
    char    my_name[BUFSIZ];
    int     next;
    char    recv_buffer[BUFSIZ];
    short   recv_buffer2[BUFSIZ];
    MS_SRE  sre;

    ferr = msg_init(&argc, &argv);
    TEST_CHK_FEOK(ferr);
    ferr = msg_mon_process_startup(!client); // system messages
    TEST_CHK_FEOK(ferr);
    util_gethostname(my_name, sizeof(my_name));
    msg_mon_enable_mon_messages(true);

    for (count = 0; count < 2; count++) {
        next = 0;
        for (inx = 0;; inx++) {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  recv_buffer2,   // reqctrl
                                  1);             // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  BUFSIZ);        // bytecount
            util_check("XMSG_READDATA_", ferr);
            if (sre.sre_flags & XSRE_MON) {
                MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
                printf("tse received mon message, type=%d\n",
                       msg->type);
                switch (msg->type) {
                case MS_MsgType_Close:
                    next = 1;
                    break;
                case MS_MsgType_Open:
                    break;
                default:
                    break;
                }
                len = 0;
            } else {
                strcat(recv_buffer, "- reply from ");
                strcat(recv_buffer, my_name);
                len = (int) strlen(recv_buffer) + 1;
            }
            XMSG_REPLY_(sre.sre_msgId,       // msgid
                        recv_buffer2,        // replyctrl
                        sre.sre_reqCtrlSize, // replyctrlsize
                        recv_buffer,         // replydata
                        (ushort) len,        // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
            if (next)
                break;
        }
    }
    printf("tse shutting down\n");
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    return 0;
}
Example #10
0
int main(int argc, char *argv[]) {
    bool               client = false;
    int                ferr;
    int                inx;
    int                len;
    int                lerr;
    int                oid;
    void              *result;
    MS_SRE             sre;
    int                status;
    SB_Thread::Thread *thr_wait;
    TAD                zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    ferr = proc_set_process_completion();
    TEST_CHK_FEOK(ferr);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);
    if (client) {
        ferr = msg_mon_open_process((char *) "$srv",      // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
    }
    util_gethostname(my_name, sizeof(my_name));

    if (client) {
        thr_wait = new SB_Thread::Thread(thread_wait_fun, "wait");
        thr_wait->start();
        thr_send = new SB_Thread::Thread(thread_send_fun, "send");
        thr_send->start();
        thr_send_brk = new SB_Thread::Thread(thread_sendbrk_fun, "sendbrk");
        thr_send_brk->start();
        status = thr_send->join(&result);
        TEST_CHK_STATUSOK(status);
        status = thr_send_brk->join(&result);
        TEST_CHK_STATUSOK(status);
        delete thr_send;
        delete thr_send_brk;
        thr_send = NULL;
        thr_send_brk = NULL;
        status = thr_wait->join(&result);
        TEST_CHK_STATUSOK(status);
        delete thr_wait;
    } else {
        for (inx = 0; inx < loop; inx++) {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  NULL,           // reqctrl
                                  0);             // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  40000);         // bytecount
            util_check("XMSG_READDATA_", ferr);
            strcat(recv_buffer, "- reply from ");
            strcat(recv_buffer, my_name);
            len = (int) strlen(recv_buffer) + 1;
            len = len; // touch
            XMSG_REPLY_(sre.sre_msgId,  // msgid
                        NULL,           // replyctrl
                        0,              // replyctrlsize
                        recv_buffer,    // replydata
                        39000,          // replydatasize
                        0,              // errorclass
                        NULL);          // newphandle
        }
    }
    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #11
0
int main(int argc, char *argv[]) {
    bool                client = false;
    bool                client1 = false;
    bool                client2 = false;
    bool                client3 = false;
    int                 ferr;
    int                 inx;
    int                 lerr;
    int                 loop = 10;
    int                 msgid;
    int                 oid;
    TPT_DECL           (phandle);
    MS_Result_Type      results;
    MS_SRE              sre;
    MS_Mon_Transid_Type transid;
    TAD                 zargs[] = {
      { "-client1",   TA_Bool, TA_NOMAX,    &client1   },
      { "-client2",   TA_Bool, TA_NOMAX,    &client2   },
      { "-client3",   TA_Bool, TA_NOMAX,    &client3   },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    if (client1)
        client = true;
    if (client2)
        client = true;
    if (client3)
        client = true;
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);
    if (client) {
        ferr = msg_mon_open_process((char *) "$srv",      // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
    }
    util_gethostname(my_name, sizeof(my_name));

    if (client) {
        if (client1)
            sleep(5);
        else if (client2) {
            util_abort_core_free();
        } else {
            ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                              &msgid,                      // msgid
                              NULL,                        // reqctrl
                              0,                           // reqctrlsize
                              NULL,                        // replyctrl
                              0,                           // replyctrlmax
                              send_buffer,                 // reqdata
                              0,                           // reqdatasize
                              recv_buffer,                 // replydata
                              0,                           // replydatamax
                              0,                           // linkertag
                              0,                           // pri
                              0,                           // xmitclass
                              0);                          // linkopts
            util_check("XMSG_LINK_", ferr);
            ferr = XMSG_BREAK_(msgid, (short *) &results, TPT_REF(phandle));
            util_check("XMSG_BREAK_", ferr);
        }
    } else {
        msg_mon_enable_mon_messages(true);
        for (inx = 0; inx < 7; inx++) {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  40000);         // bytecount
            util_check("XMSG_READDATA_", ferr);
            if (sre.sre_flags & XSRE_MON) {
                MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
                if (msg->type == MS_MsgType_Open) {
                    if (strcasecmp(msg->u.open.target_process_name, "$cli2") == 0) {
                        transid.id[0] = -1;
                        transid.id[1] = -1;
                        transid.id[2] = -1;
                        transid.id[3] = -1;
                        ferr = msg_mon_deregister_death_notification(-1, // msg->u.open.nid,
                                                                     -1, // msg->u.open.pid,
                                                                     transid);
                        TEST_CHK_FEOK(ferr);
                    }
                }
                printf("server reply type=%d, inx=%d\n", msg->type, inx);
            } else
                printf("server reply inx=%d\n", inx);
            XMSG_REPLY_(sre.sre_msgId,  // msgid
                        NULL,           // replyctrl
                        0,              // replyctrlsize
                        recv_buffer,    // replydata
                        0,              // replydatasize
                        0,              // errorclass
                        NULL);          // newphandle
        }
    }
    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
int main(int argc, char *argv[]) {
    char           *cli;
    int             ferr;
    int             lerr;
    int             msgid;
    int             nid;
    int             oid;
    TPT_DECL       (phandle);
    int             pid;
    MS_Result_Type  results;
    int             send_len;
    const char     *sname = "$srv";
    MS_SRE          sre;

    ferr = msg_init(&argc, &argv);
    TEST_CHK_FEOK(ferr);
    ferr = msg_mon_process_startup(true);  // system messages?
    TEST_CHK_FEOK(ferr);
    ferr = msg_mon_get_my_process_name(pname, sizeof(pname));
    TEST_CHK_FEOK(ferr);
    msg_mon_enable_mon_messages(true);

    sprintf(prog, "%s/%s", getenv("PWD"), argv[0]);
    cli = strstr(prog, "cli");
    strcpy(cli, "srv");
    nid = 0;
    ferr = msg_mon_start_process_nowait(prog,                     // prog
                                        (char *) sname,           // name
                                        retname,                  // ret-name
                                        argc,                     // argc
                                        argv,                     // argv
                                        TPT_REF(phandle),         // phandle
                                        MS_ProcessType_Generic,   // type
                                        0,                        // priority
                                        false,                    // debug
                                        false,                    // backup
                                        0x123456789abcdefLL,      // tag
                                        &nid,                     // nid
                                        &pid,                     // pid
                                        NULL,                     // infile
                                        NULL);                    // outfile
    TEST_CHK_FEOK(ferr);
    assert(strcasecmp(retname, sname) == 0);
    assert(nid == 0);
    lerr = XWAIT(LREQ, -1);
    TEST_CHK_WAITIGNORE(lerr);
    for (;;) {
        lerr = XMSG_LISTEN_((short *) &sre, // sre
                            0,              // listenopts
                            0);             // listenertag
        if (lerr == XSRETYPE_NOWORK)
            continue;
        ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                              recv_buffer,    // reqdata
                              BUFSIZ);        // bytecount
        TEST_CHK_FEOK(ferr);
        if (sre.sre_flags & XSRE_MON) {
            MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
            printf("client (%s) received mon message, type=%d\n",
                   pname, msg->type);
            assert(msg->type == MS_MsgType_ProcessCreated);
            printf("client (%s) received new process message, ferr=%d, nid=%d, pid=%d, tag=0x%llx, pname=%s\n",
                   pname,
                   msg->u.process_created.ferr,
                   msg->u.process_created.nid,
                   msg->u.process_created.pid,
                   msg->u.process_created.tag,
                   msg->u.process_created.process_name);
            assert(msg->u.process_created.ferr == XZFIL_ERR_OK);
            assert(msg->u.process_created.tag == 0x123456789abcdefLL);
            ferr = msg_mon_open_process((char *) sname,       // name
                                        TPT_REF(phandle),
                                        &oid);
            TEST_CHK_FEOK(ferr);
        }
        XMSG_REPLY_(sre.sre_msgId,       // msgid
                    NULL,                // replyctrl
                    0,                   // replyctrlsize
                    NULL,                // replydata
                    0,                   // replydatasize
                    0,                   // errorclass
                    NULL);               // newphandle
        if (sre.sre_flags & XSRE_MON)
            break;
    }

    strcpy(send_buffer, "hello, greetings from client");
    send_len = (int) strlen(send_buffer) + 1;
    ferr = BMSG_LINK_(TPT_REF(phandle),            // phandle
                      &msgid,                      // msgid
                      NULL,                        // reqctrl
                      0,                           // reqctrlsize
                      recv_buffer3,                // replyctrl
                      1,                           // replyctrlmax
                      send_buffer,                 // reqdata
                      (ushort) send_len,           // reqdatasize
                      recv_buffer,                 // replydata
                      BUFSIZ,                      // replydatamax
                      0,                           // linkertag
                      0,                           // pri
                      0,                           // xmitclass
                      0);                          // linkopts
    TEST_CHK_FEOK(ferr);
    ferr = BMSG_BREAK_(msgid, (short *) &results, TPT_REF(phandle));
    TEST_CHK_FEOK(ferr);
    printf("%s\n", recv_buffer);

    ferr = msg_mon_close_process(TPT_REF(phandle));
    TEST_CHK_FEOK(ferr);
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    return 0;
}
Example #13
0
int main(int argc, char *argv[]) {
    bool                       client = false;
    int                        count;
    int                        disable;
    int                        ferr;
    MS_Mon_Open_Info_Type      info;
    MS_Mon_Open_Info_Max_Type  info_max[MAX_OPENS];
    int                        inx;
    int                        len;
    int                        lerr;
    int                        loop = 10;
    int                        msgid;
    int                        oid;
    TPT_DECL                  (phandle);
    RT                         results;
    int                        send_len;
    MS_SRE                     sre;
    TAD                        zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);
    // process-wait for server/shell
    ferr = msfs_util_wait_process_count(MS_ProcessType_Generic, 2, NULL, false);
    TEST_CHK_FEOK(ferr);
    // process-wait for client
    ferr = msfs_util_wait_process_count(MS_ProcessType_TSE, 1, NULL, false);
    TEST_CHK_FEOK(ferr);
    if (client) {
        ferr = msg_mon_open_process((char *) "$srv",      // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
    } else

    util_gethostname(my_name, sizeof(my_name));
    msg_mon_enable_mon_messages(true);

    for (inx = 0; inx < loop; inx++) {
        if (client) {
            sprintf(send_buffer, "hello, greetings from %s, inx=%d",
                    my_name, inx);
            send_len = (int) strlen(send_buffer) + 1;
            ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                              &msgid,                      // msgid
                              send_buffer2,                // reqctrl
                              (ushort) (inx & 1),          // reqctrlsize
                              recv_buffer3,                // replyctrl
                              1,                           // replyctrlmax
                              send_buffer,                 // reqdata
                              (ushort) send_len,           // reqdatasize
                              recv_buffer,                 // replydata
                              BUFSIZ,                      // replydatamax
                              0,                           // linkertag
                              0,                           // pri
                              0,                           // xmitclass
                              0);                          // linkopts
            util_check("XMSG_LINK_", ferr);
            ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle));
            util_check("XMSG_BREAK_", ferr);
            assert(results.u.t.ctrl_size == (uint) (inx & 1));
            assert(results.u.t.data_size > (strlen(send_buffer) + 14));
            assert(results.u.t.errm == RT_DATA_RCVD); // data
            printf("%s\n", recv_buffer);
        } else {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  recv_buffer2,   // reqctrl
                                  1);             // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  BUFSIZ);        // bytecount
            util_check("XMSG_READDATA_", ferr);
            if (sre.sre_flags & XSRE_MON) {
                printf("server received mon message\n");
                inx--;
                len = 0;
            } else {
                if (inx == 0) {
                    sleep(3); // wait for monitor replicate
                    disable = msg_test_assert_disable();
                    ferr = msg_mon_get_open_info(-1,
                                                 -1,
                                                 (char *) "$srv",
                                                 1,
                                                 &info);
                    assert(ferr == XZFIL_ERR_INVALOP);
                    ferr = msg_mon_get_open_info_max(-1,
                                                     -1,
                                                     (char *) "$srv",
                                                     false,
                                                     &count,
                                                     MAX_OPENS,
                                                     info_max);
                    assert(ferr == XZFIL_ERR_INVALOP);
                    msg_test_assert_enable(disable);
                }
                strcat(recv_buffer, "- reply from ");
                strcat(recv_buffer, my_name);
                len = (int) strlen(recv_buffer) + 1;
            }
            XMSG_REPLY_(sre.sre_msgId,       // msgid
                        recv_buffer2,        // replyctrl
                        sre.sre_reqCtrlSize, // replyctrlsize
                        recv_buffer,         // replydata
                        (ushort) len,        // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
        }
    }

    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    } else {
        ferr = msg_mon_process_close();
        TEST_CHK_FEOK(ferr);
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #14
0
int main(int argc, char *argv[]) {
    bool            client = false;
    int             ferr;
    int             inx;
    int             len;
    int             lerr;
    int             loop = 10;
    int             msgid;
    TPT_DECL2      (phandle,MAX_SERVERS);
    bool            rand = false;
    RT              results;
    int             send_len;
    MS_SRE          sre;
    MS_SRE_LDONE    sre_ldone;
    int             srv;
    int             srv2;
    TAD             zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-rand",      TA_Bool, TA_NOMAX,    &rand      },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client); // system messages
    TEST_CHK_FEOK(ferr);
    if (client) {
        for (srv = 0; srv < MAX_SERVERS; srv++) {
            sprintf(name, "$srv%d", srv);
            ferr = msg_mon_open_process(name,
                                        TPT_REF2(phandle,srv),
                                        &oid[srv]);
            TEST_CHK_FEOK(ferr);
        }
    }
    util_gethostname(my_name, sizeof(my_name));

    if (client) {
        for (inx = 0; inx < loop; inx++) {
            for (srv = 0; srv < MAX_SERVERS; srv++) {
                sprintf(send_buffer[srv], "hello, greetings from %s, inx=%d, srv=%d",
                        my_name, inx, srv);
                send_len = (int) strlen(send_buffer[srv]) + 1;
                ferr = XMSG_LINK_(TPT_REF2(phandle,srv),          // phandle
                                  &msgid,                         // msgid
                                  send_buffer2,                   // reqctrl
                                  (ushort) (inx & 1),             // reqctrlsize
                                  recv_buffer3[srv],              // replyctrl
                                  1,                              // replyctrlmax
                                  send_buffer[srv],               // reqdata
                                  (ushort) send_len,              // reqdatasize
                                  recv_buffer[srv],               // replydata
                                  BUFSIZ,                         // replydatamax
                                  (SB_Tag_Type) send_buffer[srv], // linkertag
                                  0,                              // pri
                                  0,                              // xmitclass
                                  XMSG_LINK_LDONEQ);              // linkopts
                util_check("XMSG_LINK_", ferr);
            }
            for (srv = 0; srv < MAX_SERVERS;) {
                if (rand)
                    util_time_sleep_ms(rnd());
                lerr = XWAIT(LDONE, -1);
                TEST_CHK_WAITIGNORE(lerr);
                for (;;) {
                    lerr = XMSG_LISTEN_((short *) &sre_ldone, // sre
                                        0,                    // listenopts
                                        0);                   // listenertag
                    if (lerr == XSRETYPE_NOWORK)
                        break;
                    srv++;
                    assert(lerr == XSRETYPE_LDONE);
                    for (srv2 = 0; srv2 < MAX_SERVERS; srv2++) {
                        if (sre_ldone.sre_linkTag ==
                            (SB_Tag_Type) send_buffer[srv2])
                            break;
                    }
                    assert(srv2 < MAX_SERVERS);
                    ferr = XMSG_BREAK_(sre_ldone.sre_msgId,
                                       results.u.s,
                                       TPT_REF2(phandle,srv2));
                    util_check("XMSG_BREAK_", ferr);
                    assert(results.u.t.ctrl_size == (uint) (inx & 1));
                    assert(results.u.t.data_size > (strlen(send_buffer[srv2]) + 14));
                    assert(results.u.t.errm == RT_DATA_RCVD); // data
                    printf("%s\n", recv_buffer[srv2]);
                }
            }
        }
    } else {
        for (inx = 0; inx < loop;) {
            lerr = XWAIT(LREQ, -1);
            lerr = XMSG_LISTEN_((short *) &sre, // sre
                                0,              // listenopts
                                0);             // listenertag
            if (lerr == XSRETYPE_NOWORK)
                continue;
            inx++;
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  recv_buffer2,   // reqctrl
                                  1);             // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer4,   // reqdata
                                  BUFSIZ);        // bytecount
            util_check("XMSG_READDATA_", ferr);
            strcat(recv_buffer4, "- reply from ");
            strcat(recv_buffer4, my_name);
            len = (int) strlen(recv_buffer4) + 1;
            if (rand)
                util_time_sleep_ms(rnd());
            XMSG_REPLY_(sre.sre_msgId,       // msgid
                        recv_buffer2,        // replyctrl
                        sre.sre_reqCtrlSize, // replyctrlsize
                        recv_buffer4,        // replydata
                        (ushort) len,        // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
        }
    }

    if (client) {
        for (srv = 0; srv < MAX_SERVERS; srv++) {
            ferr = msg_mon_close_process(TPT_REF2(phandle,srv));
            TEST_CHK_FEOK(ferr);
        }
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #15
0
int main(int argc, char *argv[]) {
    int                 abandon = 0;
    bool                client = false;
    int                 closes;
    int                 count;
    int                 count_abandon;
    int                 ferr;
    int                 inxl;
    int                 inxo;
    int                 inxs;
    int                 lerr;
    int                 loop = 10;
    int                 maxcp = 1;
    int                 maxout = 1;
    int                 maxsp = 1;
    int                 msgid[MAX_OUT];
    int                 msg_count;
    bool                mq = false;
    int                 oid;
    TPT_DECL2          (phandle, MAX_SRV);
    int                 recv_len;
    RT                  results;
    int                 send_len;
    char                serv[20];
    BMS_SRE             sre;
    bool                verbose = false;
    TAD                 zargs[] = {
      { "-abandon",   TA_Int,  TA_NOMAX,    &abandon   },
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-maxcp",     TA_Int,  MAX_CLI,     &maxcp     },
      { "-maxout",    TA_Int,  MAX_OUT,     &maxout    },
      { "-maxsp",     TA_Int,  MAX_SRV,     &maxsp     },
      { "-mq",        TA_Bool, TA_NOMAX,    &mq        },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "-v",         TA_Bool, TA_NOMAX,    &verbose   },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    ferr = msg_init(&argc, &argv);
    TEST_CHK_FEOK(ferr);
    msfs_util_init_fs(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);
    ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
    util_check("msg_mon_get_my_process_name", ferr);

    if (client) {
        ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT,
                                     XMAX_SETTABLE_SENDLIMIT);
        assert(ferr == XZFIL_ERR_OK);
        msg_count = 0;
        count_abandon = 0;
        for (inxl = 0; inxl < loop; inxl++) {
            for (inxs = 0; inxs < maxsp; inxs++) {
                sprintf(serv, "$srv%d", inxs);
                ferr = msg_mon_open_process((char *) serv,       // name
                                            TPT_REF2(phandle, inxs),
                                            &oid);
                TEST_CHK_FEOK(ferr);
            }
            count = 0;
            if (abandon)
                count_abandon = rnd(abandon);
            for (inxs = 0; inxs < maxsp; inxs++) {
                for (inxo = 0; inxo < maxout; inxo++) {
                    send_len = rnd(BUFSIZ);
                    ferr = BMSG_LINK_(TPT_REF2(phandle, inxs), // phandle
                                      &msgid[inxo],            // msgid
                                      NULL,                    // reqctrl
                                      0,                       // reqctrlsize
                                      NULL,                    // replyctrl
                                      0,                       // replyctrlmax
                                      send_buffer[inxo],       // reqdata
                                      send_len,                // reqdatasize
                                      recv_buffer[inxo],       // replydata
                                      BUFSIZ,                  // replydatamax
                                      0,                       // linkertag
                                      0,                       // pri
                                      0,                       // xmitclass
                                      0);                      // linkopts
                    util_check("XMSG_LINK_", ferr);
                }
            }
            for (inxs = 0; inxs < maxsp; inxs++) {
                for (inxo = 0; inxo < maxout; inxo++) {
                    msg_count++;
                    if (verbose)
                        printf("client(%s): msg-count=%d\n",
                               my_name, msg_count);
                    count++;
                    if (abandon && (count >= count_abandon)) {
                        if (verbose)
                            printf("client(%s): sending abandon, count=%d\n",
                                   my_name, count);
                        count_abandon = rnd(abandon);
                        count = 0;
                        ferr = XMSG_ABANDON_(msgid[inxo]);
                        util_check("XMSG_ABANDON_", ferr);
                    } else {
                        ferr = BMSG_BREAK_(msgid[inxo],
                                           results.u.s,
                                           TPT_REF2(phandle, inxs));
                        util_check("XMSG_BREAK_", ferr);
                    }
                }
            }
            if (mq) {
                if ((inxl % 100) == 0)
                    printf("client(%s): count=%d\n", my_name, inxl);
            }
        }
        for (inxs = 0; inxs < maxsp; inxs++) {
            ferr = msg_mon_close_process(TPT_REF2(phandle, inxs));
            TEST_CHK_FEOK(ferr);
        }
    } else {
        ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT,
                                     XMAX_SETTABLE_RECVLIMIT);
        assert(ferr == XZFIL_ERR_OK);
        closes = 0;
        msg_count = 0;
        msg_mon_enable_mon_messages(true);
        // process requests
        for (;;) {
            do {
                lerr = XWAIT(LREQ, -1);
                lerr = BMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            if (sre.sre_flags & XSRE_MON) {
                ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                      recv_buffer[0], // reqdata
                                      BUFSIZ);        // bytecount
                util_check("XMSG_READDATA_", ferr);
                MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer[0];
                if (verbose)
                    printf("server(%s): mon-msg type=%d\n",
                           my_name, msg->type);
                if (msg->type == MS_MsgType_Close) {
                    closes++;
                    if (verbose)
                        printf("server(%s): closes=%d\n",
                               my_name, closes);
                }
            } else {
                msg_count++;
                if (verbose)
                    printf("server(%s): msg-count=%d\n",
                           my_name, msg_count);
            }
            recv_len = rnd(BUFSIZ);
            BMSG_REPLY_(sre.sre_msgId,       // msgid
                        NULL,                // replyctrl
                        0,                   // replyctrlsize
                        recv_buffer[0],      // replydata
                        recv_len,            // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
            if (closes >= maxcp)
                break;
        }
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #16
0
int main(int argc, char *argv[]) {
    bool            attach = false;
    bool            chook = false;
    bool            client = false;
    const char     *cname = "$cli";
    int             count;
    int             ferr;
    int             inx;
    int             len;
    int             lerr;
    int             loop = 10;
    int             msgid;
    int             oid;
    TPT_DECL       (phandle);
    char           *pname = NULL;
    RT              results;
    int             send_len;
    bool            shook = false;
    const char     *sname = "$srv";
    MS_SRE          sre;
    long            t_elapsed;
    struct timeval  t_start;
    struct timeval  t_stop;
    TAD             zargs[] = {
      { "-attach",    TA_Bool, TA_NOMAX,    &attach    },
      { "-chook",     TA_Bool, TA_NOMAX,    &chook     },
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-cname",     TA_Str,  TA_NOMAX,    &cname     },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-name",      TA_Str,  TA_NOMAX,    &pname     },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "-shook",     TA_Bool, TA_NOMAX,    &shook     },
      { "-sname",     TA_Str,  TA_NOMAX,    &sname     },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    arg_proc_args(zargs, false, argc, argv);
    if (client && chook)
        test_debug_hook("c", "c");
    if (!client && shook)
        test_debug_hook("s", "s");

    if (attach)
        msfs_util_init_attach(&argc, &argv, msg_debug_hook, false, pname);
    else
        msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_time_timer_start(&t_start);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);

    // process-wait for server/shell
    ferr = msfs_util_wait_process_count(MS_ProcessType_Generic, 2, NULL, false);
    TEST_CHK_FEOK(ferr);
    // process-wait for client
    ferr = msfs_util_wait_process_count(MS_ProcessType_TSE, 1, NULL, false);
    TEST_CHK_FEOK(ferr);
    if (client) {
        ferr = msg_mon_open_process((char *) sname,       // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
    }

    util_gethostname(my_name, sizeof(my_name));
    msg_mon_enable_mon_messages(true);
    if (client) {
        ferr = msg_mon_get_process_info_type(MS_ProcessType_TSE,
                                             &count,
                                             0,
                                             NULL);
        TEST_CHK_FEOK(ferr);
        if (!attach)
            assert(count == 1);
        ferr = msg_mon_get_process_info_type(MS_ProcessType_TSE,
                                             &count,
                                             1,
                                             info);
        TEST_CHK_FEOK(ferr);
        if (!attach)
            assert(count == 1);
    }

    for (inx = 0; inx < loop; inx++) {
        if (client) {
            sprintf(send_buffer, "hello, greetings from %s, inx=%d",
                    my_name, inx);
            send_len = (int) strlen(send_buffer) + 1;
            ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                              &msgid,                      // msgid
                              send_buffer2,                // reqctrl
                              (ushort) (inx & 1),          // reqctrlsize
                              recv_buffer3,                // replyctrl
                              1,                           // replyctrlmax
                              send_buffer,                 // reqdata
                              (ushort) send_len,           // reqdatasize
                              recv_buffer,                 // replydata
                              BUFSIZ,                      // replydatamax
                              0,                           // linkertag
                              (short) (inx+1),             // pri
                              0,                           // xmitclass
                              0);                          // linkopts
            util_check("XMSG_LINK_", ferr);
            ferr = XMSG_BREAK_(msgid,
                               results.u.s,
                               TPT_REF(phandle));
            util_check("XMSG_BREAK_", ferr);
            assert(results.u.t.ctrl_size == (uint) (inx & 1));
            assert(results.u.t.data_size > (strlen(send_buffer) + 14));
            assert(results.u.t.errm == RT_DATA_RCVD); // data
            printf("%s\n", recv_buffer);
        } else {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  recv_buffer2,   // reqctrl
                                  1);             // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  BUFSIZ);        // bytecount
            util_check("XMSG_READDATA_", ferr);
            if (sre.sre_flags & XSRE_MON) {
                printf("server received mon message\n");
                inx--;
                len = 0;
            } else {
                strcat(recv_buffer, "- reply from ");
                strcat(recv_buffer, my_name);
                len = (int) strlen(recv_buffer) + 1;
            }
            XMSG_REPLY_(sre.sre_msgId,       // msgid
                        recv_buffer2,        // replyctrl
                        sre.sre_reqCtrlSize, // replyctrlsize
                        recv_buffer,         // replydata
                        (ushort) len,        // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
        }
    }

    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    } else {
        ferr = msg_mon_process_close();
        TEST_CHK_FEOK(ferr);
    }
    util_time_timer_stop(&t_stop);
    t_elapsed = (t_stop.tv_sec * 1000000 + t_stop.tv_usec) -
                (t_start.tv_sec * 1000000 + t_start.tv_usec);
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    if (client)
        printf("elapsed time (gettimeofday us)=%ld\n", t_elapsed);
    return 0;
}
Example #17
0
int main(int argc, char *argv[]) {
    bool      client = false;
    int       event_len;
    int       ferr;
    int       inx;
    int       len;
    int       lerr;
    int       linx;
    int       loop = 10;
    int       msgid;
    int       oid;
    TPT_DECL (phandle);
    RT        results;
    int       send_len;
    int       srv_nid = -1;
    int       srv_pid = -1;
    MS_SRE    sre;
    TAD       zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);
    if (client) {
        ferr = msg_mon_open_process((char *) "$srv",      // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
        ferr = msg_mon_get_process_info((char *) "$srv", &srv_nid, &srv_pid);
        TEST_CHK_FEOK(ferr);
    }

    util_gethostname(my_name, sizeof(my_name));
    msg_mon_enable_mon_messages(true);

    for (inx = 0; inx < MS_MON_MAX_SYNC_DATA; inx++)
        event_data[inx] = (char) (inx + 1);
    for (inx = 0; inx < loop; inx++) {
        if (client) {
            sprintf(send_buffer, "hello, greetings from %s, inx=%d",
                    my_name, inx);
            send_len = (int) strlen(send_buffer) + 1;
            ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                              &msgid,                      // msgid
                              send_buffer2,                // reqctrl
                              (ushort) (inx & 1),          // reqctrlsize
                              recv_buffer3,                // replyctrl
                              1,                           // replyctrlmax
                              send_buffer,                 // reqdata
                              (ushort) send_len,           // reqdatasize
                              recv_buffer,                 // replydata
                              BUFSIZ,                      // replydatamax
                              0,                           // linkertag
                              0,                           // pri
                              0,                           // xmitclass
                              0);                          // linkopts
            util_check("XMSG_LINK_", ferr);
            lerr = XWAIT(LDONE, 10);
            TEST_CHK_WAITIGNORE(lerr);
            assert(!XMSG_ISDONE_(msgid));
            ferr =
              msg_mon_event_send(srv_nid,                    // nid
                                 srv_pid,                    // pid
                                 MS_ProcessType_Undefined,   // process-type
                                 inx,                        // event-id
                                 inx % MS_MON_MAX_SYNC_DATA, // event-len
                                 event_data);                // event-data
            TEST_CHK_FEOK(ferr);
            ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle));
            util_check("XMSG_BREAK_", ferr);
            assert(results.u.t.ctrl_size == (uint) (inx & 1));
            assert(results.u.t.data_size > (strlen(send_buffer) + 14));
            assert(results.u.t.errm == RT_DATA_RCVD); // data
            printf("%s\n", recv_buffer);
        } else {
            do {
                lerr = XWAIT(LREQ, -1);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  recv_buffer2,   // reqctrl
                                  1);             // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  BUFSIZ);        // bytecount
            util_check("XMSG_READDATA_", ferr);
            if (sre.sre_flags & XSRE_MON) {
                printf("server received mon message\n");
                inx--;
                len = 0;
            } else {
                memset(event_data, 0, sizeof(event_data));
                ferr = msg_mon_event_wait(inx, &event_len, event_data);
                TEST_CHK_FEOK(ferr);
                assert(event_len == (inx % MS_MON_MAX_SYNC_DATA));
                for (linx = 0; linx < event_len; linx++)
                    assert(event_data[linx] == (linx + 1));
                strcat(recv_buffer, "- reply from ");
                strcat(recv_buffer, my_name);
                len = (int) strlen(recv_buffer) + 1;
            }
            XMSG_REPLY_(sre.sre_msgId,       // msgid
                        recv_buffer2,        // replyctrl
                        sre.sre_reqCtrlSize, // replyctrlsize
                        recv_buffer,         // replydata
                        (ushort) len,        // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
        }
    }

    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    } else {
        ferr = msg_mon_process_close();
        TEST_CHK_FEOK(ferr);
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #18
0
int main(int argc, char *argv[]) {
    bool               client = false;
    int                ferr;
    int                inx;
    int                len;
    int                lerr;
    int                oid;
    char               recv_buffer[BUFSIZ];
    short              recv_buffer2[BUFSIZ];
    MS_SRE             sre;
    int                status;
    SB_Thread::Thread *thr[MAX_THR];
    TAD                zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    if (client)
        printf("threads=%d, msgs-per-thread=%d, msgs=%d\n",
               MAX_THR, MAX_MSGS_PER_THR, MAX_MSGS);
    ferr = msg_mon_process_startup(!client); // system messages
    TEST_CHK_FEOK(ferr);
    if (client) {
        ferr = msg_mon_open_process((char *) "$srv",      //  name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
    }
    util_gethostname(my_name, sizeof(my_name));

    if (client) {
        for (inx = 0; inx < MAX_THR; inx++) {
            char name[10];
            sprintf(name, "c%d", inx);
            thr[inx] = new SB_Thread::Thread(client_thr, name);
        }
        for (inx = 0; inx < MAX_THR; inx++)
            thr[inx]->start();
        for (inx = MAX_THR - 1; inx >= 0; inx--) {
            void *res;
            status = thr[inx]->join(&res);
            TEST_CHK_STATUSOK(status);
            printf("joined with client %d\n", inx);
        }
        for (inx = 0; inx < MAX_THR; inx++)
            delete thr[inx];
    } else {
        for (inx = 0; inx < MAX_MSGS;) {
            lerr = XWAIT(LREQ, -1);
            TEST_CHK_WAITIGNORE(lerr);
            do {
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
                if (lerr == XSRETYPE_IREQ) {
                    inx++;
                    ferr = XMSG_READCTRL_(sre.sre_msgId,    // msgid
                                          recv_buffer2,     // reqctrl
                                          1);               // bytecount
                    util_check("XMSG_READCTRL_", ferr);
                    ferr = XMSG_READDATA_(sre.sre_msgId,    // msgid
                                          recv_buffer,      // reqdata
                                          BUFSIZ);          // bytecount
                    util_check("XMSG_READDATA_", ferr);
                    strcat(recv_buffer, "- reply from ");
                    strcat(recv_buffer, my_name);
                    len = (int) strlen(recv_buffer) + 1;
                    XMSG_REPLY_(sre.sre_msgId,       // msgid
                                recv_buffer2,        // replyctrl
                                sre.sre_reqCtrlSize, // replyctrlsize
                                recv_buffer,         // replydata
                                (ushort) len,        // replydatasize
                                0,                   // errorclass
                                NULL);               // newphandle
                } else {
                    assert(lerr == XSRETYPE_NOWORK);
                }
            } while (lerr != XSRETYPE_NOWORK);
        }
    }

    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    }
    printf("%s shutting down\n", client ? "client" : "server");
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #19
0
int main(int argc, char *argv[]) {
    bool       client = false;
    unsigned   expR3;
    int        ferr;
    int        inx;
    int        lc;
    int        lerr;
    int        msgid;
    int        oid;
    RT         results;
    TPT_DECL  (phandle);
    MS_SRE     sre;
    TAD        zargs[] = {
        { "-client",    TA_Bool, TA_NOMAX,    &client    },
        { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
        { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client); // system messages
    TEST_CHK_FEOK(ferr);
    if (client) {
        ferr = msg_mon_open_process((char *) "$srv",      // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
    }
    util_gethostname(my_name, sizeof(my_name));

    lc = (int) (sizeof(res)/sizeof(Test_Results));
    for (inx = 0; inx < lc; inx++) {
        if (client) {
            sprintf(send_buffer, "hello, greetings from %s, inx=%d",
                    my_name, inx);
            ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                              &msgid,                      // msgid
                              ctrl_buffer,                 // reqctrl
                              res[inx].cQc,                // reqctrlsize
                              ctrl_buffer,                 // replyctrl
                              res[inx].cPcM,               // replyctrlmax
                              send_buffer,                 // reqdata
                              res[inx].cQd,                // reqdatasize
                              recv_buffer,                 // replydata
                              res[inx].cPdM,               // replydatamax
                              0,                           // linkertag
                              0,                           // pri
                              0,                           // xmitclass
                              0);                          // linkopts
            util_check("XMSG_LINK_", ferr);
//          ferr = XMSG_ISDONE_(msgid);
//          checkdone("XMSG_ISDONE_", ferr);
            results.u.t.ctrl_size = (uint) -1;
            results.u.t.data_size = (uint) -1;
            results.u.t.errm = (uint) -1;
            ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle));
            util_check("XMSG_BREAK_", ferr);
            if (results.u.t.ctrl_size != res[inx].cEpC) {
                printf("*** ERROR inx=%d, results.ctrl_size=%d, cEpC=%d\n",
                       inx, (int) results.u.t.ctrl_size, (int) res[inx].cEpC);
                assert(results.u.t.ctrl_size == res[inx].cEpC);
            }
            if (results.u.t.data_size != (uint) res[inx].cEpD) {
                printf("*** ERROR inx=%d, results.data_size=%d, cEpD=%d\n",
                       inx, (int) results.u.t.data_size, (int) res[inx].cEpD);
                assert(results.u.t.data_size == res[inx].cEpD);
            }
            expR3 = 0x0; // no-data
            if (res[inx].cEpD > 0)
                expR3 |= 0x2; // data
            if (results.u.t.errm != expR3) {
                printf("*** ERROR inx=%d, results.errm=%x, expR3=%x\n",
                       inx, results.u.t.errm, expR3);
                assert(results.u.t.errm == expR3);
            }
        } else {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            if (sre.sre_reqCtrlSize != res[inx].sEqC) {
                printf("*** ERROR inx=%d, sre.sre_reqCtrlSize=%d, sEqC=%d\n",
                       inx, sre.sre_reqCtrlSize, res[inx].sEqC);
                assert(sre.sre_reqCtrlSize == res[inx].sEqC);
            }
            if (sre.sre_reqDataSize != res[inx].sEqD) {
                printf("*** ERROR inx=%d, sre.sre_reqDataSize=%d, sEqD=%d\n",
                       inx, sre.sre_reqDataSize, res[inx].sEqD);
                assert(sre.sre_reqDataSize == res[inx].sEqD);
            }
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  ctrl_buffer,    // reqctrl
                                  res[inx].sQc);  // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  res[inx].sQd);  // bytecount
            util_check("XMSG_READDATA_", ferr);
            XMSG_REPLY_(sre.sre_msgId,            // msgid
                        (short *) recv_buffer,    // replyctrl
                        res[inx].sPc,             // replyctrlsize
                        recv_buffer,              // replydata
                        res[inx].sPd,             // replydatasize
                        0,                        // errorclass
                        NULL);                    // newphandle
        }
    }
    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
        printf("if there were no asserts, all is well\n");
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #20
0
int main(int argc, char *argv[]) {
    int        csize = 0;
    int        dinx;
    int        dloop = MAX_OUT;
    int        dsize = MAX_DBUF;
    int        ferr;
    TPT_DECL2 (phandle,MAX_SERVERS);
    int        inx;
    int        lerr;
    int        loop = 10;
    int        max;
    int        maxsp = 1;
    int        msgids[MAX_SERVERS * MAX_OUT];
    int        oid;
    int        pinx;
    short     *reqctrl;
    char      *reqdata;
    short     *repctrl;
    char      *repdata;
    RT         results;
    MS_SRE     sre;
    bool       verbose = false;
    int        xinx;
    TAD        zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-csize",     TA_Int,  MAX_CBUF,    &csize     },
      { "-dloop",     TA_Int,  MAX_OUT,     &dloop     },
      { "-dsize",     TA_Int,  MAX_DBUF,    &dsize     },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-maxcp",     TA_Int,  MAX_CLIENTS, &maxcp     },
      { "-maxsp",     TA_Int,  MAX_SERVERS, &maxsp     },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "-v",         TA_Bool, TA_NOMAX,    &verbose   },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    ferr = msg_init(&argc, &argv);
    TEST_CHK_FEOK(ferr);
    msfs_util_init_fs(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    if (maxcp < 0)
        maxcp = 1;
    if (maxsp < 0)
        maxsp = 1;
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);
    if (!client)
        msg_mon_enable_mon_messages(true);
    ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
    TEST_CHK_FEOK(ferr);

    // process-wait for clients/servers/shell
    ferr = msfs_util_wait_process_count(MS_ProcessType_Generic,
                                        maxcp + maxsp + 1,
                                        NULL,
                                        verbose);
    TEST_CHK_FEOK(ferr);
    sleep(3); // wait for all process_count's to complete
    if (client) {
        pinx = atoi(&my_name[4]);
        assert(pinx >= 0);
        printf("loop=%d\n", loop);
        for (inx = 0; inx < loop; inx++) {
            for (pinx = 0; pinx < maxsp; pinx++) {
                sprintf(serv, "$srv%d", pinx);
                ferr = msg_mon_open_process(serv,
                                            TPT_REF2(phandle,pinx),
                                            &oid);
                TEST_CHK_FEOK(ferr);
            }
            for (pinx = 0; pinx < maxsp; pinx++) {
                for (dinx = 0; dinx < dloop; dinx++) {
                    xinx = pinx * maxsp + dinx;
                    reqctrl = &send_buffer2[xinx * csize];
                    repctrl = &recv_buffer3[xinx * csize];
                    reqdata = &send_buffer[xinx * dsize];
                    repdata = &recv_buffer[xinx * dsize];
                    ferr = XMSG_LINK_(TPT_REF2(phandle,pinx), // phandle
                                      &msgids[xinx],          // msgid
                                      reqctrl,                // reqctrl
                                      (short) csize,          // reqctrlsize
                                      repctrl,                // replyctrl
                                      (short) csize,          // replyctrlmax
                                      reqdata,                // reqdata
                                      (short) dsize,          // reqdatasize
                                      repdata,                // replydata
                                      (short) dsize,          // replydatamax
                                      0,                      // linkertag
                                      0,                      // pri
                                      0,                      // xmitclass
                                      0);                     // linkopts
                    util_check("XMSG_LINK_", ferr);
                }
            }
            for (pinx = 0; pinx < maxsp; pinx++) {
                for (dinx = 0; dinx < dloop; dinx++) {
                    xinx = pinx * maxsp + dinx;
                    ferr = XMSG_BREAK_(msgids[xinx],
                                       results.u.s,
                                       TPT_REF2(phandle,pinx));
                    util_check("XMSG_BREAK_", ferr);
                    assert((int) results.u.t.ctrl_size == csize);
                    assert((int) results.u.t.data_size == dsize);
                    assert(results.u.t.errm == RT_DATA_RCVD); // data
                }
                if (verbose)
                    printf("%s-open-count=%d\n", my_name, inx);
            }
            for (pinx = 0; pinx < maxsp; pinx++) {
                ferr = msg_mon_close_process(TPT_REF2(phandle,pinx));
                TEST_CHK_FEOK(ferr);
                if (verbose)
                    printf("%s-close-count=%d\n", my_name, inx);
            }
        }
    } else {
        max = 2 * maxcp * loop + maxcp * dloop * loop;
        for (inx = 0; inx < max; inx++) {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_READCTRL_(sre.sre_msgId,        // msgid
                                  recv_buffer2,         // reqctrl
                                  sre.sre_reqCtrlSize); // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,        // msgid
                                  recv_buffer,          // reqdata
                                  sre.sre_reqDataSize); // bytecount
            util_check("XMSG_READDATA_", ferr);
            XMSG_REPLY_(sre.sre_msgId,         // msgid
                        recv_buffer2,          // replyctrl
                        sre.sre_reqCtrlSize,   // replyctrlsize
                        recv_buffer,           // replydata
                        sre.sre_reqDataSize,   // replydatasize
                        0,                     // errorclass
                        NULL);                 // newphandle
            if (verbose)
                printf("%s-count=%d\n", my_name, inx);
        }
    }

    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #21
0
int main(int argc, char *argv[]) {
    char                      *args[4];
    bool                       attach = false;
    bool                       chook = false;
    bool                       client = false;
    bool                       clientd = false;
    int                        cli_nid = -1;
    int                        cli_pid = -1;
    const char                *cname = "$cli";
    int                        count;
    int                        ferr;
    int                        inx;
    int                        len;
    int                        lerr;
    int                        loop = 10;
    TPT_DECL                  (mphandle);
    char                      *mphandlec = (char *) &mphandle;
    TPT_DECL_INT              (mphandlei);
    int                        msgid;
    int                        my_mon_nid;
    int                        my_mon_pid;
    int                        my_mon_ptype;
    int                        my_mon_zid;
    int                        my_os_pid;
    long                       my_os_tid;
    int                        my_compid;
    int                        my_pnid;
    int                        my_segid;
    int                        nid;
    int                        oid;
    TPT_DECL                  (phandle);
    int                        pid;
    char                      *pname = NULL;
    int                        ptype;
    RT                         results;
    int                        scollpid = -1;
    int                        scompid = -1;
    int                        send_len;
    bool                       shook = false;
    const char                *sname = "$srv";
    bool                       sonar = false;
    MS_SRE                     sre;
    int                        srv_nid = -1;
    int                        srv_pid = -1;
    MS_Mon_Monitor_Stats_Type  stats;
    int                        status;
    long                       t_elapsed;
    struct timeval             t_start;
    struct timeval             t_stop;
    int                        tm_seq;
    bool                       val_bool;
    int                        val_int;
    const char                *val_str;
    int                        winx;
    pid_t                      wpid;
    TAD                        zargs[] = {
        { "-attach",    TA_Bool, TA_NOMAX,    &attach    },
        { "-chook",     TA_Bool, TA_NOMAX,    &chook     },
        { "-client",    TA_Bool, TA_NOMAX,    &client    },
        { "-clientd",   TA_Bool, TA_NOMAX,    &clientd   },
        { "-cname",     TA_Str,  TA_NOMAX,    &cname     },
        { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
        { "-name",      TA_Str,  TA_NOMAX,    &pname     },
        { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
        { "-shook",     TA_Bool, TA_NOMAX,    &shook     },
        { "-sname",     TA_Str,  TA_NOMAX,    &sname     },
        { "-sonar",     TA_Bool, TA_NOMAX,    &sonar     },
        { "",           TA_End,  TA_NOMAX,    NULL       }
    };

#ifdef DEBUG_ENV
    env = environ;
    while (*env != NULL) {
        printf("env=%s\n", *env);
        env++;
    }
#endif

    arg_proc_args(zargs, false, argc, argv);
    if (client && chook)
        test_debug_hook("c", "c");
    if (!client && shook)
        test_debug_hook("s", "s");

    setenv("TESTKEYBOOL", "1", 1);
    setenv("TESTKEYINT", "44", 1);
    setenv("TESTKEYSTR", "TESTVALSTR", 1);
    //
    // test msg_getenv* before msg_init
    //
    val_bool = true;
    msg_getenv_bool("TESTKEYBOOL", &val_bool);
    assert(val_bool);
    val_bool = false;
    msg_getenv_bool("TESTKEYBOOL", &val_bool);
    assert(!val_bool);
    val_int = 0;
    msg_getenv_int("TESTKEYINT", &val_int);
    assert(val_int == 0);
    val_int = 1;
    msg_getenv_int("TESTKEYINT", &val_int);
    assert(val_int == 1);
    val_str = (const char *) 1;
    val_str = msg_getenv_str("TESTKEYSTR");
    assert(val_str == NULL);

    if (attach)
        msfs_util_init_attach(&argc, &argv, msg_debug_hook, false, pname);
    else
        msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_time_timer_start(&t_start);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);

    //
    // test msg_getenv* after msg_init
    //
    msg_getenv_bool("TESTKEYBOOL", &val_bool);
    assert(val_bool);
    msg_getenv_int("TESTKEYINT", &val_int);
    assert(val_int == 44);
    val_str = msg_getenv_str("TESTKEYSTR");
    assert(strcmp(val_str, "TESTVALSTR") == 0);

    // process-wait for server/shell
    ferr = msfs_util_wait_process_count(MS_ProcessType_Generic, 2, NULL, false);
    TEST_CHK_FEOK(ferr);
    // process-wait for client
    ferr = msfs_util_wait_process_count(MS_ProcessType_TSE, 1, NULL, false);
    TEST_CHK_FEOK(ferr);
    if (client) {
        if (sonar) {
            scollpid = fork();
            if (scollpid == 0) {
                // child
                args[0] = (char *) "sonarcollector";
                args[1] = (char *) "-i"; // sampling interval // cast
                args[2] = (char *) "1"; // cast
                args[3] = NULL;
                lerr = execvp(args[0], args);
                assert(lerr == 0);
            }
        }
        ferr = msg_mon_open_process((char *) sname,       // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
    }

    // this phandle check assumed a particular data structure
    ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
    util_check("msg_mon_get_my_process_name", ferr);
    ferr = XPROCESSHANDLE_GETMINE_(TPT_REF(mphandle));
    util_check("XPROCESSHANDLE_GETMINE_", ferr);
    TPT_COPY_INT(mphandlei, mphandle);
    assert((mphandlei[0] & 0xf0) == 0x20); // named
    assert(strncmp(my_name, &mphandlec[4], 32) == 0);
    printf("phandle=%x.%x.%x.%x.%x\n",
           mphandlei[0],
           mphandlei[1],
           mphandlei[2],
           mphandlei[3],
           mphandlei[4]);
    ferr = msg_mon_get_my_info(&my_mon_nid,
                               &my_mon_pid,
                               my_mon_name,
                               BUFSIZ,
                               &my_mon_ptype,
                               &my_mon_zid,
                               &my_os_pid,
                               &my_os_tid);
    util_check("msg_mon_get_my_info", ferr);
    printf("nid=%d, pid=%d, name=%s, ptype=%d, zid=%d, os-pid=%d, os-tid=%ld\n",
           my_mon_nid,
           my_mon_pid,
           my_mon_name,
           my_mon_ptype,
           my_mon_zid,
           my_os_pid,
           my_os_tid);
    my_mon_nid   = -1;
    my_mon_pid   = -1;
    my_mon_ptype = -1;
    my_mon_zid   = -1;
    my_os_pid    = -1;
    my_os_tid    = -1;
    my_compid    = -1;
    my_pnid      = -1;
    ferr = msg_mon_get_my_info3(&my_mon_nid,
                                &my_mon_pid,
                                my_mon_name3,
                                BUFSIZ,
                                &my_mon_ptype,
                                &my_mon_zid,
                                &my_os_pid,
                                &my_os_tid,
                                &my_compid,
                                &my_pnid);
    util_check("msg_mon_get_my_info3", ferr);
    printf("nid=%d, pid=%d, name=%s, ptype=%d, zid=%d, os-pid=%d, os-tid=%ld, compid=%d, pnid=%d\n",
           my_mon_nid,
           my_mon_pid,
           my_mon_name3,
           my_mon_ptype,
           my_mon_zid,
           my_os_pid,
           my_os_tid,
           my_compid,
           my_pnid);
    ferr = msg_mon_get_my_segid(&my_segid);
    util_check("msg_mon_get_my_segid", ferr);
    printf("segid=%d\n", my_segid);

    ferr = msg_mon_get_monitor_stats(&stats);
    util_check("msg_mon_get_monitor_stats", ferr);
    printf("avail_min=%d, acquired_max=%d, buf_misses=%d\n",
           stats.avail_min, stats.acquired_max, stats.buf_misses);

    util_gethostname(my_name, sizeof(my_name));
    msg_mon_enable_mon_messages(true);
    ferr = msg_mon_get_tm_seq(&tm_seq);
    util_check("msg_mon_get_tm_seq", ferr);
    printf("tm_seq=%d\n", tm_seq);
    if (client) {
        ferr = msg_mon_get_process_info_type(MS_ProcessType_TSE,
                                             &count,
                                             0,
                                             NULL);
        TEST_CHK_FEOK(ferr);
        if (!attach)
            assert(count == 1);
        ferr = msg_mon_get_process_info_type(MS_ProcessType_TSE,
                                             &count,
                                             1,
                                             info);
        TEST_CHK_FEOK(ferr);
        if (!attach)
            assert(count == 1);
    }

    for (inx = 0; inx < loop; inx++) {
        if (client) {
            sprintf(send_buffer, "hello, greetings from %s, inx=%d",
                    my_name, inx);
            send_len = (int) strlen(send_buffer) + 1;
            ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                              &msgid,                      // msgid
                              send_buffer2,                // reqctrl
                              (ushort) (inx & 1),          // reqctrlsize
                              recv_buffer3,                // replyctrl
                              1,                           // replyctrlmax
                              send_buffer,                 // reqdata
                              (ushort) send_len,           // reqdatasize
                              recv_buffer,                 // replydata
                              BUFSIZ,                      // replydatamax
                              0,                           // linkertag
                              (short) (inx+1),             // pri
                              0,                           // xmitclass
                              0);                          // linkopts
            util_check("XMSG_LINK_", ferr);
            ferr = XMSG_BREAK_(msgid,
                               results.u.s,
                               TPT_REF(phandle));
            util_check("XMSG_BREAK_", ferr);
            assert(results.u.t.ctrl_size == (uint) (inx & 1));
            assert(results.u.t.data_size > (strlen(send_buffer) + 14));
            assert(results.u.t.errm == RT_DATA_RCVD); // data
            printf("%s\n", recv_buffer);
        } else {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_GETREQINFO_(MSGINFO_NID,
                                    sre.sre_msgId,
                                    &nid);
            util_check("XMSG_GETREQINFO_", ferr);
            ferr = XMSG_GETREQINFO_(MSGINFO_PID,
                                    sre.sre_msgId,
                                    &pid);
            util_check("XMSG_GETREQINFO_", ferr);
            ferr = XMSG_GETREQINFO_(MSGINFO_PTYPE,
                                    sre.sre_msgId,
                                    &ptype);
            util_check("XMSG_GETREQINFO_", ferr);
            if (sre.sre_flags & XSRE_MON) {
                // mon messages have our nid/pid
                if (srv_nid < 0) {
                    ferr = msg_mon_get_process_info((char *) "",
                                                    &srv_nid,
                                                    &srv_pid);
                    TEST_CHK_FEOK(ferr);
                }
                if (!clientd) {
                    assert(nid == srv_nid);
                    assert(pid == srv_pid);
                }
            } else {
                assert(sre.sre_pri == ((inx+1) & 0xffff));
                if (cli_nid < 0) {
                    ferr = msg_mon_get_process_info((char *) cname,
                                                    &cli_nid,
                                                    &cli_pid);
                    TEST_CHK_FEOK(ferr);
                }
                if (!attach)
                    assert(ptype == MS_ProcessType_TSE);
                assert(nid == cli_nid);
                assert(pid == cli_pid);
            }
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  recv_buffer2,   // reqctrl
                                  1);             // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  BUFSIZ);        // bytecount
            util_check("XMSG_READDATA_", ferr);
            if (sre.sre_flags & XSRE_MON) {
                printf("server received mon message\n");
                inx--;
                len = 0;
                if (clientd) {
                    MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
                    if (msg->type == MS_MsgType_Close)
                        inx = loop;
                }
            } else {
                strcat(recv_buffer, "- reply from ");
                strcat(recv_buffer, my_name);
                len = (int) strlen(recv_buffer) + 1;
            }
            XMSG_REPLY_(sre.sre_msgId,       // msgid
                        recv_buffer2,        // replyctrl
                        sre.sre_reqCtrlSize, // replyctrlsize
                        recv_buffer,         // replydata
                        (ushort) len,        // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
        }
    }
    if (sonar) {
        if (client) {
            // for some reason [monitor?], one 'sonarcom stop' doesn't stop coll
            for (winx = 0; winx < 20; winx++) {
                scompid = fork();
                if (scompid == 0) {
                    // child
                    args[0] = (char *) "sonarcom";
                    args[1] = (char *) "stop";
                    args[2] = NULL;
                    lerr = execvp(args[0], args);
                    assert(lerr == 0);
                }
                wpid = waitpid(scompid, &status, 0);
                assert(wpid == scompid);
                wpid = waitpid(scollpid, &status, WNOHANG);
                if (wpid == scollpid)
                    break;
                else
                    sleep(1);
            }
            assert(wpid == scollpid);
            ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                              &msgid,                      // msgid
                              NULL,                        // reqctrl
                              0,                           // reqctrlsize
                              NULL,                        // replyctrl
                              0,                           // replyctrlmax
                              NULL,                        // reqdata
                              0,                           // reqdatasize
                              NULL,                        // replydata
                              0,                           // replydatamax
                              0,                           // linkertag
                              0,                           // pri
                              0,                           // xmitclass
                              0);                          // linkopts
            TEST_CHK_FEOK(ferr);
            ferr = XMSG_BREAK_(msgid,
                               results.u.s,
                               TPT_REF(phandle));
            TEST_CHK_FEOK(ferr);
        } else {
            do {
                lerr = XWAIT(LREQ, -1);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            XMSG_REPLY_(sre.sre_msgId,       // msgid
                        NULL,                // replyctrl
                        0,                   // replyctrlsize
                        NULL,                // replydata
                        0,                   // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
        }
    }

    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    } else {
        if (!clientd) {
            ferr = msg_mon_process_close();
            TEST_CHK_FEOK(ferr);
        }
    }
    util_time_timer_stop(&t_stop);
    t_elapsed = (t_stop.tv_sec * 1000000 + t_stop.tv_usec) -
                (t_start.tv_sec * 1000000 + t_start.tv_usec);
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    if (client) {
        printf("elapsed time (gettimeofday us)=%ld\n", t_elapsed);
    }
    return 0;
}
Example #22
0
int main(int argc, char *argv[]) {
    bool            exit;
    int             ferr;
    int             lerr;
    int             msgid;
    int             nid;
    int             oid;
    int             pid;
    TPT_DECL       (phandle);
    char            recv_buffer[BUFSIZ];
    short           recv_buffer2[BUFSIZ];
    MS_Result_Type  results;
    MS_SRE          sre;

    ferr = msfs_util_init_role(true, &argc, &argv, msg_debug_hook);
    TEST_CHK_FEOK(ferr);
    util_test_start(true);
    ferr = msg_mon_process_startup(true); // system messages
    TEST_CHK_FEOK(ferr);
    msg_mon_enable_mon_messages(true);
    printf("cli: opening server\n");
    ferr = msg_mon_get_process_info((char *) "$srv", &nid, &pid);
    TEST_CHK_FEOK(ferr);
    printf("cli: server opened\n");
    ferr = msg_mon_open_process((char *) "$srv",      // name
                                TPT_REF(phandle),
                                &oid);
    TEST_CHK_FEOK(ferr);
    exit = false;
    while (!exit) {
        lerr = XWAIT(LREQ, -1);
        TEST_CHK_WAITIGNORE(lerr);
        for (;;) {
            lerr = XMSG_LISTEN_((short *) &sre, // sre
                                0,              // listenopts
                                0);             // listenertag
            if (lerr == XSRETYPE_NOWORK)
                break;
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  BUFSIZ);        // bytecount
            util_check("XMSG_READDATA_", ferr);
            if (sre.sre_flags & XSRE_MON) {
                MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
                printf("cli: mon message, type=%d\n", msg->type);
                if (msg->type == MS_MsgType_Open) {
                    ferr = msg_mon_get_process_info((char *) "$srv", &nid, &pid);
                    TEST_CHK_FEOK(ferr);
                    assert(msg->u.open.nid == nid);
                    assert(msg->u.open.pid == pid);
                    assert(strcasecmp(msg->u.open.target_process_name, "$srv") == 0);
                    exit = true;
                }
            } else {
                printf("cli: NON-mon message\n");
            }
            XMSG_REPLY_(sre.sre_msgId,       // msgid
                        NULL,                // replyctrl
                        0,                   // replyctrlsize
                        NULL,                // replydata
                        0,                   // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
        }
    }
    printf("cli: sending message to server\n");
    ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                      &msgid,                      // msgid
                      NULL,                        // reqctrl
                      0,                           // reqctrlsize
                      recv_buffer2,                // replyctrl
                      1,                           // replyctrlmax
                      NULL,                        // reqdata
                      0,                           // reqdatasize
                      recv_buffer,                 // replydata
                      BUFSIZ,                      // replydatamax
                      0,                           // linkertag
                      0,                           // pri
                      0,                           // xmitclass
                      0);                          // linkopts
    util_check("XMSG_LINK_", ferr);
    ferr = XMSG_BREAK_(msgid, (short *) &results, TPT_REF(phandle));
    util_check("XMSG_BREAK_", ferr);
    exit = false;
    while (!exit) {
        lerr = XWAIT(LREQ, -1);
        for (;;) {
            lerr = XMSG_LISTEN_((short *) &sre, // sre
                                0,              // listenopts
                                0);             // listenertag
            if (lerr == XSRETYPE_NOWORK)
                break;
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqctrl
                                  BUFSIZ);        // bytecount
            util_check("XMSG_READDATA_", ferr);
            if (sre.sre_flags & XSRE_MON) {
                MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
                printf("cli: mon message, type=%d\n", msg->type);
                if (msg->type == MS_MsgType_ProcessDeath) {
                    assert(msg->u.death.nid == nid);
                    assert(msg->u.death.pid == pid);
                    exit = true;
                }
            } else
                printf("cli: NON-mon message\n");
            XMSG_REPLY_(sre.sre_msgId,       // msgid
                        NULL,                // replyctrl
                        0,                   // replyctrlsize
                        NULL,                // replydata
                        0,                   // replydatasize
                        0,                   // errorclass
                        NULL);               // newphandle
        }
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(true);
    return 0;
}
Example #23
0
int main(int argc, char *argv[]) {
    SB_Array<int>  array(MAX_OUT);
    int            client = false;
    int            disable = 0;
    int            ferr;
    int            inx;
    int            lerr;
    int            linker = false;
    int            listener = false;
    int            oid;
    int            req_ctrl_size;
    int            req_data_size;
    int            rep_ctrl_size;
    int            rep_data_size;
    RT             results;
    TPT_DECL      (phandle);
    TAD            zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-linker",    TA_Bool, TA_NOMAX,    &linker    },
      { "-listener",  TA_Bool, TA_NOMAX,    &listener  },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);             // system messages
    TEST_CHK_FEOK(ferr);
    if (client) {
        ferr = msg_mon_open_process((char *) "$srv",              // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);

        for (inx = 0; inx < MAX_OUT; inx++) {
            req_ctrl_size = (inx + 1) % MAX_DATA;
            req_data_size = (inx + 2) % MAX_DATA;
            ferr = XMSG_LINK_(TPT_REF(phandle),         // phandle
                              &msgids[inx],             // msgid
                              send_cli_c_buffer[inx],   // reqctrl
                              (ushort) req_ctrl_size,   // reqctrlsize
                              recv_cli_c_buffer[inx],   // replyctrl
                              (ushort) MAX_DATA,        // replyctrlmax
                              send_cli_d_buffer[inx],   // reqdata
                              (ushort) req_data_size,   // reqdatasize
                              recv_cli_d_buffer[inx],   // replydata
                              (ushort) MAX_DATA,        // replydatamax
                              0,                        // linkertag
                              0,                        // pri
                              0,                        // xmitclass
                              0);                       // linkopts
            util_check("XMSG_LINK_", ferr);
        }
        if (linker) {
            sleep(1);
            util_abort_core_free();
        }
        for (inx = 0; inx < MAX_OUT; inx++) {
            array.add();
            array.set_val(inx, inx);
        }
        for (inx = 0; inx < MAX_OUT; inx++) {
            int rnd =
              (int) (1.0 * array.get_size() * rand_r(&seed) / (RAND_MAX + 1.0));
            int xinx = array.get_val(rnd);
            array.remove(rnd);
            rep_ctrl_size = (xinx + 3) % MAX_DATA;
            rep_data_size = (xinx + 4) % MAX_DATA;
            if (listener)
                disable = msg_test_assert_disable();
            ferr = XMSG_BREAK_(msgids[xinx], results.u.s, TPT_REF(phandle));
            if (listener) {
                assert(ferr == XZFIL_ERR_PATHDOWN);
                msg_test_assert_enable(disable);
            } else {
                util_check("XMSG_BREAK_", ferr);
                assert(results.u.t.ctrl_size == (unsigned short) rep_ctrl_size);
                assert(results.u.t.data_size == (unsigned short) rep_data_size);
            }
        }
        printf("if there were no asserts, all is well\n");
    } else {
        for (inx = 0; inx < MAX_OUT; inx++) {
            lerr = XWAIT(LREQ, -1);
            TEST_CHK_WAITIGNORE(lerr);
            do {
                lerr = XMSG_LISTEN_((short *) &sres[inx], // sre
                                    0,                    // listenopts
                                    0);                   // listenertag
                if (lerr == XSRETYPE_NOWORK)
                    util_time_sleep_ms(1);
            } while (lerr == XSRETYPE_NOWORK);
        }
        for (inx = 0; inx < MAX_OUT; inx++) {
            array.add();
            array.set_val(inx, inx);
        }
        for (inx = 0; inx < MAX_OUT; inx++) {
            int rnd =
              (int) (1.0 * array.get_size() * rand_r(&seed) / (RAND_MAX + 1.0));
            int xinx = array.get_val(rnd);
            array.remove(rnd);
            req_ctrl_size = (xinx + 1) % MAX_DATA;
            req_data_size = (xinx + 2) % MAX_DATA;
            assert(req_ctrl_size == sres[xinx].sre_reqCtrlSize);
            assert(req_data_size == sres[xinx].sre_reqDataSize);
            ferr = XMSG_READCTRL_(sres[xinx].sre_msgId,        // msgid
                                  recv_srv_c_buffer[xinx],     // reqctrl
                                  sres[xinx].sre_reqCtrlSize); // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sres[xinx].sre_msgId,        // msgid
                                  recv_srv_d_buffer[xinx],     // reqdata
                                  sres[xinx].sre_reqDataSize); // bytecount
            util_check("XMSG_READDATA_", ferr);
        }
        for (inx = 0; inx < MAX_OUT; inx++) {
            array.add();
            array.set_val(inx, inx);
        }
        if (linker)
            sleep(1);
        if (listener)
            util_abort_core_free();
        for (inx = 0; inx < MAX_OUT; inx++) {
            int rnd =
              (int) (1.0 * array.get_size() * rand_r(&seed) / (RAND_MAX + 1.0));
            int xinx = array.get_val(rnd);
            array.remove(rnd);
            rep_ctrl_size = (xinx + 3) % MAX_DATA;
            rep_data_size = (xinx + 4) % MAX_DATA;
            XMSG_REPLY_(sres[xinx].sre_msgId,    // msgid
                        recv_srv_c_buffer[xinx], // replyctrl
                        (ushort) rep_ctrl_size,  // replyctrlsize
                        recv_srv_d_buffer[xinx], // replydata
                        (ushort) rep_data_size,  // replydatasize
                        0,                       // errorclass
                        NULL);                   // newphandle
        }
    }

    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    if (linker)
        util_test_finish(!client);
    else
        util_test_finish(client);
    return 0;
}
Example #24
0
int main(int argc, char *argv[]) {
    int                 exit;
    int                 ferr;
    bool                ldone;
    int                 lerr;
    int                 msgid;
    int                 nid;
    int                 oid;
    int                 pid;
    TPT_DECL           (phandle);
    char                recv_buffer[BUFSIZ];
    short               recv_buffer2[BUFSIZ];
    RT                  results;
    MS_SRE              sre;
    MS_Mon_Transid_Type transid;

    ferr = msfs_util_init_role(true, &argc, &argv, msg_debug_hook);
    TEST_CHK_FEOK(ferr);
    util_test_start(true);
    ferr = msg_mon_process_startup(true); // system messages
    TEST_CHK_FEOK(ferr);
    msg_mon_enable_mon_messages(true);
    ferr = msg_mon_get_process_info((char *) "$srv", &nid, &pid);
    TEST_CHK_FEOK(ferr);
    ferr = msg_mon_open_process((char *) "$srv",      // name
                                TPT_REF(phandle),
                                &oid);
    TEST_CHK_FEOK(ferr);
    TRANSID_SET_NULL(transid);
    ferr = msg_mon_deregister_death_notification(nid, pid, transid);
    TEST_CHK_FEOK(ferr);
    ferr = msg_mon_register_death_notification(nid, pid);
    TEST_CHK_FEOK(ferr);
    ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                      &msgid,                      // msgid
                      NULL,                        // reqctrl
                      0,                           // reqctrlsize
                      recv_buffer2,                // replyctrl
                      1,                           // replyctrlmax
                      NULL,                        // reqdata
                      0,                           // reqdatasize
                      recv_buffer,                 // replydata
                      BUFSIZ,                      // replydatamax
                      0,                           // linkertag
                      0,                           // pri
                      0,                           // xmitclass
                      XMSG_LINK_LDONEQ);           // linkopts
    util_check("XMSG_LINK_", ferr);
    exit = 0;
    ldone = false;
    while (!exit) {
        do {
            lerr = XWAIT(LREQ|LDONE, -1);
            TEST_CHK_WAITIGNORE(lerr);
            if (lerr == LDONE) {
                ldone = true;
                break;
            }
            lerr = XMSG_LISTEN_((short *) &sre, // sre
                                0,              // listenopts
                                0);             // listenertag
        } while (lerr == XSRETYPE_NOWORK);
        if (ldone) {
            printf("LINK done\n");
            lerr = XMSG_LISTEN_((short *) &sre,       // sre
                                XLISTEN_ALLOW_LDONEM, // listenopts
                                0);                   // listenertag
            assert(lerr == XSRETYPE_LDONE);
            ferr = XMSG_BREAK_(sre.sre_msgId,
                               results.u.s,
                               TPT_REF(phandle));
            assert(ferr == XZFIL_ERR_OK);
            break;
        }
        ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                              recv_buffer,    // reqdata
                              BUFSIZ);        // bytecount
        util_check("XMSG_READDATA_", ferr);
        if (sre.sre_flags & XSRE_MON) {
            MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
            printf("cli: mon message, type=%d\n", msg->type);
            if (msg->type == MS_MsgType_ProcessDeath) {
                assert(msg->u.death.nid == nid);
                assert(msg->u.death.pid == pid);
                exit = 1;
            } else if (msg->type == MS_MsgType_Shutdown) {
                printf("cli: received cluster shutdown, level=%d\n", msg->u.shutdown.level);
                assert(msg->u.shutdown.level==MS_Mon_ShutdownLevel_Immediate);
            }
        } else
            printf("cli: NON-mon message\n");
        XMSG_REPLY_(sre.sre_msgId,       // msgid
                    NULL,                // replyctrl
                    0,                   // replyctrlsize
                    NULL,                // replydata
                    0,                   // replydatasize
                    0,                   // errorclass
                    NULL);               // newphandle
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(true);
    return 0;
}
Example #25
0
int main(int argc, char *argv[]) {
    bool       client = false;
    int        client_mon;
    int        cnid = -1;
    bool       commit_rcvd = false;
    int        cpid = -1;
    int        disable;
    bool       done = false;
    int        event_len;
    int        ferr;
    int        first;
    int        handle;
    int        inx;
    int        len;
    int        lerr;
    int        loop = 10;
    int        msgid;
    int        nid;
    bool       open_rcvd = false;
    int        orig_tag;
    TPT_DECL2 (phandle,MAX_SERVERS);
    int        pid;
    int        pinx;
    RT         results;
    int        send_len;
    MS_SRE     sre;
    int        status;
    bool       sync = false;
    bool       threaded = false;
    bool       verbose = false;
    TAD        zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-quiet",     TA_Bool, TA_NOMAX,    &quiet     },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "-sync",      TA_Bool, TA_NOMAX,    &sync      },
      { "-threaded",  TA_Bool, TA_NOMAX,    &threaded  },
      { "-v",         TA_Bool, TA_NOMAX,    &verbose   },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);
    sleep(1); // wait for client to get into msg_mon_process_info
    ferr = msg_mon_get_my_process_name(pname, sizeof(pname));
    TEST_CHK_FEOK(ferr);
    if (strcasecmp(pname, "$tm0") == 0)
         tag = TAG0;
    else if (strcasecmp(pname, "$tm1") == 0)
         tag = TAG1;
    else
         tag = TAG2;
    ferr = msg_mon_get_process_info(NULL, &snid, &spid);
    TEST_CHK_FEOK(ferr);
    if (client) {
        char serv[BUFSIZ];
        for (pinx = 0; pinx < MAX_SERVERS; pinx++) {
            sprintf(serv, "$tm%d", pinx);
            ferr = msg_mon_open_process(serv,         // name
                                        TPT_REF2(phandle,pinx),
                                        &oid[pinx]);
            TEST_CHK_FEOK(ferr);
        }
    } else {
        first = (strcasecmp(pname, "$tm0") == 0);
        disable = msg_test_assert_disable();
        ferr = msg_mon_tm_leader_set(&nid, &pid, lname);
        msg_test_assert_enable(disable);
        if (first) {
            TEST_CHK_FEOK(ferr);
        } else
            assert(ferr != XZFIL_ERR_OK);
        printf("leader is p-id=%d/%d, name=%s\n",
               nid, pid, lname);
    }

    util_gethostname(my_name, sizeof(my_name));
    msg_mon_enable_mon_messages(true);
    if (!client) {
        ferr = msg_mon_event_wait(1, &event_len, event_data);
        util_check("msg_mon_event_wait", ferr);
        ferr = msg_mon_tmsync_register(tmsync_cb);
        util_check("msg_mon_tmsync_register", ferr);
        if (sync) {
            char serv[BUFSIZ];
            for (pinx = 0; pinx < MAX_SERVERS; pinx++) {
                sprintf(serv, "$tm%d", pinx);
                if (strcasecmp(serv, pname) != 0) {
                    ferr = msg_mon_open_process(serv,         // name
                                                TPT_REF2(phandle,pinx),
                                                &oid[pinx]);
                    TEST_CHK_FEOK(ferr);
                }
            }
            // at this point, we know everyone is registered
            // if everyone isn't registered, there will be an abort
            do_sync();
            if (threaded)
                do_sync_threaded();
        }
    }

    if (client) {
        for (inx = 0; inx < loop; inx++) {
            sprintf(send_buffer, "hello, greetings from %s, inx=%d",
                    my_name, inx);
            send_len = (int) strlen(send_buffer) + 1;
            for (pinx = 0; pinx < MAX_SERVERS; pinx++) {
                if (verbose)
                    printf("%s: sending message, pinx=%d, inx=%d\n",
                           pname, pinx, inx);
                ferr = XMSG_LINK_(TPT_REF2(phandle,pinx),      // phandle
                                  &msgid,                      // msgid
                                  send_buffer2,                // reqctrl
                                  (ushort) (inx & 1),          // reqctrlsize
                                  recv_buffer3,                // replyctrl
                                  1,                           // replyctrlmax
                                  send_buffer,                 // reqdata
                                  (ushort) send_len,           // reqdatasize
                                  recv_buffer,                 // replydata
                                  BUFSIZ,                      // replydatamax
                                  0,                           // linkertag
                                  0,                           // pri
                                  0,                           // xmitclass
                                  0);                          // linkopts
                util_check("XMSG_LINK_", ferr);
                ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF2(phandle,pinx));
                util_check("XMSG_BREAK_", ferr);
                assert(results.u.t.ctrl_size == (uint) (inx & 1));
                assert(results.u.t.data_size > (strlen(send_buffer) + 14));
                assert(results.u.t.errm == RT_DATA_RCVD); // data
                if (!quiet)
                    printf("%s\n", recv_buffer);
            }
        }
        for (pinx = 0; pinx < MAX_SERVERS; pinx++) {
            ferr = msg_mon_close_process(TPT_REF2(phandle,pinx));
            TEST_CHK_FEOK(ferr);
        }
    } else {
        inx = 0;
        while (!done) {
            lerr = XWAIT(LREQ, -1);
            TEST_CHK_WAITIGNORE(lerr);
            for (;;) {
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
                if (lerr == XSRETYPE_NOWORK)
                    break;
                ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                      recv_buffer2,   // reqctrl
                                      1);             // bytecount
                util_check("XMSG_READCTRL_", ferr);
                ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                      recv_buffer,    // reqdata
                                      BUFSIZ);        // bytecount
                util_check("XMSG_READDATA_", ferr);
                if (sre.sre_flags & XSRE_MON) {
                    MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
                    if (cnid < 0) {
                        ferr = msg_mon_get_process_info((char *) "$cli", &cnid, &cpid);
                        if (ferr != XZFIL_ERR_OK) {
                            cnid = -1;
                            cpid = -1;
                        }
                    }
                    client_mon = true;
                    Item *item_hdl;
                    Item *item_tag;
                    const char *type;
                    switch (msg->type) {
                    case MS_MsgType_Close:
                        type = "close";
                        if ((cnid == msg->u.close.nid) &&
                            (cpid == msg->u.close.pid)) {
                        } else
                            client_mon = false;
                        break;
                    case MS_MsgType_NodeDown:
                        type = "node-down";
                        break;
                    case MS_MsgType_Open:
                        type = "open";
                        if ((cnid == msg->u.open.nid) &&
                            (cpid == msg->u.open.pid))
                            open_rcvd = true;
                        else
                            client_mon = false;
                        break;
                    case MS_MsgType_ProcessDeath:
                        type = "process-death";
                        break;
                    case MS_MsgType_Shutdown:
                        type = "shutdown";
                        done = true;
                        break;
                    case MS_MsgType_TmSyncAbort:
                    case MS_MsgType_TmSyncCommit:
                        if (msg->type == MS_MsgType_TmSyncAbort)
                            type = "tmsync-abort";
                        else
                            type = "tmsync-commit";
                        nid = msg->u.tmsync.nid[0];
                        handle = msg->u.tmsync.handle[0];
                        if (msg->u.tmsync.orig_count == 0) {
                            msg->u.tmsync.orig_tag[0] = -1;
                            msg->u.tmsync.orig_handle[0] = -1;
                        }
                        orig_tag = msg->u.tmsync.orig_tag[0];
                        if (!quiet) {
                            printf("server (%s) received (%s) mon message, type=%s(%d), nid=%d\n",
                               pname,
                               client_mon ? "cli" : "dtm",
                               type,
                               msg->type,
                               nid);
                            printf("  orig_count=%d, orig_tag=%d, orig_handle=%d, count=%d, handle[0]=%d\n",
                               msg->u.tmsync.orig_count,
                               orig_tag,
                               msg->u.tmsync.orig_handle[0],
                               msg->u.tmsync.count,
                               handle);
                        }
                        if (nid == snid) {
                            if (!quiet)
                                printf("server (%s) commit handle=%d, orig-count=%d\n",
                                       pname, handle, msg->u.tmsync.orig_count);
                            for (int inx2 = 0;
                                 inx2 < msg->u.tmsync.count;
                                 inx2++) {
                                int ltag = msg->u.tmsync.orig_tag[inx2];
                                int lhandle = msg->u.tmsync.orig_handle[inx2];
                                if (!quiet)
                                    printf("server (%s) commit orig-tag/handle=%d/%d\n",
                                           pname, ltag, lhandle);
                                item_tag = (Item *) tag_issue_map.remove(ltag);
                                assert(item_tag != NULL);
                                delete item_tag;
                                item_hdl = (Item *) handle_issue_map.remove(lhandle);
                                assert(item_hdl != NULL);
                                delete item_hdl;
                            }
                        } else {
                            assert(msg->u.tmsync.orig_count == 0);
                        }
                        commit_rcvd = true;
                        break;
                    default:
                        type = "<unknown>";
                    }
                    if (!quiet)
                        printf("server (%s) received (%s) mon message, type=%s(%d)\n",
                               pname, client_mon ? "cli" : "dtm", type, msg->type);
                    len = 0;
                } else {
                    inx++;
                    if (verbose)
                        printf("%s: received non-mon message, inx=%d\n",
                               pname, inx);
                    if (!sync)
                        assert(sync_rcvd);
                    assert(commit_rcvd);
                    assert(open_rcvd);
                    strcat(recv_buffer, "- reply from ");
                    strcat(recv_buffer, my_name);
                    strcat(recv_buffer, " - ");
                    strcat(recv_buffer, pname);
                    len = (int) strlen(recv_buffer) + 1;
                }
                XMSG_REPLY_(sre.sre_msgId,       // msgid
                            recv_buffer2,        // replyctrl
                            sre.sre_reqCtrlSize, // replyctrlsize
                            recv_buffer,         // replydata
                            (ushort) len,        // replydatasize
                            0,                   // errorclass
                            NULL);               // newphandle
            }
        }
        assert(inx == loop);
        assert(tag_issue_map.empty());
        assert(handle_issue_map.empty());
        // need to wait for shutdown to be started
        ferr = msg_mon_event_wait(2, &event_len, event_data);
        util_check("msg_mon_event_wait", ferr);
        if (sync && threaded) {
            sync_thr_shutdown = true;
            for (int thr = 0; thr < MAX_THR; thr++) {
                void *larg;
                status = sync_thr[thr]->join(&larg);
                TEST_CHK_STATUSOK(status);
            }
        }
    }

    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #26
0
int main(int argc, char *argv[]) {
    bool       client = false;
    int        disable;
    int        ferr;
    int        inx;
    int        len;
    int        lerr;
    int        loop = 10;
    int        msgid;
    int        oid;
    TPT_DECL  (phandle);
    RT         results;
    MS_SRE     sre;
    TPT_DECL  (xphandle);
    TAD        zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    setenv("MS_STREAMS_MAX", "10", 1);
    msfs_util_init(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    util_test_start(client);
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);
    if (client) {
        ferr = msg_mon_open_process((char *) "$srv",      // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
    } else {
        disable = msg_test_assert_disable();
        for (inx = 0; inx < 20; inx++) {
            ferr = msg_mon_open_process((char *) "$crap", // name
                                        TPT_REF(xphandle),
                                        &oid);
            assert(ferr != XZFIL_ERR_OK);
        }
        msg_test_assert_enable(disable);
    }
    util_gethostname(my_name, sizeof(my_name));

    for (inx = 0; inx < loop; inx++) {
        if (client) {
            sprintf(send_buffer, "hello, greetings from %s, inx=%d",
                    my_name, inx);
            ferr = XMSG_LINK_(TPT_REF(phandle),            // phandle
                              &msgid,                      // msgid
                              NULL,                        // reqctrl
                              0,                           // reqctrlsize
                              NULL,                        // replyctrl
                              0,                           // replyctrlmax
                              send_buffer,                 // reqdata
                              39000,                       // reqdatasize
                              recv_buffer,                 // replydata
                              40000,                       // replydatamax
                              0,                           // linkertag
                              0,                           // pri
                              0,                           // xmitclass
                              0);                          // linkopts
            util_check("XMSG_LINK_", ferr);
            ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle));
            util_check("XMSG_BREAK_", ferr);
            assert(results.u.t.ctrl_size == 0);
            assert(results.u.t.errm == RT_DATA_RCVD); // data
            printf("%s\n", recv_buffer);
        } else {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  NULL,           // reqctrl
                                  0);             // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  40000);         // bytecount
            util_check("XMSG_READDATA_", ferr);
            strcat(recv_buffer, "- reply from ");
            strcat(recv_buffer, my_name);
            len = (int) strlen(recv_buffer) + 1;
            len = len; // touch - not currently used
            XMSG_REPLY_(sre.sre_msgId,  // msgid
                        NULL,           // replyctrl
                        0,              // replyctrlsize
                        recv_buffer,    // replydata
                        39000,          // replydatasize
                        0,              // errorclass
                        NULL);          // newphandle
        }
    }
    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #27
0
int main(int argc, char *argv[]) {
    int        ferr;
    TPT_DECL2 (phandle,MAX_SERVERS);
    int        inx;
    int        lerr;
    int        loop = 10;
    int        max;
    int        maxsp = 1;
    int        oid;
    int        pinx;
    MS_SRE     sre;
    bool       verbose = false;
    TAD        zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-maxcp",     TA_Int,  MAX_CLIENTS, &maxcp     },
      { "-maxsp",     TA_Int,  MAX_SERVERS, &maxsp     },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "-v",         TA_Bool, TA_NOMAX,    &verbose   },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    ferr = msg_init(&argc, &argv);
    TEST_CHK_FEOK(ferr);
    msfs_util_init_fs(&argc, &argv, msg_debug_hook);
    arg_proc_args(zargs, false, argc, argv);
    if (maxcp < 0)
        maxcp = 1;
    if (maxsp < 0)
        maxsp = 1;
    ferr = msg_mon_process_startup(!client);  // system messages?
    TEST_CHK_FEOK(ferr);
    if (!client)
        msg_mon_enable_mon_messages(true);
    ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
    TEST_CHK_FEOK(ferr);

    // process-wait for clients/servers/shell
    ferr = msfs_util_wait_process_count(MS_ProcessType_Generic,
                                        maxcp + maxsp + 1,
                                        NULL,
                                        verbose);
    TEST_CHK_FEOK(ferr);
    sleep(3); // wait for all process_count's to complete
    if (client) {
        pinx = atoi(&my_name[4]);
        assert(pinx >= 0);
        printf("loop=%d\n", loop);
        for (inx = 0; inx < loop; inx++) {
            for (pinx = 0; pinx < maxsp; pinx++) {
                sprintf(serv, "$srv%d", pinx);
                ferr = msg_mon_open_process(serv,
                                            TPT_REF2(phandle,pinx),
                                            &oid);
                TEST_CHK_FEOK(ferr);
            }
            for (pinx = 0; pinx < maxsp; pinx++) {
                ferr = msg_mon_close_process(TPT_REF2(phandle,pinx));
                TEST_CHK_FEOK(ferr);
                if (verbose)
                    printf("%s-close-count=%d\n", my_name, inx);
            }
        }
    } else {
        max = 2 * maxcp * loop;
        for (inx = 0; inx < max; inx++) {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            ferr = XMSG_READCTRL_(sre.sre_msgId,        // msgid
                                  recv_buffer2,         // reqctrl
                                  sre.sre_reqCtrlSize); // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,        // msgid
                                  recv_buffer,          // reqdata
                                  sre.sre_reqDataSize); // bytecount
            util_check("XMSG_READDATA_", ferr);
            XMSG_REPLY_(sre.sre_msgId,         // msgid
                        recv_buffer2,          // replyctrl
                        sre.sre_reqCtrlSize,   // replyctrlsize
                        recv_buffer,           // replydata
                        sre.sre_reqDataSize,   // replydatasize
                        1,                     // errorclass
                        NULL);                 // newphandle
            if (verbose)
                printf("%s-count=%d\n", my_name, inx);
        }
        sleep(5);
    }

    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}
Example #28
0
int main(int argc, char *argv[]) {
    int                arg;
    char               buf[BUFSIZ];
    bool               client = false;
    int                disable;
    int                ferr;
    int                inx;
    int                len;
    int                lerr;
    int                oid;
    void              *result;
    MS_SRE             sre;
    int                status;
    SB_Thread::Thread *thr_send[MAX_THREADS];
    TAD                zargs[] = {
      { "-client",    TA_Bool, TA_NOMAX,    &client    },
      { "-loop",      TA_Int,  TA_NOMAX,    &loop      },
      { "-server",    TA_Ign,  TA_NOMAX,    NULL       },
      { "-threads",   TA_Int,  MAX_THREADS, &threads   },
      { "-v",         TA_Bool, TA_NOMAX,    &verbose   },
      { "",           TA_End,  TA_NOMAX,    NULL       }
    };

    msfs_util_init(&argc, &argv, msg_debug_hook);
    gargc = &argc;
    gargv = argv;
    arg_proc_args(zargs, false, argc, argv);
    for (arg = 1; arg < argc; arg++) {
        if (strcmp(argv[arg], "-client") == 0) // start_process
            argv[arg] = (char *) "-server"; // set to server for start-process
    }
    if (threads < 1)
        threads = 1;
    if (client)
        strcpy(who, "client");
    else
        strcpy(who, "server");
    util_test_start(client);
    ferr = msg_mon_process_startup(true);  // system messages?
    TEST_CHK_FEOK(ferr);
    if (client) {
        if (verbose)
            printf("%s - opening server\n", who);
        ferr = msg_mon_open_process((char *) "$srv",      // name
                                    TPT_REF(phandle),
                                    &oid);
        TEST_CHK_FEOK(ferr);
    }
    util_gethostname(my_name, sizeof(my_name));

    if (client) {
        disable = msg_test_assert_disable();
        for (inx = 0; inx < threads; inx++) {
            sprintf(buf, "%d", inx);
            thr_send[inx] = new SB_Thread::Thread(thread_send_fun, buf);
            thr_send[inx]->start();
        }
        for (inx = 0; inx < threads; inx++) {
            status = thr_send[inx]->join(&result);
            TEST_CHK_STATUSOK(status);
            delete thr_send[inx];
        }
        thread_send_fun(NULL);
        msg_test_assert_enable(disable);
    } else {
        inx = 0;
        for (;;) {
            do {
                lerr = XWAIT(LREQ, -1);
                TEST_CHK_WAITIGNORE(lerr);
                lerr = XMSG_LISTEN_((short *) &sre, // sre
                                    0,              // listenopts
                                    0);             // listenertag
            } while (lerr == XSRETYPE_NOWORK);
            inx++;
            if (inx > 4)
                util_abort_core_free(); // don't reply
            ferr = XMSG_READCTRL_(sre.sre_msgId,  // msgid
                                  NULL,           // reqctrl
                                  0);             // bytecount
            util_check("XMSG_READCTRL_", ferr);
            ferr = XMSG_READDATA_(sre.sre_msgId,  // msgid
                                  recv_buffer,    // reqdata
                                  40000);         // bytecount
            util_check("XMSG_READDATA_", ferr);
            strcat(recv_buffer, "- reply from ");
            strcat(recv_buffer, my_name);
            len = (int) strlen(recv_buffer) + 1;
            len = len; // touch
            XMSG_REPLY_(sre.sre_msgId,             // msgid
                        NULL,                      // replyctrl
                        0,                         // replyctrlsize
                        recv_buffer,               // replydata
                        39000,                     // replydatasize
                        0,                         // errorclass
                        NULL);                     // newphandle
            if (sre.sre_reqDataSize == 0)
                break;
        }
    }
    if (client) {
        ferr = msg_mon_close_process(TPT_REF(phandle));
        TEST_CHK_FEOK(ferr);
    }
    ferr = msg_mon_process_shutdown();
    TEST_CHK_FEOK(ferr);
    util_test_finish(client);
    return 0;
}