클라이언트 API

#include <atmi.h>
int tpstart (TPSTART_T *tpinfo )

struct TPSTART_T{
      char cltid[MAXTIDENT+2];  /*클라이언트명 (tpbroadcast())*/
      char dompwd[MAX_PASSWD_LENGTH+2];  /*시스템 접속 보안에 대한 암호*/
      char usrname[MAXTIDENT+2];   /*사용자 인증 보안에 대한 계정*/
      char usrpwd[MAX_PASSWD_LENGTH+2]; /*사용자 인증 보안에 대한 암호*/
      int flags; /*비요청 메시지 유형과 시스템 접근 방법결정*/
} ;

#include <stdio.h>
#include <usrinc/atmi.h>
void main(int argc, char *argv[])
{
    int ret;
    char *buf;
    long len;
    TPSTART_T  *tpinfo;

    tpinfo = (TPSTART_T *)tpalloc(“TPSTART”, NULL, sizeof(TPSTART_T));
    if (tpinfo==NULL) { error processing }

    strcpy(tpinfo->cltname, “cli1”);
    strcpy(tpinfo->usrname, “navis”);
    strcpy(tpinfo->dompwd, “tmax”);
    tpinfo->flags = TPUNSOL_HND;
    ret=tpstart(tpinfo);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (buf==NULL) {error processing };

    ret=tpcall(“SERVICE”, buf, 20, &buf, &len, TPNOFLAGS);
    if (ret==-1) { error processing }

    data process....
    tpfree((char *) buf);
    tpend();
}

# include  <atmi.h>
int  tpend (void)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <usrinc/atmi.h>

void main(int argc, char *argv[])
{
    char    *sndbuf, *rcvbuf;
    long    rcvlen, sndlen;
    int     ret;

    ret=tpstart((TPSTART_T *)NULL)
    if (ret==-1) {error processing }

    buf = (char *)tpalloc(“STRING”, NULL, 0)
    if (buf=NULL) { error processing }

    data process …

    ret=tpcall(“SERVICE”, buf, 0, &buf, &len, TPNOFLAGS);
    if (ret==-1) { error processing }

    data process …
    printf(“ data: %s\n”, buf);
    tpfree((char *)buf);
    tpend();
}

# include <atmi.h>
int tpcall (char *svc, char *idata, long ilen, char **odata, long *olen,
            long flags)

#include <stdio.h>
#include <usrinc/atmi.h>

void main(int argc, char *argv[])
{
    int ret;
    char *sndbuf, *rcvbuf;
    long sndlen,  rcvlen;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    sndbuf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (sndbuf==NULL) {error processing };

    rcvbuf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (rcvbuf==NULL) {error processing };

    data process....

    sndbuf=strlen(sndbuf);
    ret=tpcall(”SERVICE”, sndbuf, sndlen, &rcvbuf, &rcvlen, TPNOCHANGE);
    if (ret==-1) { error processing }

    data process....

    tpfree((char *)sndbuf);
    tpfree((char *)rcvbuf);
    tpend();
}

# include <atmi.h>
int tpacall (char *svc, char *data, long len, long flags)

#include <stdio.h>
#include <usrinc/atmi.h>
void main(int argc, char *argv[])
{
    char *buf;
    int ret,cd;
    long len;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret<0) { error processing }

    buf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (buf==NULL) {error processing }
    data process....

    cd = tpacall(“SERVICE”, sndbuf, 20, TPNOTIME);
    if (cd<0) {error processing }
    data process…

    ret=tpgetrply(&cd, (char **)&buf, &len, TPNOTIME);
    if (ret<0) { error processing }
    data process....

    tpfree((char *)buf);
    tpend();
}

# include <atmi.h>
int  tpgetrply(int *cd, char **data, long *len, long flags)

#include <stdio.h>
#include <usrinc/atmi.h>
void main(int argc, char *argv[])
{
    int ret;
    long len;
    char *buf;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }
    data process …

    cd = tpacall(“SERVICE”, buf, 0, TPNOFLAGS);
    if (cd==-1) { error procesing }
    data process....

    ret=tpgetrply(&cd, &buf, &len, TPNOTIME);
    if (ret==-1) { error processing }
    data process....

    tpfree(buf);
    tpend();
}

# include <atmi.h>
int tpcancel (int cd)

