test2_main.c

/*   
 *   (c) Copyright 2008 Philipp Skadorov (philipp_s@users.sourceforge.net)
 *
 *   This file is part of FREESECS.
 *
 *   FREESECS is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   FREESECS is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with FREESECS, see COPYING.
 *   If not, see <http://www.gnu.org/licenses/>.
 */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>
#include "hsmsd_cli.h"


#define MAX_DELTA 30

struct
{
    unsigned short  stream;
    unsigned short  function;
    unsigned char   wbit;
    unsigned int    sysbytes;
    unsigned int    data_len;
    unsigned char   data[2];   
} s1f13_msg =
{
    .stream = 1,
    .function = 13,
    .wbit = 1,
    .sysbytes = 0,
    .data_len = 2,
    .data = {0x1, 0x0}
};

struct
{
    unsigned short  stream;
    unsigned short  function;
    unsigned char   wbit;
    unsigned int    sysbytes;
    unsigned int    data_len;
    unsigned char   data[343];   
} s3f17_msg =
{
    .stream = 3,
    .function = 17,
    .wbit = 1,
    .sysbytes = 1 << 24,
    .data_len = 343,
    .data = {   0x1, 0x5, 0xa9, 0x2, 0x0, 0x1, 0x41, 0x4, 0x42, 0x69, 0x6e, 0x64,
                0x41, 0x10, 0x43, 0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30, 0x30,
                0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0xa5, 0x1, 0x1, 0x1, 0x5, 0x1,
                0x2, 0x41, 0x8, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0xa5,
                0x1, 0x19, 0x1, 0x2, 0x41, 0xe, 0x53, 0x75, 0x62, 0x73, 0x74, 0x72,
                0x61, 0x74, 0x65, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0xa5, 0x1, 0x0, 0x1,
                0x2, 0x41, 0x5, 0x55, 0x73, 0x61, 0x67, 0x65, 0x41, 0x7, 0x50, 0x52,
                0x4f, 0x44, 0x55, 0x43, 0x54, 0x1, 0x2, 0x41, 0x7, 0x53, 0x6c, 0x6f,
                0x74, 0x4d, 0x61, 0x70, 0x1, 0x19, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1,
                0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1,
                0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1,
                0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1,
                0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1,
                0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1,
                0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0xa5, 0x1, 0x1, 0x1, 0x2, 0x41,
                0xa, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4d, 0x61, 0x70, 0x1,
                0x19, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0, 0x1, 0x2, 0x41, 0x0, 0x41,
                0x0, 0x1, 0x2, 0x41, 0x0, 0x41, 0x0}
};

struct
{
    unsigned short  stream;
    unsigned short  function;
    unsigned char   wbit;
    unsigned int    sysbytes;
    unsigned int    data_len;
    unsigned char   data[343];   
} s16f15_msg =
{
    .stream = 16,
    .function = 15,
    .wbit = 1,
    .sysbytes = 2 << 24,
    .data_len = 260,
    .data = {   0x1, 0x2, 0xa9, 0x2, 0x0, 0x0, 0x1, 0x3, 0x1, 0x6, 0x41, 0xe,
                0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4a, 0x6f, 0x62, 0x5f,
                0x47, 0x31, 0x21, 0x1, 0xd, 0x1, 0x1, 0x1, 0x2, 0x41, 0x10, 0x43,
                0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30, 0x30, 0x30, 0x30, 0x30,
                0x30, 0x30, 0x32, 0x1, 0x1, 0xa5, 0x1, 0x1, 0x1, 0x3, 0xa5, 0x1,
                0x1, 0x41, 0x16, 0x48, 0x6f, 0x73, 0x74, 0x5c, 0x52, 0x65, 0x61, 0x64,
                0x20, 0x61, 0x6e, 0x64, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
                0x72, 0x1, 0x0, 0x25, 0x1, 0xff, 0x1, 0x0, 0x1, 0x6, 0x41, 0xe,
                0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4a, 0x6f, 0x62, 0x5f,
                0x47, 0x32, 0x21, 0x1, 0xd, 0x1, 0x1, 0x1, 0x2, 0x41, 0x10, 0x43,
                0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30, 0x30, 0x30, 0x30, 0x30,
                0x30, 0x30, 0x33, 0x1, 0x1, 0xa5, 0x1, 0x1, 0x1, 0x3, 0xa5, 0x1,
                0x1, 0x41, 0x16, 0x48, 0x6f, 0x73, 0x74, 0x5c, 0x52, 0x65, 0x61, 0x64,
                0x20, 0x61, 0x6e, 0x64, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
                0x72, 0x1, 0x0, 0x25, 0x1, 0xff, 0x1, 0x0, 0x1, 0x6, 0x41, 0xe,
                0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4a, 0x6f, 0x62, 0x5f,
                0x47, 0x33, 0x21, 0x1, 0xd, 0x1, 0x1, 0x1, 0x2, 0x41, 0x10, 0x43,
                0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30, 0x30, 0x30, 0x30, 0x30,
                0x30, 0x30, 0x34, 0x1, 0x1, 0xa5, 0x1, 0x1, 0x1, 0x3, 0xa5, 0x1,
                0x1, 0x41, 0x16, 0x48, 0x6f, 0x73, 0x74, 0x5c, 0x52, 0x65, 0x61, 0x64,
                0x20, 0x61, 0x6e, 0x64, 0x20, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
                0x72, 0x1, 0x0, 0x25, 0x1, 0xff, 0x1, 0x0 }
};

struct
{
    unsigned short  stream;
    unsigned short  function;
    unsigned char   wbit;
    unsigned int    sysbytes;
    unsigned int    data_len;
    unsigned char   data[504];   
} s14f9_msg =
{
    .stream = 14,
    .function = 9,
    .wbit = 1,
    .sysbytes = 3 << 24,
    .data_len = 504,
    .data = {   0x1, 0x3, 0x41, 0x9, 0x45, 0x71, 0x75, 0x69, 0x70, 0x6d, 0x65, 0x6e,
                0x74, 0x41, 0xa, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x4a, 0x6f,
                0x62, 0x1, 0x9, 0x1, 0x2, 0x41, 0x5, 0x4f, 0x62, 0x6a, 0x49, 0x44,
                0x41, 0x7, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x5f, 0x47, 0x1, 0x2, 0x41,
                0x12, 0x44, 0x61, 0x74, 0x61, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74,
                0x69, 0x6f, 0x6e, 0x50, 0x6c, 0x61, 0x6e, 0x41, 0x0, 0x1, 0x2, 0x41,
                0x10, 0x43, 0x61, 0x72, 0x72, 0x69, 0x65, 0x72, 0x49, 0x6e, 0x70, 0x75,
                0x74, 0x53, 0x70, 0x65, 0x63, 0x1, 0x4, 0x41, 0x10, 0x43, 0x41, 0x52,
                0x52, 0x49, 0x45, 0x52, 0x5f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                0x31, 0x41, 0x10, 0x43, 0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30,
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x41, 0x10, 0x43, 0x41, 0x52,
                0x52, 0x49, 0x45, 0x52, 0x5f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                0x33, 0x41, 0x10, 0x43, 0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30,
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x1, 0x2, 0x41, 0xb, 0x4d,
                0x74, 0x72, 0x6c, 0x4f, 0x75, 0x74, 0x53, 0x70, 0x65, 0x63, 0x1, 0x3,
                0x1, 0x2, 0x1, 0x2, 0x41, 0x10, 0x43, 0x41, 0x52, 0x52, 0x49, 0x45,
                0x52, 0x5f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x1, 0x1,
                0xa5, 0x1, 0x1, 0x1, 0x2, 0x41, 0x10, 0x43, 0x41, 0x52, 0x52, 0x49,
                0x45, 0x52, 0x5f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x1,
                0x1, 0xa5, 0x1, 0x1, 0x1, 0x2, 0x1, 0x2, 0x41, 0x10, 0x43, 0x41,
                0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                0x30, 0x33, 0x1, 0x1, 0xa5, 0x1, 0x1, 0x1, 0x2, 0x41, 0x10, 0x43,
                0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30, 0x30, 0x30, 0x30, 0x30,
                0x30, 0x30, 0x31, 0x1, 0x1, 0xa5, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2,
                0x41, 0x10, 0x43, 0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30, 0x30,
                0x30, 0x30, 0x30, 0x30, 0x30, 0x34, 0x1, 0x1, 0xa5, 0x1, 0x1, 0x1,
                0x2, 0x41, 0x10, 0x43, 0x41, 0x52, 0x52, 0x49, 0x45, 0x52, 0x5f, 0x30,
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x1, 0x1, 0xa5, 0x1, 0x3,
                0x1, 0x2, 0x41, 0xf, 0x4d, 0x74, 0x72, 0x6c, 0x4f, 0x75, 0x74, 0x42,
                0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1, 0x0, 0x1, 0x2, 0x41,
                0xa, 0x50, 0x61, 0x75, 0x73, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x1,
                0x0, 0x1, 0x2, 0x41, 0x12, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73,
                0x69, 0x6e, 0x67, 0x43, 0x74, 0x72, 0x6c, 0x53, 0x70, 0x65, 0x63, 0x1,
                0x3, 0x1, 0x3, 0x41, 0xe, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65,
                0x72, 0x4a, 0x6f, 0x62, 0x5f, 0x47, 0x31, 0x1, 0x0, 0x1, 0x0, 0x1,
                0x3, 0x41, 0xe, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4a,
                0x6f, 0x62, 0x5f, 0x47, 0x32, 0x1, 0x0, 0x1, 0x0, 0x1, 0x3, 0x41,
                0xe, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4a, 0x6f, 0x62,
                0x5f, 0x47, 0x33, 0x1, 0x0, 0x1, 0x0, 0x1, 0x2, 0x41, 0x10, 0x50,
                0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x4d,
                0x67, 0x6d, 0x74, 0xa5, 0x1, 0x3, 0x1, 0x2, 0x41, 0xb, 0x53, 0x74,
                0x61, 0x72, 0x74, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x25, 0x1, 0x0}
};

static FILE *fp = NULL;
static char msg_flags[15][30];

static struct
{
    sem_t sent_sem;
    sem_t recv_sem;
    sem_t err_sem;
    unsigned long us_timeout;
    unsigned int transaction_id;
    hsmsd_msg_t* pmsg;
}msg_dict[4] = 
{
    {.us_timeout = 1, .transaction_id = 1 << 24, .pmsg = (hsmsd_msg_t*)&s1f13_msg},
    {.us_timeout = 1, .transaction_id = 2 << 24, .pmsg = (hsmsd_msg_t*)&s3f17_msg},
    {.us_timeout = 1, .transaction_id = 3 << 24, .pmsg = (hsmsd_msg_t*)&s16f15_msg},
    {.us_timeout = 1, .transaction_id = 4 << 24, .pmsg = (hsmsd_msg_t*)&s14f9_msg}
};


static void prepare_dict(void);
static void start_threads(void*);
static void hsms_msg_handler(hsmsd_msg_t* msg);
static void hsms_cnx_state_handler(hsmsd_cnx_state_t state);
static void hsmsd_cnx_error_handler(int err);

static void* thread_func0(void*);
static void* thread_func1(void*);
static void* thread_func2(void*);
static void* thread_func3(void*);

static sem_t cnx_ready_sem;

int main(int argc, char **argv)
{
    int print_offset;
    int r, sent[4], recv[4], err[4];
    hsmsd_handle_t h;

    //fp = fopen("./secondaries.txt", "w+");
    memset(msg_flags, 0, sizeof(msg_flags));

    r = hsmsd_alloc_handle(&h, "hsms1");
    fprintf(stdout, "hsmsd_alloc_handle returned %d\n", r);
    if(r) exit(-1);

    r = hsmsd_subscribe_for_msgs(h, (hsmsd_msg_handler_t)hsms_msg_handler );
    fprintf(stdout, "hsmsd_subscribe_for_msgs returned %d\n", r);
    if(r) exit(-2);

    r = hsmsd_subscribe_for_cnx_state(h, (hsmsd_cnx_state_handler_t)hsms_cnx_state_handler);
    fprintf(stdout, "hsmsd_subscribe_for_cnx_state returned %d\n", r);
    if(r) exit(-3);

    r = hsmsd_subscribe_for_cnx_error(h, (hsmsd_cnx_error_handler_t)hsmsd_cnx_error_handler);
    fprintf(stdout, "hsmsd_subscribe_for_cnx_error returned %d\n", r);
    if(r) exit(-4);

    sem_init(&cnx_ready_sem, 0, 0);

    r = hsmsd_cnx_start(h);
    fprintf(stdout, "hsmsd_cnx_start returned %d\n", r);
    if(r) exit(-5);

    sem_wait(&cnx_ready_sem);

    prepare_dict();
    fprintf(stdout, "dict prepared\n");

    start_threads((void*)&h);
    fprintf(stdout, "threads started\n");

    while(1)
    {
        sleep(2);

        sem_getvalue(&msg_dict[0].sent_sem, &sent[0]);
        sem_getvalue(&msg_dict[1].sent_sem, &sent[1]);
        sem_getvalue(&msg_dict[2].sent_sem, &sent[2]);
        sem_getvalue(&msg_dict[3].sent_sem, &sent[3]);

        sem_getvalue(&msg_dict[0].recv_sem, &recv[0]);
        sem_getvalue(&msg_dict[1].recv_sem, &recv[1]);
        sem_getvalue(&msg_dict[2].recv_sem, &recv[2]);
        sem_getvalue(&msg_dict[3].recv_sem, &recv[3]);

        sem_getvalue(&msg_dict[0].err_sem, &err[0]);
        sem_getvalue(&msg_dict[1].err_sem, &err[1]);
        sem_getvalue(&msg_dict[2].err_sem, &err[2]);
        sem_getvalue(&msg_dict[3].err_sem, &err[3]);
        
        print_offset = 0;
        print_offset += fprintf(stdout, 
                                "sent:\t%d\t|\t%d\t|\t%d\t|\t%d\n", 
                                 sent[0], sent[1], sent[2], sent[3]);
        print_offset += fprintf(stdout, 
                                "recv:\t%d\t|\t%d\t|\t%d\t|\t%d\n", 
                                 recv[0], recv[1], recv[2], recv[3]);
        print_offset += fprintf(stdout, 
                                "err:\t%d\t|\t%d\t|\t%d\t|\t%d\n", 
                                 err[0], err[1], err[2], err[3]);
        //fseek(stdout, print_offset, SEEK_SET);
        fflush(stdout);

/*        if(sent[0] > recv[0]+MAX_DELTA
        || sent[1] > recv[1]+MAX_DELTA
        || sent[2] > recv[2]+MAX_DELTA
        || sent[3] > recv[3]+MAX_DELTA)
        {
            fprintf(stdout, "sent-recv delta too big!");
            exit(0);
        }
*/
    }


    exit(0);
}



void prepare_dict(void)
{
    sem_init(&msg_dict[0].sent_sem, 0, 0);
    sem_init(&msg_dict[1].sent_sem, 0, 0);
    sem_init(&msg_dict[2].sent_sem, 0, 0);
    sem_init(&msg_dict[3].sent_sem, 0, 0);

    sem_init(&msg_dict[0].recv_sem, 0, 0);
    sem_init(&msg_dict[1].recv_sem, 0, 0);
    sem_init(&msg_dict[2].recv_sem, 0, 0);
    sem_init(&msg_dict[3].recv_sem, 0, 0);

    sem_init(&(msg_dict[0].err_sem), 0, 0);
    sem_init(&(msg_dict[1].err_sem), 0, 0);
    sem_init(&(msg_dict[2].err_sem), 0, 0);
    sem_init(&(msg_dict[3].err_sem), 0, 0);
}

void start_threads(void *pdata)
{
    pthread_t id0, id1, id2, id3;
    pthread_create(&id0, NULL, thread_func0, pdata);
    pthread_create(&id1, NULL, thread_func1, pdata);
    pthread_create(&id2, NULL, thread_func2, pdata);
    pthread_create(&id3, NULL, thread_func3, pdata);
}

void hsmsd_cnx_error_handler(int err)
{
    fprintf(stdout, "hsmsd_cnx_error_handler: %d\n", err);
}


void hsms_msg_handler(hsmsd_msg_t* msg)
{
    unsigned char *begin = NULL, *end = NULL, *iter = NULL;
    unsigned int ctr = 0;
    //fprintf(stdout, "hsms_msg_handler: s%df%d, sysbytes=%ld\n", 
    //                        msg->stream, msg->function, msg->sysbytes);
    
    if(fp && 0 == msg_flags[msg->stream][msg->function])
    {
        msg_flags[msg->stream][msg->function] = 1;
        
        fprintf(fp, "s%df%d, len=%d\n", msg->stream, msg->function, msg->data_len);
    
        begin   = &msg->data[0];
        end     = &msg->data[0] + msg->data_len;
        for(iter = begin; iter < end; ++iter)
        {
            fprintf(fp, "0x%x, ", *iter);
            if(ctr++ > 10)
            {
                fprintf(fp, "\n");
                ctr = 0;
            }
        }
        fprintf(fp, "\n\n\n");
        fflush(fp);
    }

    int pool_num = msg->sysbytes >> 24;
    if(4 > pool_num)
    {
        sem_post(&msg_dict[pool_num].recv_sem);
    }
    else
    {
        fprintf(stdout, ">>>!!!!!unknown id: %d!!!!!<<<\n",pool_num);
    }
    free(msg);
}

void hsms_cnx_state_handler(hsmsd_cnx_state_t state)
{
    static char str_state[][32] = {"NOT CONNECTED", "NOT SELECTED", "SELECTED"};

    if(CNX_SELECTED == state)
    {
        sem_post(&cnx_ready_sem);
    }
    fprintf(stdout, "hsms_cnx_state_handler: %s\n", str_state[state]);
}

static void* thread_funcx(int num, void* data)
{
    fprintf(stdout, "thread function %d\n", num);
    hsmsd_handle_t h = *((hsmsd_handle_t*)data);
    while(1)
    {
        usleep(msg_dict[num].us_timeout);
        msg_dict[num].pmsg->sysbytes += 1;
        if(0 == hsmsd_cnx_send_msg(h, msg_dict[num].pmsg))
        {
            sem_post(&msg_dict[num].sent_sem);
        }
        else
        {
            fprintf(stdout, "thread function %d: exit...\n", num);
            sem_post(&msg_dict[num].err_sem);
            pthread_exit(NULL);
        }
    }
    fprintf(stdout, "thread function %d: exit...\n", num);
    return NULL;
}

void* thread_func0(void* data)
{
    return thread_funcx(0, data);
}

void* thread_func1(void* data)
{
    return thread_funcx(1, data);
}

void* thread_func2(void* data)
{
    return thread_funcx(2, data);
}

void* thread_func3(void* data)
{
    return thread_funcx(3, data);
}

---