Function

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

#include <stdio.h>
#include <usrinc/atmi.h>
void main(int argc, char* argv[])
{
   int ret, usrerrno=0;
   char *sndbuf, *rcvbuf;
   ret=tpstart((TPSTART_T*)NULL);
   if (ret==-1){
      usrerrno=gettperrno();
      printf(“error no : %d\n”, usrerrno);
   }
   data process…
   tpend();
}

#include <usrinc/tmaxapi.h>
int tmax_chk_conn (int sec)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <usrinc/atmi.h>
#include <usrinc/fbuf.h>
#include <usrinc/tmaxapi.h>
#include “../fdl/demo_fdl.h”

main(int argc, char *argv[])
{
        FBUF    *sndbuf, *rcvbuf;
        int     fc, fg, ret,  i, chkno;
        char    sndata[30],    rcvdata[30];
        char     input[10], outdata[10];
        long    sndlen, rcvlen;
        int Count = 1;

        if (argc != 2)
            error processing…

        if ( (ret = tmaxreadenv( “tmax.env”,”TMAX” )) == -1 )
            error processing…

        /* Check for tpstart execution */
        /***
        chkno = tmax_chk_conn(-1);
        printf(“chkno = %d\n”, chkno);
        if(chkno < 0)
        {
              printf(“tpstart is not started\n”);
              printf(“errno = %d\tstrerror=%s\n”, tperrno, tpstrerror(tperrno) );
        }
        else if(chkno == 0)
        {
              printf(“tpstart is started\n”);
        }
        ***/

        if (tpstart((TPSTART_T *)NULL) == -1)
              error processing…
        if ((sndbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0)) == NULL)
              error processing…
        if ((rcvbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0)) == NULL)
              error processing…
        /* Check socket status */
        /***********
        chkno = tmax_chk_conn(0);
        printf(“chkno = %d\n”, chkno);
        if(chkno < 0)
        {
              printf(“The situation of socket is bad\n”);
              printf(“errno = %d\tstrerror=%s\n”, tperrno, tpstrerror(tperrno) );
        }
        else if(chkno == 0)
        {
              printf(“The situation of socket is good\n”);
        }
        **********/
        printf(“My Count = %d\n”, Count++);
        strcpy(input, “INPUT”);
        strcpy(sndata, argv[1]);
        fc = fbput(sndbuf, fbget_fldkey(input), sndata, 0);
        if (tpcall(“FDLTOUPPER”, (char *)sndbuf, 0, (char **)&rcvbuf,
                    (long *)&rcvlen, TPNOFLAGS) == -1)
              error processing…
        /* Check connection status by sending a message */
        chkno = tmax_chk_conn(1);
        printf(“chkno = %d\n”, chkno);
        if(chkno < 0)
        {
              printf(“The situation of connection(Message Transfer) is bad\n”);
              printf(“errno = %d\tstrerror=%s\n”, tperrno, tpstrerror(tperrno) );
        }
        else if(chkno == 0)
        {
              printf(“The situation of connection(Message Transfer) is good\n”);
        }

        strcpy(outdata, “OUTPUT”);
        fg = fbget(rcvbuf, fbget_fldkey(outdata), rcvdata, 0);
        fbprint(rcvbuf);
        tpfree((char *)sndbuf);
        tpfree((char *)rcvbuf);
        tpend();
}

#include <tmaxapi.h>
int tmax_gq_count (void)

#include <tmaxapi.h>
int tmax_gq_get(char *key, long keylenl, char **data, long *lenl, long flagsl)

#include <tmaxapi.h>
SQ_KEYLIST_T tmax_gq_getkeylist(char *key, long keylenl)

#include <tmaxapi.h>
int tmax_gq_keygen(char *key, long keylenl)

#include <tmaxapi.h>
int tmax_gq_purge(char *key, long keylenl)

#include <tmaxapi.h>
int tmax_gq_put(char *key, long keylenl, char *data, long lenl, long flagsl)

#include <tmaxapi.h>
int tmax_get_sessionid(void)

#include <tmaxapi.h>
int tmax_keylist_count(SQ_KEYLIST_T keylist)

#include <tmaxapi.h>
int tmax_keylist_free(SQ_KEYLIST_T keylist)

#include <tmaxapi.h>
int tmax_keylist_getakey(SQ_KEYLIST_T keylist, int nth, SQ_KEYINFO_T *keyinfo)

Structure keyinfo {
     long keylen
     long datalen
     time_t starttime
     char *key
};

#include <usrinc/tmaxapi.h>
int tmax_make_unique_spri_in_domain(int nodeno, int spri)

#include <stdio.h>
#include <usrinc/tmaxapi.h>
...
tpsvrinit(int argc, char **argv)
{
    uniqspri = tmax_make_unique_spri_in_domain(my_nodeno, my_spri);
}

#include <tmaxapi.h>
int tmax_sq_count(void)

#include <tmaxapi.h>
int tmax_sq_get(char *key, long keylenl, char **data, long *lenl, long flagsl)

#include <tmaxapi.h>
SQ_KEYLIST_T tmax_sq_getkeylist(char *key, long keylenl)

#include <tmaxapi.h>
int tmax_sq_keygen(char *key, long keylenl)

#include <tmaxapi.h>
int tmax_sq_purge(char *key, long keylenl)

#include <tmaxapi.h>
int tmax_sq_put(char *key, long keylenl, char *data, long lenl, long flagsl)

#include <tmaxapi.h>
char *tmaxlastsvc(char *idata, char *odata, long flags)

#include <usrinc/atmi.h>
main(int argc, char *argv[])
{
   ...
   if(tpcall(“TOUPPER”, sndbuf, 0, &rcvbuf, &rcvlen, TPNOFLAGS)==-1){
      memset(svc, NULL, 16);
      strcpy((char *)svc, tmaxlastsvc(sndbuf, rcvbuf, TPNOFLAGS));
      printf(“servicename = %s\n”, svc);
      error processing
   }
   ...
}