#include <stdio.h>
#include <usrinc/atmi.h>
void main(int argc, char *argv[])
{
    char *test[2];
    int ret, i, cd[2];
    long len;

    if (argc != 4) { error processing }
    ret=tpstart((TPSTART_T *)NULL;
    if (ret==-1) { error processing }

    for (i=0; i<3; i++)
    {
        test[i] = tpalloc(“STRING”,NULL,0);
        if (test[I])==NULL} { error processing }
        strcpy(test[i],argv[i+1]);
        cd[i]=tpacall(“SERVICE”, test[i], 0, TPNOTIME);
    )

    ret=tpcancel(cd[1]);         /* 2번째 응답을 취소한다. */
    if (ret==-1) { error processing }
    for (i=0; i<3; i++)
    {
        ret=tpgetrply(&cd[i], (char **)&test[i], &len, TPNOTIME)
        if (ret==-1) printf(“Can’t rcv data from service of %d\n”,cd[i]);
        else prtinf(“%dth rcv data : %s\n”, I+1, test[I]);
        tpfree(test[I]);
    }
    tpend();
}

# include  <atmi.h>
int  tpconnect (char  *svc,  char  *data,  long  len,  long  flags)

#include <stdio.h>
#include <usrinc/atmi.h>

void main(int argc, char *argv[])
{
    char *buf;
    int ret, cd;
    long len, revent;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf=tpalloc(“STRING”,NULL,0);
    if (buf=NULL) { error procesing }

    data process ....

    cd = tpconnect(“SERVICE”,sndbuf,0,TPRECVONLY);
    if (cd==-1) { error processing }
    data process....

    ret=tprecv(cd, &buf, &len, TPNOFLAGS, revent);
    if (ret==-1) { error processing }
    tpfree(buf);
    tpend();
}

# include <atmi.h>
int  tpsend (int  cd,  char  *data,  long  len,  long  flags,  long  *revent)

#include <stdio.h>
#include <usrinc/atmi.h>
#include “../sdl/demo.s”

main(int argc,char* argv[])
{
    int ret, cd;
    struct dat *buf;
    long revent, len;

    if (argc!=3) {error processing }
    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf=(struct dat *)tpalloc(“STRUCT”, “dat”, 0);
    if (buf==NULL) { error processing }
    strcpy(buf->sdata, argv[1]);
    data process….

    cd=tpconnect(“SERVICE”, buf, 0, TPSENDONLY);
    if (cd==-1) { error processing }
    strcpy(buf->sdata, argv[2]);
    data process….

    ret=tpsend(cd, buf, 0,TPRECVONLY,&revent);
    if (ret==-1) { error processing }

    ret=tprecv(&cd,(char**)&buf,&len,TPNOTIME,&revent);
    if (ret==-1) { error processing }
    data process....

    tpfree(buf);
    tpend();
}

# include <atmi.h>
int  tprecv (int cd, char **data, long *len, long flags, long *revent)

#include <stdio.h>
#include <usrinc/atmi.h>
#include “../sdl/demo.s”

main(int argc,char* argv[])
{
    int ret, cd;
    struct dat *buf;
    long revent, len;
    if (argc!=3) {error processing }
    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf=(struct dat *)tpalloc(“STRUCT”, “dat”, 0);
    if (buf==NULL) { error processing }
    strcpy(buf->sdata, argv[1]);
    data process….

    cd=tpconnect(“SERVICE”, buf, 0, TPSENDONLY);
    if (cd==-1) { error processing }
    strcpy(buf->sdata, argv[2]);
    data process….

    ret=tpsend(cd, buf, 0,TPRECVONLY,&revent);
    if (ret==-1) { error processing }
    ret=tprecv(cd,(char**)&buf,&len,TPNOTIME,&revent);
    if (ret==-1) { error processing }
    data process....

    tpfree(buf);
    tpend();
}

# include  <atmi.h>
int  tpdiscon (int cd)

#include <stdio.h>
#include <stdlib.h>
#include <usrinc/atmi.h>

void main(int argc, char *argv[])
{
    int ret, cd;
    char *buf
    long len, revent;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf=tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }

    data process....
    cd=tpconnect(“SERVICE”,buf,0,TPRECVONLY);

    if (cd==-1) { error processing }
    data process....
    ret=tprecv(cd, (char **)&buf, &len, TPNOFLAGS, &revent);
    if (ret==-1 && revent != TPEV_SENDONLY && revent != TPEV_SVCSUCC)
    { error processing }
    printf(“received data = %s\n”, buf);
    if (atoi(buf)>90) {
        ret=tpdiscon(cd);
        if (ret==-1) {error processing }
        tpfree(buf);
        tpend();
        exit(1);
    }

    data process....
    tpfree(buf);
    tpend();
}

# include  <atmi.h>
Unsolfunc *tpsetunsol (void ( *disp ) ( char  *data,  long  len,  long  flags ))

#include <stdio.h>
#include <usrinc/atmi.h>
#include “../sdl/demo.s”

void get_unsol(char *data, long len, long flags)
{
    printf(“get unsolicited data = %s\n”, data);
    data process....
}

void main(int argc, char *argv[])
{
    int ret;
    char *buf;
    long len;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }
    ret=tpsetupsol_flag(TPUNSOL_HND);
    if (ret==-1) { error processing }

    ret=tpsetunsol(get_unsol);
    if (ret==TPUNSOLERR) { error processing }

    buf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (buf==NULL) {error processing };
    data process...

    ret=tpcall(“SERVICE”, buf, 20, (char **)&buf, &len, TPNOFLAGS);
    if (ret==-1) { error processing }
    data process...

    tpfree((char *)buf);
    tpend();
}

#include <tmaxapi.h>
int  tpgetunsol (int type, char **data, long *len, long flags)

#include <stdio.h>
#include <string.h>
#include <usrinc/tmaxapi.h>

void main(int argc, char *argv[])
{
    int ret;
    char *buf;
    long len;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf=tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }
    data process....

    while(1)
    {
        ret=tp_sleep(2);
        if (ret==-1) { error processing }

        if (ret==0)
            printf(“nothing happened\n”);
        else {
            ret=tpgetunsol(UNSOL_TPSENDTOCLI, (char **)&buf, &len, TPNOCHANGE);
            if (ret==-1) { error processing }
            printf(“received data : %s\n”, buf);
        }

        data process....
        if (strncmp(buf, “end”, 3)==0) break;
    }

    data process....
    tpfree(buf);
    tpend();
}

#include <tmaxapi.h>
int  tpset_timeout (int sec)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/tmaxapi.h>

void main(int argc, char *argv[])
{
    int ret;
    char *sndbuf, *rcvbuf;
    long sndlen,  rcvlen;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    sndbuf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (sndbuf==NULL) {error processing };
    rcvbuf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (rcvbuf==NULL) {error processing };
    data process....

    sndbuf=strlen(sndbuf);
    ret=tpset_timeout(4);
    if (ret==-1) { error processing }

    ret=tpcall(“SERVICE”, sndbuf, sndlen, &rcvbuf, &rcvlen, TPNOCHANGE);
    if (ret==-1) { error processing }
    data process....

    tpfree((char *)sndbuf);
    tpfree((char *)rcvbuf);
    tpend();
}

#include <tmaxapi.h>
int  tpsetsvctimeout (int sec, long flags)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <stdlib.h>
#include <usrinc/tmaxapi.h>
#include <usrinc/tdlcall.h>

TOUPPER(TPSVCINFO *msg)
{
        int             i;

        if ( tpsetsvctimeout(10, 0) < 0 )
              ;
            //error handle code
        printf("TOUPPER service is started!\n");
        sleep(15);
        printf("INPUT : data=%s\n", msg->data);

        for (i = 0; i < msg->len; i++)
            msg->data[i] = toupper(msg->data[i]);
        printf("OUTPUT: data=%s\n", msg->data);
        tpreturn(TPSUCCESS,0,(char *)msg->data, 0,0);
}

# include <atmi.h>
char * tpalloc (char *type, char *subtype, long size)

#include <stdio.h>
#include <usrinc/atmi.h>
#include “../sdl/demo.s”

void main(int argc, char *argv[])
{
    int ret;
    struct data *buf;
    long len;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret<0) { error processing }
    buf=(struct data *)tpalloc(“STRUCT”, “data”,0);
    data process....

    ret=tpcall(“SERVICE”, (char *)sndbuf, 0, (char **)&rcvbuf, &len, TPNOFLAGS);
    if (ret<0) {error processing }
    data process....
    tpfree((char *)buf);
    tpend();
}

# include <atmi.h>
char  * tprealloc (char *ptr, long size)

#include <stdio.h>
#include <usrinc/atmi.h>
void main(int argc, char *argv[])
{
    char *buf;
    buf=tpalloc(“STRING”,NULL,10);
    if (buf==NULL) { error processing }
    buf=tprealloc(buf,20);  /* ok */
    if (buf==NULL) { error processing }

    buf=”test”;
    buf=tprealloc(buf,30);  /*error : TPEINVAL */
    if (buf==NULL) { error processing }
}

# include <atmi.h>
void  tpfree(char *ptr)

#include <usrinc/atmi.h>
#include <stdio.h>
#include “../sdl/demo.s”

void main(int argc, char *argv[])
{
    int ret;
    struct data *buf;
    char *message, *message2;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf=(struct data *)tpalloc(“STRUCT”, “data”,0);
    if (buf==NULL) { error processing }
    message=tpalloc(“STRING”, NULL, 0);
    if (message==NULL) { error processing }

    message2=tpalloc(“CARRAY”, NULL, 20);
    if (message==NULL) { error processing }

    data process....
    tpfree((char *)buf);
    tpfree(message);
    tpfree((char *)message2);
    tpend();
}

