Server API

# include <atmi.h>
void  tpreturn (int  rval, long  rcode, char  *data, long  len, long  flags)

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

SERVICE1(TPSVCINFO *msg)
{
    char *buf;
    long len;

    buf=tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processsing }
    buf=msg->data;
    data process....

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

    if (buf !=”SUCCESS”) {
        printf(“svc fail..\n”);
        tpreturn (TPFAIL, -1, NULL,0,0);
    }
    else {
        tpreturn(TPSUCCESS, 0, msg->data, msg->len, 0);
    }
}

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

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

SWITCH(TPSVCINFO *msg)
{
    int switch;
    char *buf;

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

    strcpy(buf, msg->data);
    data process…

    if (switch>5)
       tpforward(“SERVICE1”, buf, 0, 0);
    else
       tpforward(“SERVICE2”, buf, 0, 0);
}

# include <tmaxapi.h>
int  tpsvrinit (int  argc, char  **argv)

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

EXEC SQL INCLUDE sqlca.h;
tpsvrinit(int argc, char **argv)
{
    EXEC SQL begin declare section;
    char user_name[30];
    char user_passwd[30];
    EXEC SQL end declare section;
    EXEC SQL CONNECT scott IDENTIFIED BY tiger;
    return(0);
}

SERVICE(TPSVCINFO *msg)
{
    int ret, cd;
    char *buf;
    buf=tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }

    data process....
    cd=tpgetclid();
    if (cd==-1) { error processing }
    ret=tpsendtocli(cd, buf, 0, TPNOFLAGS);
    if (ret==-1) { error processing }

    data process....
    printf(“ Sevice end\n”);
    EXEC SQL COMMIT WORK RELEASE;
    tpreturn(TPSUCCESS, buf, strlen(buf), 0);
}

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

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

EXEC SQL INCLUDE sqlca.h;

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

    EXEC SQL begin declare section;
    ….
    EXEC SQL end declare section;
    EXEC SQL CONNECT : scott IDENTIFIED BY : tiger;
    buf=tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }
    data process….

    cd=tpgetclid();
    if (cd==-1) { error processing }
    ret=tpsendtocli(cd, buf, 0, TPNOFLAGS);
    if (ret==-1) { error processing }
    data process....

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

int tpsvrdone()
{
    printf(“ Sevice end\n”);
}

# include <tmaxapi.h>
int  tpsvrthrinit (int  argc, char  **argv)

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

void tpsvrthrinit(int argc, char **argv)
{
    param_t *param;
    param = get_threadspecificdata();
    if (pthread_create(&param->tid, NULL, THREAD_ROUTINE, (void *)param) != 0) {
        printf("user_create_thread failed\n");
        return -1;
    }
    pthread_mutex_init(&param->mutex, NULL);
    pthread_cond_init(&param->cond, NULL);
    return 0;
}

void tpsvrthrdone()
{
    void *ret;
    param_t *param;

    param = get_threadspecificdata();
    param->state = EXIT;
    pthread_cond_signal(&param->cond);
    pthread_join(param->tid, &ret);

    pthread_mutex_destroy(&param->mutex);
    pthread_cond_destroy(&param->cond);
    printf("user_create_thread destroyed\n");
}

SERVICE(TPSVCINFO *msg)
{
    param_t *param;
    param = get_threadspecificdata();
    ...
    ret = tpgetctxt(&param->ctxtid, TPNOFLAGS);
    ret = pthread_cond_signal(&param->cond);
    ...
}

void *THREAD_ROUTINE(void *arg)
{
    param_t *param;
    param = (param_t *)arg;

    while(1) {
        pthread_mutex_lock(&param->mutex); {
            pthread_cond_wait(&param->cond, &param->mutex);
            if (param->state == EXIT)
                break;
            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;
            }
            ...
        } pthread_mutex_unlock(&param->mutex);
    }
    return NULL;
}

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

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

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

    ret=tpsendtocli(clid, (char *)buf, 0, 0);
    if (ret==-1) { error processing }
    tpreturn(TPSUCCESS, 0, 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 <tmaxapi.h>
int tpchkclid(int clid)

int _discon(char **buf)
{
    int clid, n;
    clid = tpgetclid();
    n = tpchkclid(clid);
    if (n < 0) {
        printf(“Invalid Client\n”);
        return -1;
    }
   ...
}

#include <ucs.h>
int  tpschedule(int timeout)

#include <stdio.h>
#include <usrinc/atmi.h>
#include <usrinc/ucs.h>
int usermain(int argc, char *argv[])
{
    ...
    while(1)
    {
        ...
        tpschedule(3);
        ret = tpcall(“SERVICE”, (char *)buf, strlen(buf), (char **)&buf,
                      (long *)&rlen, TPNOFLAGS);
        if (ret == -1) { error processing}
        ...
    }
}

#include <ucs.h>
int tpuschedule (int timeout)

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

int usermain(int argc, char *argv[])
{
    ...
    while(1)
    {
        ...
        tpuschedule(3000000);
        ret = tpcall(“SERVICE”, (char *)buf, strlen(buf), (char **)&buf,
                      (long *)&rlen, TPNOFLAGS);
        if (ret == -1) { error processing }
        ...
     }
}

#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 <ucs.h>
int  tpissetfd (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 }

        tpsetfd(listen_fd);
        ...
        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 }
                    tpsetfd(newfd);
            }
            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 <ucs.h>
int  tpclrfd (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 }

    tpsetfd(listen_fd);
    ...
    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 }
            tpsetfd(newfd);
        }

        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 }
                ...
            ret = tpclrfd(newfd);
            if (ret == -1){ error processing }
            close(newfd);
        }
        ...
   }
   return 1;
}

#include <ucs.h>
CTX_T * tpsavectx(void)

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

CTX_T *ctx = NULL;

usermain(int argc, char *argv[])
{
    int ret, i;
    char *rcvbuf, *sndbuf;
    long sndlen;

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

    i = 0;
    while(1) {
        tpschedule(1);
        if (ctx != NULL)
        {
            i++;
            if ((sndbuf = (char *)tpalloc(“CARRAY”,NULL, 1024)) == NULL)
            { error processing }
            else
            {
                ...
                ret = tprelay(“TPRETURN”, sndbuf, sndlen, 0, ctx);
                if (ret==-1) { error processing }
                data process...
                ctx = NULL;
                tpfree(sndbuf);
            }
        }
    }
}

int RELAY(TPSVCINFO *rqst)
{
    ...
    ctx = tpsavectx();
    tpreturn(TPSUCCESS, 0, rqst->data, rqst->len, 0);
}

#include <tmaxapi.h>
int tpgetctx (CTX_T *ctxp)

RELAY_SVC(TPSVCINFO *msg)
{
    CTX_T *ctxp;
    ctxp=(CTX_T *)malloc(sizeof(CTX_T);
    ....
    ret = tpgetctx(ctxp);
    if (ret<0) {
        error process routine
    }
    .....
}

#include <ucs.h>
int tpcancelctx(CTX_T *ctxp);

RELAY_SVC(TPSVCINFO *msg) {
    .....
    ctxp = (CTX_T *)tpsavectx();
    .....
    ret=tpcancelctx(ctxp);
    if (ret<0) {
          error process routine
     }
     .....
     tpreturn(TPFAIL, sqlca.sqlcode, NULL, 0, TPNOFLAGS);
}

#include <ucs.h>
int  tprelay(char *svc, char *data, long len, long flags, CTX_T *ctxp);

...
#include <stdio.h>
#include <usrinc/ucs.h>
CTX_T *ctx = NULL;

DUMMY(TPSVCINFO *msg)
{
    data process ...
}

usermain(int argc, char *argv[])
{
    int ret, i;
    char *rcvbuf, *sndbuf;
    long sndlen;

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

    while(1) {
        tpschedule(1);
        if (ctx != NULL)
        {
            i++;
            if ((sndbuf = (char *)tpalloc(“CARRAY”,NULL, 1024)) == NULL)
            { error processing }
            else
            {
                 ...
                 ret = tprelay(“TPRETURN”, sndbuf, sndlen, 0, ctx);
                 if (ret==-1) { error processing }
                 data process...
                 ctx = NULL;
                 tpfree(sndbuf);
             }
        }
    }
}

int RELAY(TPSVCINFO *rqst)
{
   ...
   ctx = tpsavectx();
   tpreturn(TPSUCCESS, 0, rqst->data, rqst->len, 0);
}

# include <ucs.h>
int  tpregcb (UcsCallback)

typedef struct {
        long    urcode;     /* user response code */
        int     errcode;    /* response error code */
        int     msgtype;    /* message type (used as internal identifier) */
        int     cd;         /* connection descriptor */
        int     len;        /* length of response data */
        char    *data;      /* pointer to the response data */
} UCSMSGINFO;

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

void reply_receive(UCSMSGINFO *reply);
DUMMY(TPSVCINFO *msg)
{
    data process ….
}

int usermain(int argc, char *argv[])
{
    int ret;
    char *buf

    ret = tpregcb(reply_receive);
    if (ret == -1){ error processing }
    buf=tpalloc(“STRING”, NULL, 0);
    if (buf==NULL) { error processing }
    data process…
    while(1)
    {
        ...
        tpschedule(3);
        cd = tpacall(“SERVICE”, buf, strlen(buf), TPNOFLAGS);
        if (cd < 0) { error processing }
        ...
    }
}

void reply_receive(UCSMSGINFO *reply)
{
    rtcd = reply->errcode;

    if(rtcd != 0)
    {
         printf("[tperrno(%d) : %s]\n", rtcd,tpstrerror(rtcd));
         /* Error handling code */
    }

    printf(“data....%s\n”, reply->data);
}

#include <ucs.h>
int  tpunregcb (void)

...
#include <usrinc/atmi.h>
#include <usrinc/ucs.h>
void reply_receive(UCSMSGINFO *reply);

int usermain(int argc, char *argv[])
{
    ...
    ret = tpregcb(reply_receive);
    if (ret == -1){ error processing  }

    ret = tpunregcb();
    if (ret == -1){  error processing  }
    while(1)
    {
        ...
        tpschedule(3);
        cd = tpacall(“SERVICE”, buf, strlen(buf), TPNOFLAGS);
        if (cd < 0) { error processing  }
        ...
    }
}

void reply_receive(UCSMSGINFO *reply)
{
    printf(“first reply receive\n”);
    printf(“data....%s\n”, reply->data);
}