commsdms.c

电信数字交换机用户数据联机下载入磁带程序

    }/* end of if nread > 0 */
else {
    rc = -1;
    }/* end of if nread <= 0 */
free(read_buffer);
free(msg_buf);
return rc;
}


/*
On receive a packet return 1, else return 0
Note: packet is terminated by null char(\x0)
*/
#define MAX_FDS        96      /* maximum file descriptors */
int SelectTcpStream(char *packet,char *name)
{
    struct timeval seltime;
    fd_set readfds;
    int new_socket;
    char new_name[MAX_TCP_STREAM_NAME];
    struct TCP_Stream_Node_t *current_node,*new_node;
    char temp_buffer[512];

    /* 1. set the selecting time */
    seltime.tv_sec = 0; seltime.tv_usec = 10;

    /* 2. clear and set the file descriptors(socket) */
    FD_ZERO(&readfds);
    current_node = &fst_node;
    while (current_node) {
        if (current_node->socket != -1)
            FD_SET(current_node->socket,&readfds);
        current_node = current_node->next;
        }

    /* 3. check if anything received */
    if (select(MAX_FDS,&readfds,(fd_set*)0,(fd_set*)0,&seltime))
    {
        current_node = &fst_node;
        while (current_node)
        {
            if (current_node->socket != -1)
            {
                if (FD_ISSET(current_node->socket,&readfds))
                {
                    switch(current_node->type)
                    {
                    case TCP_SERVER:
                        /* try to accept the connection */
                        new_socket = (*(current_node->accept_fn))(current_node,new_name);
                        if (new_socket != -1)
                        {

                            /* === Added code 1997.04.01 === */
                            if (CAPINodeStatus(new_name) == TCP_CONNECTED) {
                                sprintf(temp_buffer,"%s seem to already connected, but reconnecting now !",new_name);
                                (*record_err)(temp_buffer);
                                if (ClearNode(new_name) == 1) {
                                    sprintf(temp_buffer,"previous node for %s cleared",new_name);
                                    (*record_err)(temp_buffer);
                                    }
                                }
                            /* === End added code === */

                            new_node = GetIdleTcpNode();
                            if (new_node == NULL)
                            {
                                close(new_socket);/* break the connection */
                                sprintf(temp_buffer,"SelectTcpStream: can not get a new node for %s",new_name);
                                (*record_err)(temp_buffer);
                            }
                            else
                            {
                                /* setup new node info. */
                                /* DEL on 97-3-30 */ /* memset(new_node,0,sizeof(struct TCP_Stream_Node_t)); */
                                new_node->type = TCP_CHILD;
                                new_node->status = TCP_CONNECTED;
                                new_node->socket = new_socket;
                                strcpy(new_node->name,new_name);
                                /* === Add by Jason, 97.11.15 === */
                                /* for new TCP_SERVER node, use the default STX&ETX */
                                new_node->stx[0] = TCP_STX;
                                new_node->stx[1] = '\0';
                                new_node->etx[0] = TCP_ETX;
                                new_node->etx[1] = '\0';
                                new_node->format = 1;
                                /* ============================= */
                            }
                        }
                        else  {  /* failed to accept connection */
                            sprintf(temp_buffer,"SelectTcpStream: Server node %s accept connection failed !!",current_node->name);
                            (*record_err)(temp_buffer);
                            }
                        break;
                    case TCP_CLIENT:
                    case TCP_CHILD: /* data incomming ... */
                        if (CAPIProcessStream(current_node) == -1)
                        {
                            close(current_node->socket);/* break the connection */
                            current_node->socket = -1;
                            if(current_node->type == TCP_CLIENT)
                                current_node->status = TCP_WAIT_RETRY;
                            else
                                current_node->type = TCP_NOTUSED;
                            sprintf(temp_buffer,"SelectTcpStream: error process TCP stream for %s",current_node->name);
                            (*record_err)(temp_buffer);
                        }
                        break;
                    case TCP_NOTUSED:
                        sprintf(temp_buffer,"SelectTcpStream: node %s marked NOTUSED but socket still remains open, CLOSE IT !!",current_node->name);
                        (*record_err)(temp_buffer);
                        close(current_node->socket);
                        current_node->socket = -1;
                        break;
                    default:
                        (*record_err)("SelectTcpStream: Invalid node type !");
                        break;
                    }// end switch
                }// something received
            }// end socket is valid
            current_node = current_node->next;
        }// end while
    }//end selected something
    tcp_timer();
    return GetPacket(packet,name);
}

/*
on error return -1, else return 1
Note: packet must terminated by NULL char
*/
int SendTcpPacket(char *packet,char *name)
{
    struct TCP_Stream_Node_t *current_node;
    char *buffer;
    char temp_buffer[512];
    int len;
    int rc;
    /* === add by Jason, 97.8.19 === */
    int stx_etx_len;
    /* ==============================*/

    /* 1. search the matched node */
    current_node = &fst_node;
    while (current_node) {
        if (current_node->type != TCP_NOTUSED)
            if (strcmp(current_node->name,name) == 0) break;
        current_node = current_node->next;
        }
    if (current_node == NULL) {
        sprintf(temp_buffer,"no matched node by name:%s",name);
        (*record_err)(temp_buffer);
        return -1;
        }

    /* 2. makeup the packet sending over the network */
    len = strlen(packet);
    buffer = (char*)calloc(len+2,sizeof(char));
    if (buffer == NULL) {
        (*record_err)("failed to allocate temp memory for sending !");
        return -1;
        }

    memset(buffer,0,len+2);

    /* === add by Jason, 97.8.19 ===*/
    if (current_node->format == 1) {    /* default stx & etx */
        stx_etx_len = 2;
        buffer[0] = TCP_STX;
        memcpy(buffer+1,packet,len);
        buffer[len+1] = TCP_ETX;
        }
    else {
        stx_etx_len = 0;
        memcpy(buffer,packet,len);
        }
    /* =============================*/


    /* 3. send the packet */
    rc = write(current_node->socket,buffer,len + stx_etx_len);    // Modify by Jason, 97.8.19
    if (rc != len + stx_etx_len) {                                // Modify by Jason, 97.8.19
        sprintf(temp_buffer,"node %s:total %d bytes requesting to send, but only %d bytes sent",name,len+2,rc);
        (*record_err)(temp_buffer);
        if (current_node->socket != -1) {
            close(current_node->socket);
            /* ====== Add by dong ,97.8.19 =======*/
            if (current_node->type == TCP_CLIENT)
                current_node->status = TCP_WAIT_RETRY;
            else
                current_node->type = TCP_NOTUSED;
            /* ============= end add =============*/
            current_node->socket = -1;
            current_node->head = 0;
            current_node->tail = 0;
            }
        free(buffer);
        return -1;
        }
    free(buffer);
    return 1;
}

void ClearCAPI(void)
{
    struct TCP_Stream_Node_t *current_node,*next_node;

    if (fst_node.type != TCP_NOTUSED)
        if (fst_node.socket != -1)
            close(fst_node.socket);
    current_node = fst_node.next;
    while (current_node)
    {
        if (current_node->type != TCP_NOTUSED)
            if (current_node->socket != -1)
                close(current_node->socket);
        next_node = current_node->next;
        free(current_node);
        current_node = next_node;
    }
}

/*
on error return -1, else return 1
*/
int ClearNode(char *name)
{
    struct TCP_Stream_Node_t *current_node;
    char temp_buffer[512];

    current_node = &fst_node;
    while (current_node)
    {
        if (current_node->type != TCP_NOTUSED)
            if(strcmp(current_node->name,name) == 0) break;
        current_node = current_node->next;
    }
    if (current_node == NULL)
    {
        sprintf(temp_buffer,"CAPI:ClearNode: no matched node by name:%s",name);
        (*record_err)(temp_buffer);
        return -1;
    }
    if (current_node->type != TCP_NOTUSED)
    {
        if (current_node->socket != -1)
        {
            close(current_node->socket);
            current_node->type = TCP_NOTUSED;
            current_node->socket = -1;
            current_node->head = 0;
            current_node->tail = 0;
            /* === add by Jason, 97.8.19 === */
            current_node->stx[0] = TCP_STX;         /* set the default value */
            current_node->stx[1] = '\0';
            current_node->etx[0] = TCP_ETX;
            current_node->etx[1] = '\0';
            current_node->format = 1;
            /* ============================= */
        }
    }
    return 1;
}

/*
return the matched node's current status if the node exist.
values:
TCP_NULL_STATUS
TCP_WAIT_CONNECT
TCP_CONNECTED
TCP_WAIT_RETRY
*/
int CAPINodeStatus(char *name)
{
    struct TCP_Stream_Node_t *current_node;
    char temp_buffer[512];

    current_node = &fst_node;
    while (current_node)
    {
        if (current_node->type != TCP_NOTUSED)
            if (strcmp(current_node->name,name) == 0) break;
        current_node = current_node->next;
    }
    if (current_node == NULL)
    {
        //Deleted by Jason, 97.11.15
        //sprintf(temp_buffer,"CAPI:CAPINodeStatus: no matched node by name:%s",name);
        //(*record_err)(temp_buffer);
        return TCP_NULL_STATUS;
    }
    if (current_node->type != TCP_NOTUSED)
        return current_node->status;
    else
        return TCP_NULL_STATUS;
}



/* Function ChangeETX, Add by Jason, 97.11.15 */
void ChangeETX(char *name, char *ETX)
{
    struct TCP_Stream_Node_t *current_node;
    char temp_buffer[512];

// 1. search match node
    current_node = &fst_node;
    while (current_node) {
        if (current_node->type != TCP_NOTUSED)
           if (strcmp(current_node->name,name) == 0)
               break;
        current_node = current_node->next;
        }
// 2. no match node
    if (current_node == NULL) {
        sprintf(temp_buffer,"CAPI:CAPINodeStatus: no matched node by name:%s",name);
        (*record_err)(temp_buffer);
        return;
        }

// 3. change ETX
    strcpy(current_node->etx, ETX);
}



/* Function ChangeSTX, Add by Jason, 97.11.15 */
void ChangeSTX(char *name, char *STX)
{
    struct TCP_Stream_Node_t *current_node;
    char temp_buffer[512];

// 1. search match node
    current_node = &fst_node;
    while (current_node) {
        if (current_node->type != TCP_NOTUSED)
           if (strcmp(current_node->name,name) == 0) break;
        current_node = current_node->next;
        }
// 2. no match node
    if (current_node == NULL) {
        sprintf(temp_buffer,"CAPI:CAPINodeStatus: no matched node by name:%s",name);
        (*record_err)(temp_buffer);
        return;
        }

// 3. change STX
    strcpy(current_node->stx, STX);
}



/* Function NoDelayConnect, Add by Jason, 98.9.21 */
int NoDelayConnect(int sk, struct sockaddr *des, int len)
{
int    i, j, flag;
struct timeval seltime;
fd_set readfds;

flag = fcntl(sk, F_GETFL);
if (flag < 0) {
    // close(sk);
    return -1;
    }
if (fcntl(sk, F_SETFL, flag | O_NDELAY) == -1) {
    //close(sk);
    return -1;
    }

for (i=0;i<10;i++) {
    j = connect(sk, des, len);
    if (j == 0)  break;
/* for SCO will alwayas return -1 , but set errno as EISCONN if use */
/* NO DELAY mode.                           */
    if (errno == EISCONN) {
        j = 0;
        break;
        }
    // Delay
    seltime.tv_sec = 0;
    seltime.tv_usec = 10000;        // 0.01 sec
    FD_ZERO(&readfds);
    FD_SET(sk,&readfds);
    select(sk+1,&readfds,(fd_set*)0,(fd_set*)0,&seltime);
    }
if (j != 0) {
    //close(sk);
    return -1;
    }
/* set socket to block mode */
flag &= ~O_NDELAY;
if (fcntl(sk, F_SETFL, flag) == -1) {
    //close(sk);
    return -1;
    }
return (sk);
}

/* end of file */