#include <atmi.h>
long  tptypes (char  *ptr, char  *type, char  *subtype)

#include <stdio.h>
#include <usrinc/atmi.h>
#include “../sdl/demo.s”
main(int argc, char *argv[])
{
    int ret;
    struct sel_o *rcvbuf;
    char type[9], subtype[17];
    long size;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }
    buf=(struct sel_o*)tpalloc(“STRUCT”,”sel_o”,0);
    if (buf==NULL) {error processing };

    size =tptypes((char*)buf, type,subtype);
    if (size==-1) {error processing };
    printf (“buf : size %d, type %s, subtype %s\n\n”, size, type, subtype);

    /*rcvbuf : size 1024, type STRUCT, subtype sel_o */
    data process...
    tpfree((char *)buf);
    tpend();
}

#include <tx.h>
int  tx_begin (void)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/tx.h>

void main(int argc, char *argv[])
{
    char *buf;
    int ret,cd;
    long len, revent;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (buf==NULL) {error processing };

    data process.…

    ret=tx_set_transaction_timeout( 5 );
    if (ret<0) { error processing }

    ret=tx_begin();
    if (ret<0) { error processing }

    cd = tpconnect(“SERVICE”, buf, 20, TPRECVONLY);
    if (cd==-1) { error processing }

    ret = tprecv(cd, (char **)&buf, &len,TPNOFLAGS, &revent)};
    if (ret < 0 && revent != TPEV_SVCSUCC)
        tx_rollback();
    else
        tx_commit();

    data process....

    tpfree((char *)buf);
    tpend();
}

# include  <tx.h>
int  tx_commit(void)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/tx.h>

void main(int argc, char *argv[])
{
    char *buf;
    int ret,cd;
    long len, revent;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (buf==NULL) {error processing };

    data process.…

    ret=tx_set_transaction_timeout( 5 );
    if (ret<0) { error processing }

    ret=tx_begin();
    if (ret<0) { error processing }

    cd = tpconnect(“SERVICE”, buf, 20, TPRECVONLY);
    if (cd==-1) { error processing }

    ret = tprecv(cd, (char **)&buf, &len,TPNOFLAGS, &revent)};
    if (ret < 0 && revent != TPEV_SVCSUCC)
       tx_rollback();
    else
       tx_commit();

    data process....
    tpfree((char *)buf);
    tpend();
}

#include  <tx.h>
int tx_info (TXINFO  *info)

struct TXINFO {
       XID                      xid;
       COMMIT_RETURN            when_return;
       TRANSACTION_CONTROL      transaction_control;
       TRANSACTION_TIMEOUT      transaction_timeout;
       TRANSACTION_STATE        transaction_state;
};

#include <stdio.h>
#include <string.h>
#include <usrinc/atmi.h>
#include <usrinc/tx.h>
void main(int argc, char *argv[])
{
    int ret;
    long len;
    char *buf;
    TXINFO info;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (buf==NULL) {error processing };
    data process....
    ret=tx_begin();
    if (ret<0) { error processing }

    ret=tpcall(“SERVICE”, buf, 20, (char **)&buf, &len, TPNOFLAGS);
    if (ret==-1) { error processing }

    if (tx_info(&info)==1) printf(“In transaction \n”);
    else printf(“Not in transaction \n”);

    if (strncmp(buf, “err”, 3)==0) tx_rollback();
    else  tx_commit();

    data process....
    tpfree((char *)buf);
    tpend();
}

#include  <tx.h>
int  tx_rollback(void)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/tx.h>

void main(int argc, char *argv[])
{
    char *buf;
    int ret,cd;
    long len, revent;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (buf==NULL) {error processing };
    data process.…
    ret=tx_set_transaction_timeout( 5 );
    if (ret<0) { error processing }

    ret=tx_begin();
    if (ret<0) { error processing }

    cd = tpconnect(“SERVICE”, buf, 20, TPRECVONLY);
    if (cd==-1) { error processing }
    ret = tprecv(cd, (char **)&buf, &len,TPNOFLAGS, &revent)};
    if (ret < 0 && revent != TPEV_SVCSUCC)  tx_rollback();
    else    tx_commit();
    data process....

    tpfree((char *)buf);
    tpend();
}

# include  <tx.h>
int  tx_set_transaction_timeout (TRANSACTION_TIMEOUT  timeout)

#include <usrinc/atmi.h>
#include <usrinc/tx.h>

void main(int argc, char *argv[])
{
    int ret;
    long len;
    char *buf;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) {error processing };

    ret=tx_set_transaction_timeout( 5 );
    if (ret<0) { error processing }

    ret=tx_begin();
    if (ret<0) { error processing }
    ret = tpcall(“SERVICE”, (char *)buf, strlen(buf), (char **)&buf, &len,
                   TPNOFLAGS);
    if (ret == -1) {
        tx_rollback();
        error processing
    }
    data process ….
    ret = tx_commit();
    if (ret < 0) { error processing }

    data process...
    tpfree((char *)buf);
    tpend();
}

# include  <tx.h>
int  tx_set_transaction_control(TRANSACTION_CONTROL  control)

#include <usrinc/atmi.h>
#include <usrinc/tx.h>

int main(int argc, char *argv[])
{
    int ret;
    long len;
    char *buf;

    ret = tpstart((TPSTART_T *)NULL);
    if (ret == -1) { error processing }

    buf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (buf==NULL) {error processing };
    ret = tx_set_transaction_timeout(5);
    if (ret < 0){ error processing }

    ret = tx_set_transaciont_control(TX_UNCHAINED);
    if (ret < 0){ error processing }
    ret = tx_begin();
    if (ret < 0) { error processing }
    data process....

    ret = tpcall(“SERVICE1”, (char *)buf, strlen(buf), (char **)&buf, &len,
                  TPNOFLAGS);
    if (ret == -1)
    {
        tx_rollback();
        error processing
    }

    data process...
    ret = tpcall(“SERVICE2”, (char *)buf, strlen(buf), (char **)&buf, &len,
                   TPNOFLAGS);
    if (ret == -1)
    {
        tx_rollback();
        error processing
    }
    data process ….

    ret = tx_commit();
    if (ret < 0) { error processing }
    data process...

    tpfree((char *)buf);
    tpend();
}

#include  <tx.h>
int  tx_set_commit_return (COMMIT_RETURN  when_return)

#include <usrinc/tx.h>

int main(int argc, char *argv[])
{
    int ret;
    long len;
    char *buf;

    ret = tpstart((TPSTART_T *)NULL);
    if (ret == -1) { error processing }

    buf = (char *)tpalloc(“CARRAY”, NULL, 20);
    if (buf==NULL) {error processing };
    ret = tx_set_transaction_timeout(5);
    if (ret < 0){ error processing }

    ret = tx_set_commit_return(TX_COMMIT_COMPLETED);
    if (ret < 0){ error processing }

    ret = tx_begin();
    if (ret < 0){ error processing }

    data process....
    ret = tpcall(“SERVICE1”, (char *)buf, strlen(buf), (char **)&buf, &len,
                   TPNOFLAGS);
    if (ret == -1)
    {
        tx_rollback();
        error processing
    }

    data process...
    ret = tpcall(“SERVICE2”, (char *)buf, strlen(buf), (char **)&buf, &len,
                   TPNOFLAGS);
    if (ret == -1)
    {
        tx_rollback();
        error processing
    }

    data process ….

    ret = tx_commit();
    if (ret < 0) { error processing }

    data process...

    tpfree((char *)buf);
    tpend();
}

# include  <tmaxapi.h>
int  tpenq (char *qname, char *svc, char *data, long len, long flags)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/tmaxapi.h>

void main(int argc, char *argv[])
{
    int ret;
    char *buf;
    long len;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }
    data process....

    ret=tpenq(“RQ”, “SERVICE”, (char *)buf, strlen(buf), TPRQS);
    if (ret==-1) { error processing }
    data process....

    ret=tpdeq(“RQ”, “SERVICE”, (char **)&buf, (long *)&len, TPRQS);
    if (ret==-1) { error processing }
    data process....

    tpfree(buf);
    tpend();
}

# include  <tmaxapi.h>
int  tpdeq (char *qname, char *svc, char **data, long *len, long flags)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/tmaxapi.h>

void main(int argc, char *argv[])
{
    int ret;
    char *buf;
    long len;
    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }
    data process....

    ret=tpenq(“RQ”, “SERVICE”, (char *)buf, strlen(buf), TPRQS);
    if (ret==-1) { error processing }
    data process....

    ret=tpdeq(“RQ”, “SERVICE”, (char **)&buf, (long *)&len, TPRQS);
    if (ret==-1) { error processing }
    data process....

    tpfree(buf);
    tpend();
}

# include  <tmaxapi.h>
int  tpqstat (char *qname, long  flags)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/tmaxapi.h>

void main(int argc, char *argv[])
{
    int ret, i;
    char *buf;

    if (argc!=2) { error processing }
    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) {error processing }

    buf = (char *)tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }
    strcpy(buf, argv[1]);

    data process…

    ret=tpenq(“RQ”, NULL, (char *)buf, strlen(buf), TPRQS);
    if (ret==-1) {error processing }
    printf(“qstat :”);
    for (i=0;i<4;i++) {
        ret=tpqstat(“rq”, i);
        if (ret==-1) {error processing }
        printf(“  %d”,ret);        /* qstat :  1  0  0  1 */
    }
    printf(“\n”);
    data process…

    ret=tpenq(“RQ”, “SERVICE”, (char *)buf, strlen(buf), TPRQS);
    if (ret==-1) {error processing }
    printf(”qstat :”);

    for (i=0;i<4;i++) {
        ret=tpqstat(“rq”, i);
        if (ret==-1) {error processing }
        printf(”  %d”,ret);        /* qstat :  2  0  0  2 */

    }
    printf(“\n”);
    tpfree((char *)buf);
    tpend();
}

# include <tmaxapi.h>
int  tpextsvcname (char *data, char *svc)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/tmaxapi.h>
void main(int argc, char *argv[])
{
    int ret;
    char *buf, *svc_name;
    long len;

    ret=tpstart((TPSTART_T *)NULL);
    if (ret==-1) { error processing }

    buf = (char *)tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }
    data process....

    ret=tpenq(“RQ”, “SERVICE”, (char *)buf, strlen(buf), TPRQS);
    if (ret==-1) { error processing }
    data process....

    ret=tpdeq(“RQ”, “SERVICE”, (char **)&buf, (long *)&len, TPRQS);
    if (ret==-1) { error processing }

    ret=tpextsvcname(buf, svc_name);
    if (ret==-1) { error processing }
    printf(“svc name : %s    ,”,svc_name);
    data process....

    tpfree(buf);
    tpend();
}

# include <tmaxapi.h>
long tpsubscribe(char *eventname, char *filter, TPEVCTL *ctl, long flags)

struct tpevctl {
    long ctl_flags;
    long post_flags;
    char svc[XATMI_SERVICE_NAME_LENGTH];
    char qname[RQ_NAME_LENGTH];
};
typedef struct tpevctl TPEVCTL;

# include <tmaxapi.h>
int tpunsubscribe(long sd, long flags)

# include <tmaxapi.h>
int tppost(char *eventname, char *data, long len, long flags)

# include <atmi.h>
int tpbroadcast (char *nodename, char *usrname, char *cltname,
                 char *data, long len, long flags)

#include <stdio.h>
#include <usrinc/atmi.h>
void main(int argc, char *argv[])
{
    int ret;
    char *buf;
    TPSTART_T *tpinfo;

    tpinfo = (TPSTART_T *)tpalloc(“TPSTART”, NULL, sizeof(TPSTART_T));
    if (tpinfo==NULL) { error processing }
    strcpy(tpinfo->cltname, “cli1”);
    strcpy(tpinfo->usrname, “navis”);
    ret=tpstart(tpinfo);
    if (ret==-1) { error processing }

    buf=tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }
    data process…

    tpbroadcast(“tmax”, NULL, NULL, buf, 0, TPNOFLAGS);
    data process....

    tpfree(buf);
    tpend();
}

# include <tmaxapi.h>
int WinTmaxAcall(TPSTART_T *sinfo, HANDLE wHandle, unsigned int msgtype,
                 char *svc, char *sndbuf, int len, int flags)

...
#include <usrinc/tmaxapi.h>
#define WM_WINTMAX_RECV WM_USER + 1
...

BEGIN_MESSAGE_MAP(CWinTmaxAcall2TestDlg, CDialog)
...
ON_MESSAGE(WM_WINTMAX_RECV, OnWinTmaxAcall)
...
END_MESSAGE_MAP()

BOOL CWinTmaxAcall2TestDlg::OnInitDialog()
{
    CDialog::OnInitDialog();
    ...
    ret = tmaxreadenv(“tmax.env”, “TMAX”);
    if (ret == -1){
        AfxMessageBox(“tmaxreadenv fail...”);
        return FALSE;
    }
    return TRUE;  // return TRUE  unless you set the focus to a control
}

void CWinTmaxAcall2TestDlg::OnOK()
{
    ...
    GetDlgItemText(IDC_EDIT1, m_Input);
    lstrcpy((LPTSTR)buf, (LPCTSTR)m_Input.operator const char *());
    ...

    buf = tpalloc(“STRING”, NULL, 0);
    if (buf == NULL){
        AfxMessageBox(“buf alloc fail...”);
        return FALSE;
    }

    ret = WinTmaxAcall((TPSTART_T *)NULL, m_hWnd, WM_WINTMAX_RECV,
           “TOUPPER”, buf, 0, TPNOFLAGS);
    if (ret == -1){
        error processing
    }
}

LRESULT CWinTmaxAcall2TestDlg::OnWinTmaxAcall(WPARAM wp, LPARAM lp)
{
    char msg[100];
    memset(msg, 0x00, 100);
    TPSVCINFO *get = (TPSVCINFO *)wp;
    if (lp < 0){
        error processing
    }
    ...
    SetDlgItemText(IDC_EDIT2, get->data);
    return 0;
}

# include <tmaxapi.h>
int WinTmaxAcall2(TPSTART_T *sinfo, WinTmaxCallback fn, char *svc,
                  char *sndbuf, int len, int flags)

#include <usrinc/tmaxapi.h>
#define WM_WINTMAX_RECV WM_USER + 1
int mycallfn(unsigned int, long);
...

BEGIN_MESSAGE_MAP(CWinTmaxAcall2TestDlg, CDialog)
...
END_MESSAGE_MAP()

BOOL CWinTmaxAcall2TestDlg::OnInitDialog()
{
    CDialog::OnInitDialog();
    ...
    ret = tmaxreadenv(“tmax.env”, “TMAX”);
    if (ret == -1){
        AfxMessageBox(“tmaxreadenv fail...”);
        return FALSE;
    }
    return TRUE;  // return TRUE  unless you set the focus to a control
}

void CWinTmaxAcall2TestDlg::OnOK()
{
    ...
    GetDlgItemText(IDC_EDIT1, m_Input);
    lstrcpy((LPTSTR)buf, (LPCTSTR)m_Input.operator const char *());
    ...
    buf = tpalloc(“STRING”, NULL, 0);
    if (buf == NULL){
        AfxMessageBox(“buf alloc fail...”);
        return FALSE;
    }
    ret = WinTmaxAcall2((TPSTART_T *)NULL, (WinTmaxCallback)mycallfn,
                       “TOUPPER”, (char *)buf, 0, TPNOFLAGS);
    if (ret == -1){
        error processing
    }
}

int mycallfn(unsigned int msg, long retval)
{
    TPSVCINFO *svcinfo;
    char infomsg[30];
    memset(infomsg, 0x00, sizeof(infomsg));
    svcinfo = (TPSVCINFO *)msg;
    strncpy(infomsg, svcinfo->data, svcinfo->len);
    if (retval != 0){
        strcpy(infomsg,tpstrerror(retval));
        AfxMessageBox(infomsg);
        return -1;
    } else {
        strncpy(infomsg, svcinfo->data, sizeof(infomsg) - 1);
        AfxMessageBox(infomsg);
        return 1;
    }
}

# include <WinTmax.h>
int WinTmaxStart(TPSTART_T *tpinfo)

# include <WinTmax.h>
int WinTmaxEnd(void)

# include <WinTmax.h>
int WinTmaxSetContext(void *winhandle, unsigned int msgType, int slot)

...
int CTMaxGwView::Connect()
{
    CString szTemp, Fname;
    WinTmaxEnd();
    int Ret = tmaxreadenv(TMAXINI, “TMAX117”);
    if(Ret<0)
    {
        szTemp.Format(“tmaxreadenv error”);
        LogDisplay2(2, (char *)(const char *)szTemp, szTemp.GetLength());
        return FALSE;
    }
    if (WinTmaxStart((TPSTART_T *)NULL) == -1) {
        szTemp.Format(“WinTmaxStart 에러 = [%s]”, tpstrerror(tperrno));
        LogDisplay2(2, (char *)(const char *)szTemp, szTemp.GetLength());
        return FALSE;
    }

    WinTmaxSetContext(m_hWnd, WM_TMAX_RECV_RDP, 0);
    WinTmaxSetContext(m_hWnd, WM_TMAX_RECV_ERR, 1);
    WinTmaxSetContext(m_hWnd, WM_TMAX_RECV, 2);

    return TRUE;
}

# include <WinTmax.h>
int WinTmaxSend(int recvContext, char *svc, char *data, long len, long flags)

rc = WinTmaxSetContext(hwd, 0x300, -1);
int nSendResult = WindTmaxSend(rc, (LPSTR)(LPCSTR)strService, (Char*)tpbuf, nLen, TPNOFLAGS);
/*
  이후 내부 Thread에서 응답 메시지를 처리하여 해당 윈도우로 다음과 같이 메시지를 전달한다.
  SendMessage(hwd, 0x300, (UINT) &msg, callRet);
*/

...
int CTMaxGwView::SendData2(char *data, long nLen)
{
    CString szTemp;
    m_send_length.Format(“%d”,nLen);
    UpdateData(FALSE);

    char *tpbuf = tpalloc(“STRING”, NULL, nLen);
    if (tpbuf == NULL) {
        szTemp.Format(“tpalloc Error [%s]”, tpstrerror(tperrno));
        LogDisplay2(2, (char *)(const char *)szTemp, szTemp.GetLength());
        return -1;
    }

   memcpy(tpbuf, data, nLen);

   CString strService;
   strService.Format(“TOUPPER_STRING”);

   int nSendResult=WinTmaxSend(2,(LPSTR)(LPCSTR)strService, (char*)tpbuf, nLen, 0);
   tpfree(tpbuf);
    …
}

#include <usrinc/atmi.h>
int tpgetctxt(int *ctxtid, long flags)

int newContext()
{
    int i;
    int id;
    i = tpstart(tpinfo);
    if (i < 0)
    {
       printf(“\t[newContext]tpstart fail[%d][%s]\n",tperrno,tpstrerror(tperrno));
       tpfree((char *)tpinfo);
       return -1;
    }
    i = tpgetctxt(&id,TPNOFLAGS);
    if (i < 0)
    {
       printf("\t[newContext]tpgetctxt fail[%d][%s]\n",tperrno,tpstrerror(tperrno));
       return -1;
    }
    return id;
}

typedef param {
    int ctxtid;
    TPSVCINFO *svcinfo;
} param_t;

MSERVICE(TPSVCINFO *svcinfo)
{
    pthread_t tid;
    param_t param;

    printf("MSERVICE service is started!");
    tpgetctxt(&param.ctxtid, TPNOFLAGS);
    param.svcinfo = svcinfo;

    pthread_create(&tid, NULL, THREAD_ROUTINE, &param);
    pthread_join(tid, NULL);

    printf("MSERVICE service is finished!");
    tpreturn(TPSUCCESS, 0, svcinfo->data, 0L, TPNOFLAGS);
}

void *THREAD_ROUTINE(void *arg)
{
    param_t *param;
    TPSVCINFO *svcinfo;

    param = (param_t *)arg;
    svcinfo = param->svcinfo;

    if (tpsetctxt(param->ctxtid, TPNOFLAGS) == -1) {
        printf("tpsetctxt(%d) failed, [tperrno:%d]", param->ctxtid, tperrno);
        return NULL;
    }

    tpcall("MTOUPPER", sndbuf, 0, &rcvbuf, &rcvlen, TPNOFLAGS);

    if (tpsetctxt(TPNULLCONTEXT, TPNOFLAGS) == -1) {
        printf("tpsetctxt(TPNULLCONTEXT) failed, [tperrno:%d]", tperrno);
        return NULL;
    }

    return NULL;
}

#include <usrinc/atmi.h>
int tpsetctxt(int ctxtid, long flags)

int altContext(int id)
{
    int i;
    int ret;
    ret = tpsetctxt(id, TPNOFLAGS);
    if (ret < 0)
    {
       printf(“\t[altContext]tpsetctxt fail[%d][%s]\n"tperrno,
              tpstrerror(tperrno));
       tpfree((char *)tpinfo);
       return -1;
    }
    return 1;
}

typedef param {
    int ctxtid;
    TPSVCINFO *svcinfo;
} param_t;

MSERVICE(TPSVCINFO *svcinfo)
{
    pthread_t tid;
    param_t param;

    printf("MSERVICE service is started!");
    tpgetctxt(&param.ctxtid, TPNOFLAGS);
    param.svcinfo = svcinfo;

    pthread_create(&tid, NULL, THREAD_ROUTINE, &param);
    pthread_join(tid, NULL);

    printf("MSERVICE service is finished!");
    tpreturn(TPSUCCESS, 0, svcinfo->data, 0L, TPNOFLAGS);
}

void *THREAD_ROUTINE(void *arg)
{
    param_t *param;
    TPSVCINFO *svcinfo;

    param = (param_t *)arg;
    svcinfo = param->svcinfo;

    if (tpsetctxt(param->ctxtid, TPNOFLAGS) == -1) {
        printf("tpsetctxt(%d) failed, [tperrno:%d]", param->ctxtid, tperrno);
        return NULL;
    }

    tpcall("MTOUPPER", sndbuf, 0, &rcvbuf, &rcvlen, TPNOFLAGS);

    if (tpsetctxt(TPNULLCONTEXT, TPNOFLAGS) == -1) {
        printf("tpsetctxt(TPNULLCONTEXT) failed, [tperrno:%d]", tperrno);
        return NULL;
    }

    return NULL;
}