void register_services	(	DIS_DNS_CONN *	dnsp,
		int	flag,
		int	dns_flag
	)

Definition at line 812 of file dis.c.

References ALL, COMMAND, Debug_on, serv::def, dim_print_date_time(), DIS_DNS_HEADER, dis_dns_ent::dis_dns_packet, dis_hash_service_get_next(), dis_hash_service_registered(), dna_write(), dis_dns_ent::dns_dis_conn_id, serv::dnsp, DIS_DNS_PACKET::format, get_node_addr(), get_node_name(), serv::id, MAX_REGISTRATION_UNIT, MAX_SERVICE_UNIT, MAX_TASK_NAME, MORE, DIS_DNS_PACKET::n_services, serv::name, DIS_DNS_PACKET::node_addr, DIS_DNS_PACKET::node_name, NONE, DIS_DNS_PACKET::pid, DIS_DNS_PACKET::port, Port_number, Protocol, DIS_DNS_PACKET::protocol, serv::registered, release_conn(), send_dns_update_packet(), SERVICE_REG::service_def, SERVICE_REG::service_id, SERVICE_REG::service_name, DIS_DNS_PACKET::services, DIS_DNS_PACKET::size, SRC_DIS, DIS_DNS_PACKET::src_type, dis_dns_ent::task_name, DIS_DNS_PACKET::task_name, and serv::type.

Referenced by dis_start_serving_dns(), do_register_services(), and recv_dns_dis_rout().

{
        register DIS_DNS_PACKET *dis_dns_p = &(dnsp->dis_dns_packet);
        register int n_services, tot_n_services;
        register SERVICE *servp;
        register SERVICE_REG *serv_regp;
        int hash_index, new_entries;
        extern int get_node_addr();
        int dis_hash_service_registered();

        if(!dis_dns_p->src_type)
        {
                get_node_name( dis_dns_p->node_name );
/*
                strcpy( dis_dns_p->task_name, Task_name );
*/
                strncpy( dis_dns_p->task_name, dnsp->task_name,
                        (size_t)(MAX_TASK_NAME-4) );
                dis_dns_p->task_name[MAX_TASK_NAME-4-1] = '\0';
                get_node_addr( dis_dns_p->node_addr );
/*
                dis_dns_p->port = htovl(Port_number);
*/
                dis_dns_p->pid = htovl(getpid());
                dis_dns_p->protocol = htovl(Protocol);
                dis_dns_p->src_type = htovl(SRC_DIS);
                dis_dns_p->format = htovl(MY_FORMAT);
if(Debug_on)
{
dim_print_date_time();
 printf("Registering as %d %s@%s\n",
        dis_dns_p->pid, dis_dns_p->task_name, dis_dns_p->node_name);
}
        
        }

        dis_dns_p->port = htovl(Port_number);
        serv_regp = dis_dns_p->services;
        n_services = 0;
        tot_n_services = 0;
        if( flag == NONE ) {
                dis_dns_p->n_services = htovl(n_services);
                dis_dns_p->size = htovl( DIS_DNS_HEADER + 
                        (n_services*(int)sizeof(SERVICE_REG)));
                if(dnsp->dns_dis_conn_id > 0)
                {
if(Debug_on)
{
dim_print_date_time();
 printf("Sending NONE to dns %d as %s@%s, %d services\n",
        dnsp->dns_dis_conn_id,
        (&(dnsp->dis_dns_packet))->task_name, (&(dnsp->dis_dns_packet))->node_name, n_services);
}
                        if(!dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet), 
                                DIS_DNS_HEADER + n_services*(int)sizeof(SERVICE_REG)))
                        {
                                release_conn(dnsp->dns_dis_conn_id, 0, 1);
                        }
                }
                return;
        }
        if(flag == ALL)
        {
                servp = 0;
                hash_index = -1;
                while( (servp = dis_hash_service_get_next(&hash_index, servp, 0)))
                {
                        if(servp->dnsp == dnsp)
                                servp->registered  = 0;
                }
        }
        servp = 0;
        hash_index = -1;
        new_entries = 0;
        if(flag == MORE)
                new_entries = 1;
        while( (servp = dis_hash_service_get_next(&hash_index, servp, new_entries)))
        {
                if( flag == MORE ) 
                {
                        if( servp->registered )
                        {
                                continue;
                        }
                }

                if(servp->dnsp != dnsp)
                        continue;

if(Debug_on)
{
dim_print_date_time();
 printf("Registering %s\n",
        servp->name);
}
                strcpy( serv_regp->service_name, servp->name );
                strcpy( serv_regp->service_def, servp->def );
                if(servp->type == COMMAND)
                        serv_regp->service_id = htovl( servp->id | 0x10000000);
                else
                        serv_regp->service_id = htovl( servp->id );

                serv_regp++;
                n_services++;
                dis_hash_service_registered(hash_index, servp);
                if( n_services == MAX_SERVICE_UNIT )
                {
                        dis_dns_p->n_services = htovl(n_services);
                        dis_dns_p->size = (int)htovl(DIS_DNS_HEADER +
                                n_services * (int)sizeof(SERVICE_REG));
                        if(dnsp->dns_dis_conn_id > 0)
                        {
if(Debug_on)
{
dim_print_date_time();
 printf("Sending MAX_SERVICE_UNIT to dns %d as %s@%s, %d services\n",
        dnsp->dns_dis_conn_id,
        (&(dnsp->dis_dns_packet))->task_name, (&(dnsp->dis_dns_packet))->node_name, n_services);
}
                                if( !dna_write(dnsp->dns_dis_conn_id,
                                           &(dnsp->dis_dns_packet), 
                                           DIS_DNS_HEADER + n_services *
                                                (int)sizeof(SERVICE_REG)) )
                                {
                                        release_conn(dnsp->dns_dis_conn_id, 0, 1);
                                }
                        }
                        serv_regp = dis_dns_p->services;
                        tot_n_services += MAX_SERVICE_UNIT;
                        n_services = 0;
                        continue;
                }
        }
        if( n_services ) 
        {
                dis_dns_p->n_services = htovl(n_services);
                dis_dns_p->size = htovl(DIS_DNS_HEADER +
                                        n_services * (int)sizeof(SERVICE_REG));
                if(dnsp->dns_dis_conn_id > 0)
                {
if(Debug_on)
{
dim_print_date_time();
 printf("Sending to dns %d as %s@%s, %d services\n",
        dnsp->dns_dis_conn_id,
        (&(dnsp->dis_dns_packet))->task_name, (&(dnsp->dis_dns_packet))->node_name, n_services);
}
                        if( !dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet),
                                DIS_DNS_HEADER + n_services * (int)sizeof(SERVICE_REG)))
                        {
                                release_conn(dnsp->dns_dis_conn_id, 0, 1);
                        }

                }
                tot_n_services += n_services;
        }
        if(!dns_flag)
        {
                if(tot_n_services >= MAX_REGISTRATION_UNIT)
                {
                        send_dns_update_packet(dnsp);
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function: