static int handle_dns_info ( DNS_DIC_PACKET *  packet )

static

Definition at line 1346 of file dic.c.

References BAD_CONN_TIMEOUT, COMMAND, bad_conn::conn, dic_serv::conn_id, Debug_on, dic_serv::def, DELETED, Dic_conns, DIM_FATAL, dim_get_keepalive_timeout(), dim_print_date_time(), DIMDNSREFUS, dll_init(), dll_insert_queue(), dll_remove(), dna_open_client(), dna_set_test_write(), dna_write(), Dns_dic_conn_id, dtq_clear_entry(), dtq_start_timer(), error_handler(), find_connection(), DNS_DIC_PACKET::format, dic_serv::format, dic_serv::format_data, Memory::free(), get_format_data(), i, id_get_ptr(), locate_bad(), Memory::malloc(), MAX_NODE_NAME, MAX_TASK_NAME, move_to_bad_service(), bad_conn::n_retries, DNS_DIC_PACKET::node_addr, DNS_DIC_PACKET::node_name, DIC_CONNECTION::node_name, ONCE_ONLY, dic_serv::pending, DNS_DIC_PACKET::pid, DIC_CONNECTION::pid, DNS_DIC_PACKET::port, DIC_CONNECTION::port, DNS_DIC_PACKET::protocol, recv_rout(), release_service(), retry_bad_connection(), bad_conn::retrying, send_service_command(), serv_id, dic_serv::serv_id, dic_serv::serv_name, DIC_DNS_PACKET::service, DNS_DIC_PACKET::service_def, DIC_CONNECTION::service_head, service_id, SERVICE_REQ::service_id, DNS_DIC_PACKET::service_id, SERVICE_REQ::service_name, service_tmout(), DIC_DNS_PACKET::size, SRC_DIC, DIC_DNS_PACKET::src_type, DNS_DIC_PACKET::task_name, DIC_CONNECTION::task_name, dic_serv::type, and WAITING_SERVER_UP.

Referenced by recv_dns_dic_rout().

{
        int conn_id, service_id;
        DIC_SERVICE *servp;
        char *node_name, *task_name;
        char node_info[MAX_NODE_NAME+4];
        int i, port, protocol, format, pid;
        register DIC_CONNECTION *dic_connp ;
        DIC_DNS_PACKET dic_dns_packet;
        register DIC_DNS_PACKET *dic_dns_p = &dic_dns_packet;
        SERVICE_REQ *serv_reqp;
        DIC_BAD_CONNECTION *bad_connp;
        int retrying = 0;
        int tmout;
        int send_service_command();
        int find_connection();
        void move_to_bad_service();
        void retry_bad_connection();

        service_id = vtohl(packet->service_id);

        servp = (DIC_SERVICE *)id_get_ptr(service_id, SRC_DIC);
        if(!servp)
                return(0);
        if(servp->serv_id != service_id)
                return(0);
        if(Debug_on)
        {
                dim_print_date_time();
                printf("Receiving DNS Info for service %s, id %d\n",servp->serv_name,
                        vtohl(packet->service_id));
        }
        node_name = packet->node_name; 
        if(node_name[0] == (char)0xFF)
        {
                error_handler(0, DIM_FATAL, DIMDNSREFUS, "DIM_DNS refuses connection");
                return(0);
        }
        
        task_name =  packet->task_name;
        strcpy(node_info,node_name);
        for(i = 0; i < 4; i ++)
                node_info[(int)strlen(node_name)+i+1] = packet->node_addr[i];
        port = vtohl(packet->port); 
        pid = vtohl(packet->pid); 
        protocol = vtohl(packet->protocol);
        format = vtohl(packet->format);

        if( Dns_dic_timr )
                dtq_clear_entry( Dns_dic_timr );
        if( servp->pending == DELETED ) {
                if( Dns_dic_conn_id > 0) {
                        dic_dns_p->size = htovl(sizeof(DIC_DNS_PACKET));
                        dic_dns_p->src_type = htovl(SRC_DIC);
                        serv_reqp = &dic_dns_p->service;
                        strcpy( serv_reqp->service_name, servp->serv_name );
                        serv_reqp->service_id = (int)htovl((unsigned)servp->serv_id | 0x80000000);
                        dna_write( Dns_dic_conn_id, dic_dns_p,
                                  sizeof(DIC_DNS_PACKET) );
                }
                release_service( servp );       
                return(0);
        }
        if( !node_name[0] ) 
        {
                servp->pending = WAITING_SERVER_UP;
                service_tmout( servp->serv_id ); 
                if( servp->pending == DELETED ) 
                {
                        if( Dns_dic_conn_id > 0) 
                        {
                                dic_dns_p->size = htovl(sizeof(DIC_DNS_PACKET));
                                dic_dns_p->src_type = htovl(SRC_DIC);
                                serv_reqp = &dic_dns_p->service;
                                strcpy( serv_reqp->service_name, servp->serv_name );
                                serv_reqp->service_id = (int)htovl((unsigned)servp->serv_id | 0x80000000);
                                dna_write( Dns_dic_conn_id, dic_dns_p,
                                        sizeof(DIC_DNS_PACKET) );
                        }
                        release_service( servp );
                }
                return(0);
        }
#ifdef OSK
        {
                register char *ptr;

                if(strncmp(node_name,"fidel",5))
                {
                        for(ptr = node_name; *ptr; ptr++)
                        {
                                if(*ptr == '.')
                                {
                                        *ptr = '\0';
                                        break;
                                }
                        }
                }
        }
#endif
        if( !(conn_id = find_connection(node_name, task_name, port)) ) 
        {
          bad_connp = locate_bad(node_name, task_name, port);
          if(bad_connp)
                  retrying = bad_connp->retrying;
          if((!bad_connp) || (retrying))
          {     
                if( (conn_id = dna_open_client(node_info, task_name, port,
                                              protocol, recv_rout, error_handler, SRC_DIC)) )
                {
/*
#ifndef VxWorks
                        if(format & MY_OS9)
                        {
                                dna_set_test_write(conn_id, TEST_TIME_OSK);
                                format &= 0xfffff7ff;
                        }
                        else
                        {
                                dna_set_test_write(conn_id, TEST_TIME_VMS);
                        }
#endif
*/
                        dna_set_test_write(conn_id, dim_get_keepalive_timeout());
                        dic_connp = &Dic_conns[conn_id];
                        strncpy( dic_connp->node_name, node_name,
                                 (size_t)MAX_NODE_NAME); 
                        strncpy( dic_connp->task_name, task_name,
                                 (size_t)MAX_TASK_NAME);
                        dic_connp->port = port;
                        dic_connp->pid = pid;
                        if(Debug_on)
                        {
                                dim_print_date_time();
                                printf("Conn %d, Server %s on node %s Connecting\n",
                                        conn_id, dic_connp->task_name, dic_connp->node_name);
                                fflush(stdout);
                        }

                        dic_connp->service_head = 
                                                malloc(sizeof(DIC_SERVICE));
                        dll_init( (DLL *) dic_connp->service_head);
                        ((DIC_SERVICE *)(dic_connp->service_head))->serv_id = 0;
                        if(retrying)
                        {
                                dll_remove((DLL *)bad_connp->conn.service_head);
                                free(bad_connp->conn.service_head);
                                dll_remove((DLL *)bad_connp);
                                free(bad_connp);
                        }
                } 
                else 
                {
                        if(!retrying)
                        {
                                if( !Bad_connection_head )
                                {
                                        Bad_connection_head = (DIC_BAD_CONNECTION *) malloc(sizeof(DIC_BAD_CONNECTION));
                                        dll_init( (DLL *) Bad_connection_head );
                                        Bad_connection_head->conn.service_head = 0;
                                }
                                bad_connp = (DIC_BAD_CONNECTION *) malloc(sizeof(DIC_BAD_CONNECTION));
                                bad_connp->n_retries = 0;
                                bad_connp->conn.service_head = malloc(sizeof(DIC_SERVICE));
                                dll_init( (DLL *) bad_connp->conn.service_head);

                                dll_insert_queue( (DLL *) Bad_connection_head, (DLL *) bad_connp );
                                if(Debug_on)
                                {
                                        dim_print_date_time();
                                        printf("Failed connecting to Server %s on node %s port %d\n",
                                                task_name, node_name, port);
                                        fflush(stdout);
                                }
                                service_tmout( servp->serv_id );
                        }
                        bad_connp->n_retries++;
                        bad_connp->retrying = 0;
                        strncpy( bad_connp->conn.node_name, node_name, (size_t)MAX_NODE_NAME); 
                        strncpy( bad_connp->conn.task_name, task_name, (size_t)MAX_TASK_NAME);
                        bad_connp->conn.port = port;
                        tmout = BAD_CONN_TIMEOUT * (bad_connp->n_retries - 1);
                        if(tmout > 120)
                                tmout = 120;
/* Can not be 0, the callback of dtq_start_timer(0) is not protected */
                        if(tmout == 0)
                                tmout = 1;
                        dtq_start_timer(tmout, retry_bad_connection, (dim_long)bad_connp);
                        if(( servp->type == COMMAND )||( servp->type == ONCE_ONLY ))
                                return(0);
                        move_to_bad_service(servp, bad_connp);
/*                      
                        ((DIC_SERVICE *)(dic_connp->service_head))->serv_id = 0;

                        servp = Service_pend_head;
                        while( (servp = (DIC_SERVICE *) dll_get_next(
                                                (DLL *) Service_pend_head,
                                                (DLL *) servp)) )
                        {
                                if( (servp->pending == WAITING_DNS_ANSWER) ||
                                        (servp->pending == WAITING_SERVER_UP))
                                                servp->pending = WAITING_DNS_UP;
                        }
                        dna_close( Dns_dic_conn_id );
                        Dns_dic_conn_id = 0;
                        request_dns_info(0);
*/
                        return(0);
                }
          }
          else
          {
                        if(!retrying)
                                service_tmout( servp->serv_id );
                        if(( servp->type == COMMAND )||( servp->type == ONCE_ONLY ))
                                return(0);
                        move_to_bad_service(servp, bad_connp);
                        return(0);
          }
        }
        strcpy(servp->def, packet->service_def);
        get_format_data(format, servp->format_data, servp->def);
        servp->format = format;
        servp->conn_id = conn_id;

        send_service_command( servp );
/*
        if( ret == 1)
        {
                if(servp->pending != WAITING_CMND_ANSWER)
                        servp->pending = NOT_PENDING;
                servp->tmout_done = 0;
        }
*/
        return(1);
}

Here is the call graph for this function:

Here is the caller graph for this function: