int execute_service

(

int

req_id

)

Definition at line 1397 of file dis.c.

References serv::address, COMMAND, req_ent::conn_id, exit_ent::conn_id, copy_swap_buffer_out(), Curr_conn_id, Debug_on, req_ent::delay_delete, dim_print_date_time(), dis_get_n_clients(), DIS_HEADER, DIS_STAMPED_HEADER, dna_write_nowait(), req_ent::first_time, req_ent::format, serv::format_data, Memory::free(), serv::id, id_get_ptr(), Last_n_clients, Memory::malloc(), MAX_NAME, serv::name, Net_conns, NET_CONNECTION::node, serv::quality, DIS_STAMPED_PACKET::quality, release_conn(), req_ent::req_id, DIS_STAMPED_PACKET::reserved, req_ent::service_id, DIS_STAMPED_PACKET::service_id, req_ent::service_ptr, size, serv::size, DIS_STAMPED_PACKET::size, sprintf(), SRC_DIS, STAMPED, str, serv::tag, NET_CONNECTION::task, DIS_STAMPED_PACKET::time_stamp, req_ent::to_delete, req_ent::type, serv::type, serv::user_millisecs, serv::user_routine, and serv::user_secs.

Referenced by dis_insert_request(), dis_report_service(), and do_update_service().

{
        int *buffp, size;
        register REQUEST *reqp;
        register SERVICE *servp;
        char str[80], def[MAX_NAME];
        int conn_id, last_conn_id;
        int *pkt_buffer, header_size, aux;
#ifdef WIN32
        struct timeb timebuf;
#else
        struct timeval tv;
        struct timezone *tz;
#endif
        FORMAT_STR format_data_cp[MAX_NAME/4];

        reqp = (REQUEST *)id_get_ptr(req_id, SRC_DIS);
        if(!reqp)
                return(0);
        if(reqp->to_delete)
                return(0);
        reqp->delay_delete++;
        servp = reqp->service_ptr;
        conn_id = reqp->conn_id;

if(Debug_on)
{
dim_print_date_time();
printf("Updating %s for %s@%s (req_id = %d)\n",
           servp->name, 
           Net_conns[conn_id].task, Net_conns[conn_id].node, 
           reqp->req_id);
}

        last_conn_id = Curr_conn_id;
        Curr_conn_id = conn_id;
        if(servp->type == COMMAND)
        {
                sprintf(str,"This is a COMMAND Service");
                buffp = (int *)str;
                size = 26;
                sprintf(def,"c:26");
        }
        else if( servp->user_routine != 0 ) 
        {
                if(reqp->first_time)
                {
                        Last_n_clients = dis_get_n_clients(servp->id);
                }
                (servp->user_routine)( &servp->tag, &buffp, &size,
                                        &reqp->first_time );
                reqp->first_time = 0;
                
        } 
        else 
        {
                buffp = servp->address;
                size = servp->size;
        }
        Curr_conn_id = last_conn_id;
/* send even if no data but not if negative */
        if( size  < 0)
        {
                reqp->delay_delete--;
                return(0);
        }
        if( DIS_STAMPED_HEADER + size > Dis_packet_size ) 
        {
                if( Dis_packet_size )
                        free( Dis_packet );
                Dis_packet = (DIS_STAMPED_PACKET *)malloc((size_t)(DIS_STAMPED_HEADER + size));
                if(!Dis_packet)
                {
                        reqp->delay_delete--;
                        return(0);
                }
                Dis_packet_size = DIS_STAMPED_HEADER + size;
        }
        Dis_packet->service_id = htovl(reqp->service_id);
        if((reqp->type & 0xFF000) == STAMPED)
        {
                pkt_buffer = ((DIS_STAMPED_PACKET *)Dis_packet)->buffer;
                header_size = DIS_STAMPED_HEADER;
                if(!servp->user_secs)
                {
#ifdef WIN32
                        ftime(&timebuf);
                        aux = timebuf.millitm;
                        Dis_packet->time_stamp[0] = htovl(aux);
                        Dis_packet->time_stamp[1] = htovl((int)timebuf.time);
#else
                        tz = 0;
                        gettimeofday(&tv, tz);
                        aux = (int)tv.tv_usec / 1000;
                        Dis_packet->time_stamp[0] = htovl(aux);
                        Dis_packet->time_stamp[1] = htovl((int)tv.tv_sec);
#endif
                }
                else
                {
                        aux = /*0xc0de0000 |*/ servp->user_millisecs;
                        Dis_packet->time_stamp[0] = htovl(aux);
                        Dis_packet->time_stamp[1] = htovl(servp->user_secs);
                }
                Dis_packet->reserved[0] = (int)htovl(0xc0dec0de);
                Dis_packet->quality = htovl(servp->quality);
        }
        else
        {
                pkt_buffer = ((DIS_PACKET *)Dis_packet)->buffer;
                header_size = DIS_HEADER;
        }
        memcpy(format_data_cp, servp->format_data, sizeof(format_data_cp));
        size = copy_swap_buffer_out(reqp->format, format_data_cp, 
                pkt_buffer,
                buffp, size);
        Dis_packet->size = htovl(header_size + size);
        if( !dna_write_nowait(conn_id, Dis_packet, header_size + size) ) 
        {
                if(Net_conns[conn_id].write_timedout)
                {
                        dim_print_date_time();
                        if(reqp->delay_delete > 1)
                        {
                                printf(" Server (Explicitly) Updating Service %s: Couldn't write to Conn %3d : Client %s@%s\n",
                                        servp->name, conn_id,
                                        Net_conns[conn_id].task, Net_conns[conn_id].node);
                        }
                        else
                        {
                                printf(" Server Updating Service %s: Couldn't write to Conn %3d : Client %s@%s\n",
                                        servp->name, conn_id,
                                        Net_conns[conn_id].task, Net_conns[conn_id].node);
                        }
                        fflush(stdout);
                }
                if(reqp->delay_delete > 1)
                {
                        reqp->to_delete = 1;
                }
                else
                {
                        reqp->delay_delete = 0;
                        release_conn(conn_id, 1, 0);
                }
        }
/*
        else
        {
                if((reqp->type & 0xFFF) == MONITORED)
                {
                        if(reqp->timr_ent)
                                dtq_clear_entry(reqp->timr_ent);
                }
        }
*/
        if(reqp->delay_delete > 0)
                reqp->delay_delete--;
        return(1);
}

Here is the call graph for this function:

Here is the caller graph for this function: