함수

#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>
char *tgstrerror(int tgerrno)

#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…

        /* tpstart 수행 여부 체크 */
        /***
        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…
        /* 소켓의 상태 점검 */
        /***********
        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…
        /* 메시지 전달로써 연결 상태 점검 */
        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_get_sessionid(void)

#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 <usrinc/tmaxapi.h>
int  tmax_grid_count(int flags)

#include <usrinc/tmaxapi.h>
int tmax_grid_create(char *key, int keylen, int flags)

#include <usrinc/tmaxapi.h>
int  tmax_grid_create2(char *key, int keylen, char *data, int len,
TG_WATHCER_CALLBACK callback, void *args, int flags)

#include <usrinc/tmaxapi.h>
int  tmax_grid_dequeue(char *key, int keylen, int *type, char **data, int *len, int flags)

#include <usrinc/tmaxapi.h>
int  tmax_grid_destroy(char *key, int keylen, int flags)

#include <usrinc/tmaxapi.h>
int tmax_grid_enqueue(char *key, int keylen, int type, void *data, int len, int flags)

#include <usrinc/tmaxapi.h>
int  tmax_grid_get(char *key, int keylen, int *type, char **data, int *len, int flags)

#include <usrinc/tmaxapi.h>
int  tmax_grid_get_child_with_index(TG_KEYLIST_T keylist, int nth,
                                   TG_KEYINFO_T * keyinfo)

#include <usrinc/tmaxapi.h>
TG_KEYLIST_T  tmax_grid_get_children(char *key, int keylen, int *child_count)

#include <usrinc/tmaxapi.h>
int  tmax_grid_is_exist(char *key, int keylen, int flags)

#include <usrinc/tmaxapi.h>
int  tmax_grid_keylist_free(TG_KEYLIST_T keylist)

#include <usrinc/tmaxapi.h>
int  tmax_grid_lock(char *key, int keylen, int timeout, int flags)

#include <usrinc/tmaxapi.h>
int tmax_grid_set(char *key, int keylen, int type, void *data, int len, int flags)

#include <usrinc/tmaxapi.h>
int  tmax_grid_unlock(char *key, int keylen, int flags)

#include <usrinc/tmaxapi.h>
int  tmax_grid_set_watcher(char *key, int keylen, TG_WATHCER_CALLBACK callback,
void *args, int flags)

#include <usrinc/tmaxapi.h>
int  tmax_grid_wait_watcher(int timeout, int flags)

#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 <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”);  /*”tmax.env”의 “tmax”절에서 환경변수를 얻음*/
    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…
    /* socket의 상태 점검 */
    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]);         /* 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 <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 <tmadmin.h>
int tpgetcliinfo(int clid, struct tmadm_cliinfo_body *info)

struct tmadm_cliinfo_body {
    int no; /* cli index */
    int clid; /* CLID */
    int clhno;
    int count;
    int idle;
    int reserve_int[3];
    char status[TMAX_NAME_SIZE];
    char addr[TMAX_IPADDR_SIZE];
    char usrname[TMAX_NAME_SIZE];
    int qpcount;
    int emaxcount;
    int reserved1;
    int reserved2;
};

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

PRINTCLIINFO(TPSVCINFO *msg)
{
   int i, ret, clid;
   struct tmadm_cliinfo_body cliinfo = {0, };

   clid = tpgetclid();
   if (clid < 0)
      error routine..

    ret = tpgetcliinfo(clid, &cliinfo);
    if (ret < 0)
       error routine..

     printf("INPUT : data=%s\n", msg->data);
     printf("CLIINFO : no:%d clid:%d clhno:%d count:%d idle:%d status:%s addr:%s usrname:%s\n",
             cliinfo.no, cliinfo.clid, cliinfo.clhno, cliinfo.count, cliinfo.idle,
             cliinfo.status, cliinfo.addr, cliinfo.usrname);

       ...

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

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