#include <tmaxapi.h>
int tmaxreadenv (char *file, char *label)

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

void main(int argc, char* argv[])
{
    tmaxreadenv(“tmax.env”, “tmax”);  /*obtains environment variable from the "tmax" section in "tmax.env"*/
    tpstart((TPSTART_T *)NULL);
    data process…
    tpend();
}

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

#include <tmaxapi.h>
int tp_usleep (int usec)

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

void main(int argc, char *argv[])
{
    int ret, cd;
    char *buf;
    long 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<0) { error processing }
    while(1)
    {
        ret=tp_usleep(2000000);
        if (ret<0) {error processing }
        if (ret==0) printf("waited 2sec..\n");
        else {
            printf("data received!\n");
            break;
        }
    }
    ret=tprecv(cd, &buf, &len, TPNOFLAGS, &revent);
    if (ret<0) { error processing }
    data process....
    tpend();
}

#include <tuxfml.h>
int tpabort (long flags)

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

void main(int argc, char *argv[])
{
    char *buf;
    int ret;
    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…
    ret = tpbegin(5, TPNOFLAGS);
    if (ret < 0){ error processing }

    ret=tpcall(“SERVICE",(char *)buf,strlen(buf),(char **)&buf,&len,TPNOFLAGS);
    if (ret == -1)
    {
        ret = tpabort(TPNOFLAGS);
        if (ret < 0){ error processing }
        tpfree(buf);
        tpend();
        exit(1);
    }

    ret = tpcommit(TPNOFLAGS);
    if (ret < 0){ error processing }
    tpfree(buf);
    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 <usrinc/tmaxapi.h>
int tpacallsvg (int svgno, char *svc, char *data, long lenl, long flagsl)

#include <usrinc/tmaxapi.h>
#include “../fdl/demo_fdl.h”

int main(int argc, char *argv[])
{
    FBUF    *sndbuf, *rcvbuf;
    int     ret, I, cd;
    char    sndata[30],     rcvdata[30];
    long    sndlen, rcvlen;
    struct svglist *svg_list;
    char svc[32];

    ret = tmaxreadenv( “tmax.env”,”TMAX” );
    ret = tpstart((TPSTART_T *)NULL);
    sndbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0)};
    rcvbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0));
    strcpy(sndata, argv[1]);

    ret = fbput(sndbuf, INPUT, sndata, 0);
    strcpy(svc, “FDLTOUPPER”);
    svg_list = (struct svglist *)tpgetsvglist(svc, 0);

    for(i=0; i< svg_list->ns_entry; i++)
    {
        printf(“\n”);
        printf(“ >>> tpcallsvg ( %d th svg )\n”, i+1);
        strcpy(sndata, argv[1]);
        ret = fbput(sndbuf, INPUT, sndata, 0);
        cd = tpacallsvg(svg_list->s_list[i], svc, (char *)sndbuf, 0, 0);
        if(cd < 0)
        {
            printf(“tpacall failed! errno = %d[%s]\n”, tperrno,
                     tpstrerror(tperrno));
            tpfree((char *)sndbuf);
            tpfree((char *)rcvbuf);
            tpend();
            exit(1);
        }
        ret = tpgetrply(&cd, (char **)&rcvbuf, (long *)&rcvlen, 0);
        ret = fbget(rcvbuf, OUTPUT, rcvdata, 0);
        fbprint(rcvbuf);
    }
    tpfree((char *)sndbuf);
    tpfree((char *)rcvbuf);
    tpend();
    return 0;
}

#include <usrinc/tmaxapi.h>
int tpalivechk(void)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <usrinc/atmi.h>
#include <usrinc/fbuf.h>
#include <usrinc/tmaxapi.h>
#include “../fdl/demo_fdl.h”

main(int argc, char *argv[])
{
    FBUF    *sndbuf, *rcvbuf;
    int     chkno;
    char    sndata[30], rcvdata[30];
    char    input[10], outdata[10];
    long    sndlen, rcvlen;

    if ( (ret = tmaxreadenv( “tmax.env”,”TMAX” )) == -1 ){
        printf( “tmax read env failed\n” );
        exit(1);
    }
    if (tpstart((TPSTART_T *)NULL) == -1)
        error processing…
    if ((sndbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0)) == NULL)
        error processing…
    if ((rcvbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0)) == NULL)
        error processing…
    /* Check socket status */
    chkno = tpalivechk();
    printf(“chkno = %d\n”, chkno);
    if(chkno < 0)
    {
        printf(“The situation of socket is bad\n”);
        printf(“errno = %d\tstrerror=%s\n”, tperrno, tpstrerror(tperrno) );
    }
    else if(chkno == 0)
    {
        printf(“The situation of socket is good\n”);
    }
    tpcall…
    data process…
    tpend();
}

# 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();
}

int tpbegin(unsigned long timeout, long flags);

#include <stdio.h>
#include <usrinc/atmi.h>
#include <tuxinc/tuxfml.h>
void main(int argc, char *argv[])
{
    char *buf;
    int ret;
    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…
    ret = tpbegin(5, TPNOFLAGS);
    if (ret < 0){ error processing }

    ret = tpcall(“SERVICE”, (char *)buf, strlen(buf),
                 (char **)&buf, &len, TPNOFLAGS);
    if (ret == -1)
    {
        ret = tpabort(TPNOFLAGS);
        if (ret < 0){ error processing }
        tpfree(buf);
        tpend();
        exit(1);
    }
    ret = tpcommit(TPNOFLAGS);
    if (ret < 0){ error processing }
    tpfree(buf);
    tpend();
}

# 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 <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 <usrinc/tmaxapi.h>
int tpcallsvg (int svgno, char *svc, char *idata, long ilenl, char **odata,
               long *olen, long flagsl)

#include <usrinc/tmaxapi.h>
#include “../fdl/demo_fdl.h”

int main(int argc, char *argv[])
{
    FBUF    *sndbuf, *rcvbuf;
    int     ret, i;
    char    sndata[30],     rcvdata[30];
    long    sndlen, rcvlen;
    struct svglist *svg_list;
    char svc[32];

    ret = tmaxreadenv( “tmax.env”,”TMAX” );
    ret = tpstart((TPSTART_T *)NULL);
    sndbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0)};
    rcvbuf = (FBUF *)tpalloc(“FIELD”, NULL, 0));
    strcpy(sndata, argv[1]);
    ret = fbput(sndbuf, INPUT, sndata, 0);
    strcpy(svc, “FDLTOUPPER”);
    svg_list = (struct svglist *)tpgetsvglist(svc, 0);
    for(i=0; i< svg_list->ns_entry; i++)
    {
        printf(“\n”);
        printf(“ >>> tpcallsvg ( %d th svg )\n”, i+1);
        strcpy(sndata, argv[1]);
        ret = fbput(sndbuf, INPUT, sndata, 0);
        if (tpcallsvg(svg_list->s_list[i], svc, (char *)sndbuf, 0,
            (char **)&rcvbuf, &rcvlen, 0) == -1)
        {
           printf("tpcall failed! errno = %d[%s]\n",tperrno,tpstrerror(tperrno));
           tpfree((char *)sndbuf);
           tpfree((char *)rcvbuf);
           tpend();
           exit(1);
        }
        ret = fbget(rcvbuf, OUTPUT, rcvdata, 0);
        fbprint(rcvbuf);
    }
    tpfree((char *)sndbuf);
    tpfree((char *)rcvbuf);
    tpend();
    return 0;
}

# 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]);         /* Cancel the second response. */
    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 <tuxfml.h>
int  tpcommit (long flags)

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

void main(int argc, char *argv[])
{
    char *buf;
    int ret;
    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…
    ret = tpbegin(5, TPNOFLAGS);
    if (ret < 0){ error processing }

    ret=tpcall("SERVICE",(char *)buf, strlen(buf), (char **)&buf, &len, TPNOFLAGS);
    if (ret == -1)
    {
        ret = tpabort(TPNOFLAGS);
        if (ret < 0){ error processing }
        tpfree(buf);
        tpend();
        exit(1);
    }
    ret = tpcommit(TPNOFLAGS);
    if (ret < 0){ error processing }

    tpfree(buf);
    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  <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 <usrinc/tmaxapi.h>
int tpdeq_ctl(char *qname, char *svc, TMQCTL *ctl, char **data,
              long *len, long flags);

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

main(int argc, char *argv[])
{
    char    *sndbuf, *rcvbuf;
    long    rcvlen, sndlen, revent;
    int ret, i, cd;
    TMQCTL   *ctl;

    ctl = (TMQCTL*)malloc(sizeof(TMQCTL));
    memset(ctl, 0, sizeof(TMQCTL));
    if (argc != 2) {
        printf(“Usage: toupper_rq string\n”);
        exit(1);
    }

    if ( (ret = tmaxreadenv( “tmax.env”,”TMAX” )) == -1 ){
        printf( “tmax read env failed\n” );
        exit(1);
    }

    if (tpstart((TPSTART_T *)NULL) == -1){
        printf(“tpstart failed\n”);
        exit(1);
    }

    if ((sndbuf = (char *)tpalloc(“STRING”, NULL, 0)) == NULL) {
        printf(“sendbuf alloc failed !\n”);
        tpend();
        exit(1);
    }

    if ((rcvbuf = (char *)tpalloc(“STRING”, NULL, 0)) == NULL) {
        printf(“recvbuf alloc failed !\n”);
        tpfree((char *)sndbuf);
        tpend();
        exit(1);
    }

    ret = tx_begin();
    if(ret < 0)
    {
        fprintf(stderr, “tx_begin() fail\n”);
        tpfree((char *)sndbuf);
        tpfree((char *)rcvbuf);
        exit(1);
    }

    strcpy(sndbuf, argv[1]);
    cd = tpdeq_ctl(“txrq1”, “TOUPPER”, ctl, &rcvbuf, &rcvlen, TPRQS );
    if (cd < 0)
    {
        printf(“tpdeq failed [%s]\n”, tpstrerror(tperrno) );
        tpfree((char *)sndbuf);
        tpfree((char *)rcvbuf);
        tpend();
        exit(1);
    }

    cd = tpdeq_ctl(“txrq1”, “TOUPPER”, ctl, &rcvbuf, &rcvlen, TPRQS );
    if (cd < 0)
    {
        printf(“tpdeq failed [%s]\n”, tpstrerror(tperrno) );
        tpfree((char *)sndbuf);
        tpfree((char *)rcvbuf);
        tpend();
        exit(1);
    }

    data process....
    ret = tx_commit();
    if(ret < 0)
    {
        fprintf(stderr, “tx_commit() fail\n”);
        tpfree((char *)sndbuf);
        tpfree((char *)rcvbuf);
        tx_rollback();
        exit(1);
    }
    tpfree((char *)sndbuf);
    tpfree((char *)rcvbuf);
    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  <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 <usrinc/tmaxapi.h>
int tpenq_ctl(char *qname, char *svc, TMQCTL *ctl, char *data, long len,
              long flags);

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

main(int argc, char *argv[])
{
    char    *sndbuf, *rcvbuf;
    long    rcvlen, sndlen, revent;
    int ret, i, cd;
    TMQCTL   *ctl;
    long t;

    ctl = (TMQCTL*)malloc(sizeof(TMQCTL));
    memset(ctl, 0, sizeof(TMQCTL));
    time(&t);
    ctl->deq_time = (int)t + 3;

    if (argc != 2) {
        printf(“Usage: toupper string\n”);
        exit(1);
    }
    if ( (ret = tmaxreadenv( “tmax.env”,”TMAX” )) == -1 ){
        printf( “tmax read env failed\n” );
        exit(1);
    }
    if (tpstart((TPSTART_T *)NULL) == -1){
        printf(“tpstart failed\n”);
        exit(1);
    }
    if ((sndbuf = (char *)tpalloc(“STRING”, NULL, 0)) == NULL) {
        printf(“sendbuf alloc failed !\n”);
        tpend();
        exit(1);
    }
    if ((rcvbuf = (char *)tpalloc(“STRING”, NULL, 0)) == NULL) {
        printf(“recvbuf alloc failed !\n”);
        tpfree((char *)sndbuf);
        tpend();
        exit(1);
    }
    ret = tx_begin();
    if(ret < 0)
    {
        fprintf(stderr, “tx_begin() fail\n”);
        tpfree((char *)sndbuf);
        tpfree((char *)rcvbuf);
        exit(1);
    }

    strcpy(sndbuf, argv[1]);
    cd = tpenq_ctl(“txrq1”, “TOUPPER”, ctl, (char *)sndbuf, 0, TPRQS );
    if (cd < 0) {
        printf(“tpenq failed [%s]\n”, tpstrerror(tperrno));
        tpfree((char *)sndbuf);
        tpfree((char *)rcvbuf);
        tpend();
        exit(1);
    }
    cd = tpenq_ctl(“txrq1”, “TOUPPER”, ctl, (char *)sndbuf, 0, TPRQS );
    if (cd < 0) {
        printf(“tpenq failed [%s]\n”, tpstrerror(tperrno));
        tpfree((char *)sndbuf);
        tpfree((char *)rcvbuf);
        tpend();
        exit(1);
    }
    data process....
    ret = tx_commit();
    if(ret < 0)
    {
        fprintf(stderr, “tx_commit() fail\n”);
        tpfree((char *)sndbuf);
        tpfree((char *)rcvbuf);
        tx_rollback();
        exit(1);
    }

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

    tpend();
}

# include  <atmi.h>
int  tperrordetail(int errno)

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

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

    data process…

    ret = tpcall(“SERVICE”, sndbuf, 20, &rcvbuf, &rcvlen, TPNOCHANGE);
    if (ret == -1){
        fprintf(stderr, “tpcall fail,,,[%d][%s]\n”,
                tperrordetail(tperrno), tpstrerror(tperrno));
        error processing
    }

    tpfree(buf);
    tpend();
}

# include <tmaxapi.h>
int  tpextsvcinfo (char *data, char *svc, int *type, int *errcode )

# 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 <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 <tmaxapi.h>
int  tpget_timeout(void)

#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=tpget_timeout();
    printf(“block time = %d\n”, sec);

    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 tpgetactivesvr(char *nodename, char **outbufp);

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

main(int argc, char *argv[])
{
    char    *sndbuf, *rcvbuf, *data;
    long    rcvlen, sndlen;
    int     ret, n, i;
    char nodename[35];

    if (argc != 2) {
        printf(“Usage: toupper string\n”);
        exit(1);
    }
    if ( (ret = tmaxreadenv( “tmax.env”,”TMAX” )) == -1 ){
        printf( “tmax read env failed\n” );
        exit(1);
    }

    if (tpstart((TPSTART_T *)NULL) == -1){
        printf(“tpstart failed\n”);
       exit(1);
    }

    if ((rcvbuf = (char *)tpalloc(“STRING”, NULL, 0)) == NULL) {
        printf(“recvbuf alloc failed !\n”);
        tpfree((char *)sndbuf);
        tpend();
        exit(1);
    }

    strcpy(nodename, “starbj”);
    if((n = tpgetactivesvr(nodename, &rcvbuf)) < 0) {
        printf(“getactivesvr failed\n”);
        tpfree((char *)rcvbuf);
        tpend();
        exit(1);
    }
    printf(“Total %d servers\n”, n);
    data = rcvbuf;
    for (i = 0; i < n; i++) {
        printf(“ACTIVE[%s]\n”, data);
        data += strlen(data) + 1;
    }
    tpfree((char *)sndbuf);
    tpfree((char *)rcvbuf);
    tpend();
}

#include <tmaxapi.h>
int tpgetcliaddr(int clid, int *ip, int *port, long flags);

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

TOUPPER(TPSVCINFO *msg)
{
        int             ret;
        int             clid;
        int             port;
        int*            ip;
        ...
        clid = tpgetclid();
        printf(“clid = %d\n”, clid);

        ret = tpgetcliaddr(clid, ip, &port, 0);
        if(ret < 0)
          error routine..

        printf(“ip = %s, port = %d\n”, inet_ntoa(ip), port);
        tpreturn(TPSUCCESS,0,(char *)msg->data, 0,0);
}

#include <tmaxapi.h>
#include <arpa/inet.h>
int tpgetcliaddr_ipv6(int clid, struct sockaddr_storage *saddr, long flags);

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

TOUPPER(TPSVCINFO *msg)
{
        int             ret;
        int             clid;
        int             portno;
        struct sockaddr_storage saddr;
        struct sockaddr_in *cli_sin4;
        struct sockaddr_in6 *cli_sin6;
        char ipaddrbuf[INET6_ADDRSTRLEN];
        const char *ipaddr = NULL;
        ...
        clid = tpgetclid();
        printf(“clid = %d\n”, clid);

        ret = tpgetcliaddr_ipv6(clid, &ipaddr, 0);
        if(ret < 0)
          error routine..

        if (saddr.ss_family == AF_INET) {
            cli_sin4 = (struct sockaddr_in *)&saddr;
            ipaddr = inet_ntop(AF_INET, &(cli_sin4->sin_addr), ipaddrbuf, sizeof(ipaddrbuf));
            portno = ntohs(cli_sin4->sin_port);
        } else if (saddr.ss_family == AF_INET6) {
            cli_sin6 = (struct sockaddr_in *)&saddr;
            ipaddr = inet_ntop(AF_INET6, &(cli_sin6->sin6_addr), ipaddrbuf, sizeof(ipaddrbuf));
            portno = ntohs(cli_sin6->sin6_port);
        }
        if (ipaddr == NULL)
            ipaddr = "unknown";

        printf(“ip = %s, port = %d\n”, ipaddr, portno);
        tpreturn(TPSUCCESS,0,(char *)msg->data, 0,0);
}

#include <tmaxapi.h>
int  tpgetclid(void)

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

SERVICE(TPSVCINFO *msg)
{
    int ret, clid;
    char *buf;

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

    clid = tpgetclid();
    if (clid==-1) { error process }

    ret=tpsendtocli(clid, buf, strlen(buf), 0);
    if (ret==-1) { error processing }
    data process….

    tpreturn(TPSUCCESS,0,buf, strlen(buf), 0);
}

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

#include <tmaxapi.h>
char *tpgetenv(char *name)

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

main(int argc, char *argv[])
{
    char *TMAXD, *SDLFI;
    TMAXD=tpgetenv(“TMAXDIR”);
    SDLFI=tpgetenv(“SDLFILE”);
    printf (“tmaxdir : %s\nsdlfile : %s\n”,TMAXD,SDLFI);
}

#include <tuxatmi.h>
int  tpgetlev(void)

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

EXEC SQL include sqlca.h;
EXEC SQL begin declare section;
struct emp *buf;
EXEC SQL end declare section;

DELETE(TPSVCINFO *msg)
{
    struct emp *buf;
    buf = (struct emp *)msg->data;
    data process...
    if (tpgetlev()) printf(“transaction mode\n”);
    else printf(« nontransaction mode\n »);
    EXEC SQL DELETE FROM emp
    WHERE empno = :buf->empno;
    data process...
    tpreturn(TPSUCCESS,0,buf, strlen(buf), 0);
}

#include <tmaxapi.h>
struct nodelist *tpgetnodelist()

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

SVGCALL(TPSVCINFO *msg)
{
        char *svcname = msg->data;

        struct nodelist *node = tpgetnodelist();
        if (node == NULL)
           ...error process

        for (i = 0; i < node->count; i++) {
                printf("[%d] %16s : %x:%p\n", i, node->nodelist[i].nodename,
                        node->nodelist[i].ipaddr, node->nodelist[i].port);
        }

        ...

        struct svglist *svg = tpgetsvglist_bynode(node->nodelist[1].nodename, svcname, 0);
        if (svg == NULL)
           ...error process

        for (i = 0; i < svg->ns_entry; i++) {
                printf("[%d] %d(%x)\n", i, svg->s_list[i], svg->s_list[i]);
        }

        ...

        tpreturn(TPSUCCESS,0,(char *)msg->data, msg->len,0);
}

#include <tmaxapi.h>
int  tpgetpeername(struct sockaddr *name, int *namelen)

#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <usrinc/atmi.h>
#inlcude <usrinc/tmaxapi.h>
...
DELETE(TPSVCINFO *msg)
{
    struct sockaddr_in cli;
    char ipAddr[16];
    int cli_len, ret;

    data process...
    memset((char *)&cli, 0, sizeof(cli));
    ret = tpgetpeername((struct sockaddr *)&cli, &cli_len);
    if (ret == -1){ error processing }
    else{
        memcpy(ipAddr, inet_ntoa(cli.sin_addr), 16);
    }
    printf(“ip = %s , port = %d\n”, ipAddr, cli.sin_port);
    data process...

    tpreturn(TPSUCCESS, 0, 0, 0, 0);
}

#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <usrinc/atmi.h>
#inlcude <usrinc/tmaxapi.h>
...
DELETE(TPSVCINFO *msg)
{
    struct sockaddr_storage cli_saddr;
    struct sockaddr_in *cli_sin4;
    struct sockaddr_in6 *cli_sin6;
    char ipaddrbuf[INET6_ADDRSTRLEN];
    const char *ipaddr = NULL;
    int cli_len, ret;
    int portno;

    data process...
    memset((char *)&cli_saddr, 0, sizeof(cli_saddr));
    cli_len = sizeof(cli_saddr);
    ret = tpgetpeername((struct sockaddr *)&cli_saddr, &cli_len);
    if (ret == -1) {
        error processing
    }
    else {
        if (cli_saddr.ss_family == AF_INET) {
            cli_sin4 = (struct sockaddr_in *)&cli_saddr;
            ipaddr = inet_ntop(AF_INET, &(cli_sin4->sin_addr), ipaddrbuf, sizeof(ipaddrbuf));
            portno = ntohs(cli_sin4->sin_port);
        } else if (cli_saddr.ss_family == AF_INET6) {
            cli_sin6 = (struct sockaddr_in *)&cli_saddr;
            ipaddr = inet_ntop(AF_INET6, &(cli_sin6->sin6_addr), ipaddrbuf, sizeof(ipaddrbuf));
            portno = ntohs(cli_sin6->sin6_port);
        }
        if (ipaddr == NULL)
            ipaddr = "unknown";
    }
    printf(“ip = %s , port = %d\n”, ipaddr, portno);
    data process...

    tpreturn(TPSUCCESS, 0, 0, 0, 0);
}

#include <ucs.h>
int tpgetrcahseqno()

#include <ucs.h>
void * tpgetrcainfo()

# 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 <tmaxapi.h>
int  tpgetsockname (struct sockaddr  *name,  int  *namelen)

#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <usrinc/atmi.h>
#inlcude <usrinc/tmaxapi.h>
...
DELETE(TPSVCINFO *msg)
{
    ...
    struct sockaddr_in cli;
    char ipAddr[16];
    int cli_len, ret, i;
    ...
    memset((char *)&cli, 0, sizeof(cli));

    ret = tpgetsockname((struct sockaddr *)&cli_saddr, &cli_len);
    if (ret == -1){
        error processing
    }
    else{
        memcpy(ipAddr, inet_ntoa(cli.sin_addr), 16);
    }
    printf(“ip = %s , port = %d\n”, ipAddr, cli.sin_port);
    ...
}

#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <usrinc/atmi.h>
#inlcude <usrinc/tmaxapi.h>
...
DELETE(TPSVCINFO *msg)
{
    struct sockaddr_storage cli_saddr;
    struct sockaddr_in *cli_sin4;
    struct sockaddr_in6 *cli_sin6;
    char ipaddrbuf[INET6_ADDRSTRLEN];
    const char *ipaddr = NULL;
    int cli_len, ret;
    int portno;

    data process...
    memset((char *)&cli_saddr, 0, sizeof(cli_saddr));
    cli_len = sizeof(cli_saddr);

    ret = tpgetsockname((struct sockaddr *)&cli_saddr, &cli_len);
    if (ret == -1) {
        error processing
    }
    else {
        if (cli_saddr.ss_family == AF_INET) {
            cli_sin4 = (struct sockaddr_in *)&cli_saddr;
            ipaddr = inet_ntop(AF_INET, &(cli_sin4->sin_addr), ipaddrbuf, sizeof(ipaddrbuf));
            portno = ntohs(cli_sin4->sin_port);
        } else if (cli_saddr.ss_family == AF_INET6) {
            cli_sin6 = (struct sockaddr_in *)&cli_saddr;
            ipaddr = inet_ntop(AF_INET6, &(cli_sin6->sin6_addr), ipaddrbuf, sizeof(ipaddrbuf));
            portno = ntohs(cli_sin6->sin6_port);
        }
        if (ipaddr == NULL)
            ipaddr = "unknown";
    }
    printf(“ip = %s , port = %d\n”, ipaddr, portno);
    ...
}

#include <usrinc/tmaxapi.h>
int tpgetsprlist(char *svc, int svgno, int *starti, int *endi, long flagsl);

main(int argc, char *argv[])
{
    int     ret;
    int     starti = 0, endi = 0;

    if (argc != 2) {
       printf(“Usage: argv[1] string\n”);
       exit(1);
       if((ret = tmaxreadenv( “tmax.env”,”TMAX” )) == -1 ){
          printf(“<%-15s> tmaxreadenv fail [%s]”, __FILE__, tpstrerror(tperrno));
          exit(1);
       }

    if (tpstart((TPSTART_T *)NULL) == -1){
        printf(“<%-15s> tpstart fail [%s]”, __FILE__, tpstrerror(tperrno));
        exit(1);
    }

    /* tpgetsprlist in client */
    ret = tpgetsprlist(argv[1], 2, &starti, &endi, 0);
    if (ret < 0) {
        printf(“<%-15s> tpgetsprlist fail [%s]”, __FILE__, tpstrerror(tperrno));
        exit(1);
    }
    else {
       printf(“Received Message : starti[%d], endi[%d]\n”, starti, endi);
    }
    tpend();
}

#include <tmaxapi.h>
struct svglist* tpgetsvglist(char *svc, long flags)

struct svglist {
    int ns_entry;
    int nf_entry;
    int *s_list;
    int *f_list;
};

#include <tmaxapi.h>
struct svglist *tpgetsvglist_bynode(char *nodename, char *svc, long flags)

struct svglist {
    int ns_entry;
    int nf_entry;
    int *s_list;
    int *f_list;
};

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

SVGCALL(TPSVCINFO *msg)
{
        char *svcname = msg->data;

        struct nodelist *node = tpgetnodelist();
        if (node == NULL)
           ...error process

        for (i = 0; i < node->count; i++) {
                printf("[%d] %16s : %x:%p\n", i, node->nodelist[i].nodename,
                        node->nodelist[i].ipaddr, node->nodelist[i].port);
        }

        ...

        struct svglist *svg = tpgetsvglist_bynode(node->nodelist[1].nodename, svcname, 0);
        if (svg == NULL)
           ...error process

        for (i = 0; i < svg->ns_entry; i++) {
                printf("[%d] %d(%x)\n", i, svg->s_list[i], svg->s_list[i]);
        }

        ...

        tpreturn(TPSUCCESS,0,(char *)msg->data, msg->len,0);
}

#include <tuxfatmi.h>
int tpgprio (void)

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

SERVICE(TPSVCINFO *msg)
{
    int ret, prio;
    prio = tpgprio();
    if (prio==-1) {
        error processing......
     }
    if (prio > 50)
        tpforward(“SERVICE1”, msg->data, msg->len, 0);
    else
        tpforward(“SERVICE2”, msg->data, msg->len, 0);
}

#include <tmaxapi.h>
struct svglist *tpmcall(char *qname, char *svc, char *data, long len, long flags)

struct svglist {
    int ns_entry;
    int nf_entry;
    int *s_list;
    int *f_list;
};

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

main(int argc, char *argv[])
{
    char    *sndbuf;
    int     ret;
    …

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

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

    ret = tpmcall(NULL, “TPMCALL”, sndbuf, 0, TPNOFLAGS);
    if (ret == NULL){  error processing  }
    …
}

#include <usrinc/tmaxapi.h>
struct svglistx* tpmcallx(char *svc, char *data, long len, long flags)

struct svglistx {
     int ns_entry; /* number of entries of s_list */
     int nf_entry; /* number of entries of f_list */
     int nr_entry; /* number of entries of r_list */
     int *s_list; /* list of server group numbers */
     int *f_list; /* list of tperrno of each server group */
     int *r_list; /* list of tpurcode of each server group */
};

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <usrinc/atmi.h>
#include <usrinc/tmaxapi.h>
main(int argc, char *argv[])
{
     char *sndbuf, *rcvbuf;
     long rcvlen, sndlen;
     struct svglistx svglist;
     struct svglistx *psvglist;
     int ret, i;

     psvglist = &svglist;
     if (argc != 2) {
          printf("Usage: toupper string\n");
          exit(1);
     }

     if ( (ret = tmaxreadenv( "tmax.env","TMAX" )) == -1 ){
          printf( "tmax read env failed\n" );
          exit(1);
     }

     if (tpstart((TPSTART_T *)NULL) == -1){
          printf("tpstart failed[%s]\n",tpstrerror(tperrno));
          exit(1);
     }

     if ((sndbuf = (char *)tpalloc("STRING", NULL, 0)) == NULL)
     {
          printf("sendbuf alloc failed !\n");
          tpend();
          exit(1);
     }

     if ((rcvbuf = (char *)tpalloc("STRING", NULL, 0)) == NULL)
     {
          printf("recvbuf alloc failed !\n");
          tpfree((char *)sndbuf);
          tpend();
          exit(1);
     }

     strcpy(sndbuf, argv[1]);
     psvglist = tpmcallx("TOUPPER", sndbuf, 0, TPBLOCK);
     if(psvglist == NULL)
     {
          printf("tpmcall is failed[%s]\n",
          tpstrerror(tperrno));
          tpfree((char *)sndbuf);
          tpfree((char *)rcvbuf);
          tpend();
          exit(1);
     }

     printf("send data: %s\n", sndbuf);
     printf("ns_entry = %d\n", psvglist->ns_entry);
     printf("nf_entry = %d\n", psvglist->nf_entry);
     printf("nr_entry = %d\n", psvglist->nr_entry);

     for(i=0; i<psvglist->ns_entry; i++)
          printf("psvglist->s_list[%d] = %d\n", i, psvglist->s_list[i]);
     for(i=0; i<psvglist->nf_entry; i++)
          printf("psvglist->f_list[%d] = %d\n", i, psvglist->f_list[i]);
     for(i=0; i<psvglist->nr_entry; i++)
          printf("psvglist->r_list[%d] = %d\n", i, psvglist->r_list[i]);

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

#include <atmi.h>
int tpnotify(CLIENTID *id, char *data, long len, long flags);

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/fbuf.h>
#include “../fdl/demo_fdl.h”

TOUPPER(TPSVCINFO* msg) {
    int i, n;
    char    rdata[100];
    FBUF    *stdata;

    stdata=(FBUF *)msg->data;
    memset(rdata, 0x00, sizeof(rdata));
    if (fbget(stdata, INPUT, rdata, 0) == -1){
    printf(“fbget failed errno = %d\n”, fberror);
    }

    for (i = 0; i < msg->len; i++) {
        rdata[i] = toupper(rdata[i]);
    }
    if (fbput(stdata, OUTPUT, rdata, 0) == -1)
        printf(“fbput failed\n”);

    i = tpnotify(&(msg->cltid), (char*)stdata, 0, TPACK);
    printf(“i= %d\n”, i);
    tpreturn(TPSUCCESS, 0, (char *)stdata, 0, 0);
}

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

#include <tmaxapi.h>
int tpputenv(char *string)

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

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

    SDLFI=tpgetenv(“SDLFILE”);
    if (SDLFI=NULL) ret=tpputenv(“SDLFILE=/tmax/sample/sdl/test.sdl”);
    if (ret<0) { error processing }

    SDLFI=tpgetenv(“SDLFILE”);
    printf (“tmax sdlfile : %s\n”,SDLFI);
}

# 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  tpqsvcstat (char *qname, char * svc, long  flags )

# 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>
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 <tmaxapi.h>
int  tpreissue(char *qname, char *filter, long flags)

#include <ucs.h>
int tpremoteconnect(char *host, int portno, int sec)

# include <tuxatmi.h>
int  tpscmt(long  flags)

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

int main(int argc, char *argv[])
{
    ...
    ret = tpstart((TPSTART_T *)NULL);
    if (ret == -1) {
        error processing
    }
    ...
    ret = tpscmt(TP_CMT_COMPLETED);
    if (ret < 0){
        error processing
    }

    ret = tpbegin();
    if (ret < 0){
        error processing
    }
    ...
    ret= tpcall(“SERVICE1”,(char*)buf, strlen(buf),(char **)&get,&rlen,TPNOFLAGS);
    if (ret == -1)
    {
        error processing
    }
    ...
    ret= tpcall(“SERVICE2",(char*)buf,strlen(buf),(char **)&get,&rlen,TPNOFLAGS);
    if (ret == -1)
    {
        error processing
    }

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

# 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 <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 <ucs.h>
int  tpsetfd (int  fd)

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <usrinc/ucs.h>
...
#define SERV_ADDR “168.126.185.129”
#define SERV_PORT 1500

int fd_read(int, char *, int);
extern int errno;

int usermain(int argc, char *argv[])
{
    ...
    int listen_fd, n, newfd;
    struct sockaddr_in my_addr, child_addr;
    socklen_t child_len;
    buf = tpalloc(“STRING”, NULL, 0);
    if (buf == NULL){
        error processing
    }

    memset((void *)&my_addr, NULL, sizeof(my_addr));
    memset((void *)&child_addr, NULL, sizeof(child_addr));
    listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1){
        error processing
    }

    my_addr.sin_family = AF_INET;
    inaddr = inet_addr(SERV_ADDR);
    my_addr.sin_port = htons((unsigned short)SERV_PORT);

    if (inaddr != -1){
        memcpy((char *)&my_addr.sin_addr, (char *)&inaddr, sizeof(inaddr));
    }
    ret = bind(listen_fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
    if (ret == -1){
        error processing
    }
    ret = listen(listen_fd, 5);
    if (ret == -1){
        error processing
    }

    ret = tpsetfd(listen_fd);
    if (ret == -1){
        error processing
    }
    ...

    while(1) {
        n = tpschedule(10);
        ...
        if (n == UCS_USER_MSG){
            if (tpissetfd(listen_fd)) {
                child_len = sizeof(child_addr);
                newfd = accept(listen_fd, &child_addr, &child_len);
                if (newfd == -1){
                    error processing
                }

            ret = tpsetfd(newfd);
            if (ret == -1){
                error processing
            }
        }

        if (tpissetfd(newfd)){
            /* Read the buffer from the socket */
            fd_read(newfd, buf, 1024);
            ret = tpcall(“SERVICE”, (char *)buf, sizeof(buf), (char **)&buf,
                           (long *)&rlen, TPNOFLAGS);
            if (ret == -1){
                error processing
            }
            ...
            tpclrfd(newfd);
            close(newfd);
        }
        ...
    }
    return 1;
}

#include <tmaxapi.h>
int  tpsleep (struct  timeval  *timeout)

struct timeval{
      long    tv_sec    /* seconds unit */
      long    tv_usec  /* 0.000001 (micro seconds) unit */
};

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

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

    struct timeval sl_time, *sleep;
    sl_time.tv_sec =3;
    sl_time.tv_usec=500000;
    sleep=&sl_time;

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

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

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

    ret=tpsleep(sleep); /* Wait for 3.5 seconds */
    if (ret==-1)
       { error processing }
    if (ret==0)
       printf(“waited 3.5sec\n”);

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

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

#include <usrinc/tmaxapi.h>
int tpspracall(char *svcname, int spri, char *data, long lenl, long flagsl);

...
main(int argc, char *argv[])
{
    char    *sndbuf, *rcvbuf;
    long    sndlen, rcvlen;
    int     ret, cd;
    int     starti = 0, endi = 0, spri = 0;
    if (argc != 2) {
        printf(“Usage: argv[1] string\n”);
        exit(1);
    }

    if ( (ret = tmaxreadenv( “tmax.env”,”TMAX” )) == -1 ){
        printf(“<%-15s> tmaxreadenv fail [%s]”, __FILE__, tpstrerror(tperrno));
        exit(1);
    }

    if (tpstart((TPSTART_T *)NULL) == -1){
        printf(“<%-15s> tpstart fail [%s]”, __FILE__, tpstrerror(tperrno));
        exit(1);
    }

    if ((sndbuf = (char*)tpalloc(“CARRAY”, 0, 0)) == NULL) {
        printf(“<%-15s> sndbuf tpalloc fail [%s]”, __FILE__, tpstrerror(tperrno));
        exit(1);
    }

    if ((rcvbuf = (char*)tpalloc(“CARRAY”, 0, 0)) == NULL) {
        printf(“<%-15s> sndbuf tpalloc fail [%s]”, __FILE__, tpstrerror(tperrno));
        tpfree((char*)sndbuf);
        exit(1);
    }

    /* tpgetsprlist in client */
    ret = tpgetsprlist(argv[1], 2, &starti, &endi, 0);
    if (ret < 0) {
        printf(“<%-15s> tpgetsprlist fail [%s]”, __FILE__, tpstrerror(tperrno)
    );
    exit(1);
    } else {
        /*printf(“Received Message from Server :
         starti[%d], endi[%d]\n”, starti, endi);*/
    }
    strcpy((char*)sndbuf, “tpspracall test”);

    /* tpspracall in client */
    for(spri = starti; spri <= endi; spri++) {
        cd = tpspracall(argv[1], spri, sndbuf, strlen(sndbuf), 0);
        if(cd < 0) {
            printf(“<%-15s> tpsprcall fail [%s]”, __FILE__, tpstrerror(tperrno));
            exit(1);
        } else {
            ret = tpgetrply(&cd, &rcvbuf, &rcvlen, 0);
            if(ret < 0) {
                printf(“Received Message from %d spri: tpgetrply fail[%s]\n”,
                         spri, tpstrerror(tperrno));
            } else {
                printf(“Received Message from %d spri: msg[%s], len[%d]\n”,
                         spri, rcvbuf, rcvlen);
            }
        }
    }
    tpend();
}

#include <usrinc/tmaxapi.h>
int tpspracall2(char *svcname, int startspri, int nth, char *data, long lenl, long flagsl);

...
main(int argc, char *argv[])
{
    char    *sndbuf, *rcvbuf;
    long    sndlen, rcvlen;
    int     ret, cd;
    int     starti = 0, endi = 0, spri = 0;
    if (argc != 2) {
        printf(“Usage: argv[1] string\n”);
        exit(1);
    }

    if ( (ret = tmaxreadenv( “tmax.env”,”TMAX” )) == -1 ){
        printf(“<%-15s> tmaxreadenv fail [%s]”, __FILE__, tpstrerror(tperrno));
        exit(1);
    }

    if (tpstart((TPSTART_T *)NULL) == -1){
        printf(“<%-15s> tpstart fail [%s]”, __FILE__, tpstrerror(tperrno));
        exit(1);
    }

    if ((sndbuf = (char*)tpalloc(“CARRAY”, 0, 0)) == NULL) {
        printf(“<%-15s> sndbuf tpalloc fail [%s]”, __FILE__, tpstrerror(tperrno));
        exit(1);
    }

    if ((rcvbuf = (char*)tpalloc(“CARRAY”, 0, 0)) == NULL) {
        printf(“<%-15s> sndbuf tpalloc fail [%s]”, __FILE__, tpstrerror(tperrno));
        tpfree((char*)sndbuf);
        exit(1);
    }

    /* tpgetsprlist in client */
    ret = tpgetsprlist(argv[1], 2, &starti, &endi, 0);
    if (ret < 0) {
        printf(“<%-15s> tpgetsprlist fail [%s]”, __FILE__, tpstrerror(tperrno)
    );
    exit(1);
    } else {
        /*printf(“Received Message from Server :
         starti[%d], endi[%d]\n”, starti, endi);*/
    }
    strcpy((char*)sndbuf, “tpspracall test”);

    /* tpspracall2 in client */
    cd = tpspracall2(argv[1], starti, 2, send_data, send_len, TPNOFLAGS);
    if(cd < 0) {
        printf(“<%-15s> tpsprcall fail [%s]”, __FILE__, tpstrerror(tperrno));
        exit(1);
    } else {
        ret = tpgetrply(&cd, &rcvbuf, &rcvlen, 0);
        if(ret < 0) {
            printf(“Received Message from %d spri: tpgetrply fail[%s]\n”,
                     spri, tpstrerror(tperrno));
        } else {
            printf(“Received Message from %d spri: msg[%s], len[%d]\n”,
                     spri, rcvbuf, rcvlen);
        }
    }
    tpend();
}

#include <tuxatmi.h>
int tpsprio (int prio, long flags)