Ignore:
Timestamp:
10/18/17 13:54:41 (7 years ago)
Author:
tbretz
Message:
Updated to v20r20 - This also includes some minor fixes, I requested.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/FACT++/dim/src/dns.c

    r18097 r18920  
    116116                {
    117117                        dim_print_date_time();
    118                         printf(" Disconnect received - conn: %d to %s@%s\n", conn_id,
     118                        printf("Disconnect received - conn: %d to %s@%s\n", conn_id,
    119119                                Net_conns[conn_id].task,Net_conns[conn_id].node );
    120120                }
     
    126126                {
    127127                        dim_print_date_time();
    128                         printf(" Connection request received - conn: %d\n", conn_id);
     128                        printf("Connection request received - conn: %d\n", conn_id);
    129129                }
    130130                /* handle_conn( conn_id ); */
     
    141141                default:
    142142                        dim_print_date_time();
    143                         printf(" conn: %d to %s@%s, Bad packet\n", conn_id,
     143                        printf("conn: %d to %s@%s, Bad packet\n", conn_id,
    144144                                Net_conns[conn_id].task,Net_conns[conn_id].node );
    145145                        printf("packet->size = %d\n", vtohl(packet->size));
     
    155155        default:       
    156156                dim_print_date_time();
    157                 printf( " - DIM panic: recv_rout(): Bad switch, exiting...\n");
     157                printf( "- DIM panic: recv_rout(): Bad switch, exiting...\n");
    158158                abort();
    159159        }
     
    172172        }
    173173*/
     174}
     175
     176void create_service_entry( int conn_id, DIS_DNS_PACKET *packet, int i, int state)
     177{
     178        DNS_SERVICE *servp;
     179        int name_too_long = 0;
     180        char *ptrt;
     181        void service_insert();
     182
     183        if((int)strlen(Dns_conns[conn_id].task_name) == MAX_TASK_NAME-4-1)
     184                name_too_long = 1;
     185        servp = (DNS_SERVICE *)malloc(sizeof(DNS_SERVICE));
     186        if(name_too_long)
     187        {
     188                if(strstr(packet->services[i].service_name,"/CLIENT_LIST"))
     189                {
     190                        strncpy(Dns_conns[conn_id].long_task_name, packet->services[i].service_name,
     191                                (size_t)MAX_NAME);
     192                        ptrt = strstr(Dns_conns[conn_id].long_task_name,"/CLIENT_LIST");
     193                        *ptrt = '\0';
     194                }
     195        }
     196        strncpy( servp->serv_name,
     197                packet->services[i].service_name,
     198                (size_t)MAX_NAME );
     199        strncpy( servp->serv_def,
     200                packet->services[i].service_def,
     201                (size_t)MAX_NAME );
     202        servp->state = state;
     203        servp->conn_id = conn_id;
     204        servp->server_format = vtohl(packet->format);
     205        servp->serv_id = vtohl(packet->services[i].service_id);
     206        dll_insert_queue( (DLL *)
     207                Dns_conns[conn_id].service_head,
     208                (DLL *) servp );
     209        servp->node_head = (RED_NODE *) malloc(sizeof(NODE));
     210        dll_init( (DLL *) servp->node_head );
     211        servp->next = 0;
     212        if(state == 1)
     213        {
     214                service_insert( &(servp->next) );
     215                Dns_conns[conn_id].n_services++;
     216        }
     217}
     218
     219int warn_server(int conn_id)
     220{
     221        DNS_SERVICE *servp;
     222        DNS_DIS_PACKET *dis_packet;
     223        int n_dupl, dupl_conn_id;
     224        char vname[MAX_NAME], dupl_server[MAX_NAME];
     225        int type, size, dupl_id, kill_anyway, ret;
     226        char *ptr;
     227               
     228        ret = 1;
     229        type = DNS_DIS_KILL;
     230        n_dupl = 0;
     231        strcpy(vname, Dns_conns[conn_id].task_name);
     232        strcat(vname, "/VERSION_NUMBER");
     233        dupl_id = 0;
     234        kill_anyway = 0;
     235        dupl_conn_id = Dns_conns[conn_id].already;
     236        servp = (DNS_SERVICE *)Dns_conns[conn_id].service_head;
     237        while( (servp = (DNS_SERVICE *) dll_get_next(
     238                                (DLL *) Dns_conns[conn_id].service_head,
     239                                (DLL *) servp)) )
     240        {
     241                if(servp->state == -2)
     242                {
     243                        if(!dupl_id)
     244                        {
     245                                dupl_id = servp->serv_id;
     246                                sprintf(dupl_server,"%s(%d)@%s:%d",
     247                                        Dns_conns[dupl_conn_id].task_name,
     248                                        Dns_conns[dupl_conn_id].pid,
     249                                        Dns_conns[dupl_conn_id].node_name,
     250                                        Dns_conns[dupl_conn_id].port);
     251                        }
     252                        if(!strcmp(servp->serv_name, vname))
     253                                kill_anyway = 1;
     254                        n_dupl++;
     255                }
     256        }
     257/* allocate Header + space for <server_name>:<pid>@<node_name>:<port_number> + n duplicated + duplicated ids */
     258        dis_packet = (DNS_DIS_PACKET *)malloc(DNS_DIS_HEADER + MAX_NAME*2 + (n_dupl+1)*10);
     259        sprintf(dis_packet->dup_info, "%s %d", dupl_server, n_dupl);
     260        ptr = dis_packet->dup_info + strlen(dis_packet->dup_info);
     261        if(kill_anyway)
     262        {
     263                type |= (0x01 << (int)16) & (int)0xFFFF0000;
     264                dim_print_date_time();
     265printf("Server already declared by conn %d - %s@%s:%d (PID %d), Killing server conn %d - %s@%s:%d (PID %d) \n",
     266                        dupl_conn_id,
     267                        Dns_conns[dupl_conn_id].task_name,
     268                        Dns_conns[dupl_conn_id].node_name,
     269                        Dns_conns[dupl_conn_id].port,
     270                        Dns_conns[dupl_conn_id].pid,
     271                        conn_id,
     272                        Dns_conns[conn_id].task_name,
     273                        Dns_conns[conn_id].node_name,
     274                        Dns_conns[conn_id].port,
     275                        Dns_conns[conn_id].pid);
     276                fflush(stdout);
     277        }
     278        else
     279        {
     280                servp = (DNS_SERVICE *)Dns_conns[conn_id].service_head;
     281                while( (servp = (DNS_SERVICE *) dll_get_next(
     282                                        (DLL *) Dns_conns[conn_id].service_head,
     283                                        (DLL *) servp)) )
     284                {
     285                        if(servp->state == -2)
     286                        {
     287                                dupl_id = servp->serv_id;
     288                                sprintf(ptr," %08X", dupl_id);
     289                                ptr += 9;
     290                        }
     291                }
     292        }
     293        dis_packet->type = htovl(type);
     294        size = DNS_DIS_HEADER + strlen(dis_packet->dup_info);
     295/* Unfortunatelly the size is wrong, this is for backward compatibility on the server side (it tested the size)*/
     296        dis_packet->size = htovl(DNS_DIS_HEADER);
     297/*
     298printf("Sendig packet %s\n", dis_packet->dup_info);
     299*/
     300        if( !dna_write_nowait(conn_id, dis_packet, size) )
     301        {
     302                dim_print_date_time();
     303                printf("Kill Server: Couldn't write, releasing %d\n",conn_id);
     304                fflush(stdout);
     305                ret = 0;
     306        }
     307        free(dis_packet);
     308        return ret;
    174309}
    175310
     
    180315        int i, service_id;
    181316        int n_services;
    182         char *ptr, *ptr1, *ptrt;
     317        char *ptr, *ptr1;
    183318        int found;
    184319        void do_update_did();
     
    195330#endif
    196331        int update_did = 0;
     332/*
    197333        int name_too_long = 0;
     334*/
    198335        int rem_only = 0;
     336        int all_services_registered = -1;
    199337
    200338        Dns_conns[conn_id].validity = (int)time(NULL);
    201339        if( !Dns_conns[conn_id].service_head )
    202340        {
    203 
     341                all_services_registered = 0;
    204342                if(vtohl(packet->n_services) > 0)
    205343                {
     
    212350        {
    213351                        dim_print_date_time();
    214                         printf( " !!!! New Conn %3d : Server %s@%s (PID %d) registering %d services, to delete %d\n",
     352                        printf( "!!!! New Conn %3d : Server %s@%s (PID %d) registering %d services, to delete %d\n",
    215353                                conn_id, packet->task_name,
    216354                                packet->node_name,
     
    246384        {
    247385                        dim_print_date_time();
    248                         printf( " !!!! New Conn %3d : Server %s@%s (PID %d) registered %d services\n",
     386                        printf( "!!!! New Conn %3d : Server %s@%s (PID %d) registered %d services\n",
    249387                                conn_id, Dns_conns[conn_id].task_name,
    250388                                Dns_conns[conn_id].node_name,
     
    293431                                {
    294432                                        dim_print_date_time();
    295                                         printf(" Stop Server: Couldn't write, releasing %d\n",conn_id);
     433                                        printf("Stop Server: Couldn't write, releasing %d\n",conn_id);
    296434                                        fflush(stdout);
    297435                                }
    298436                                dim_print_date_time();
    299                                 printf(" Connection from %s refused, stopping server %s\n",
     437                                printf("Connection from %s refused, stopping server %s\n",
    300438                                                Dns_conns[conn_id].node_name,
    301439                                                Dns_conns[conn_id].task_name);
     
    332470                                dna_set_test_write(conn_id, dim_get_keepalive_timeout());
    333471                        dim_print_date_time();
    334                         printf( " Server %s out of error\n",
     472                        printf( "Server %s out of error\n",
    335473                                Dns_conns[conn_id].task_name );
    336474                        fflush(stdout);
     
    339477        }
    340478        n_services = vtohl(packet->n_services);
     479/*
    341480        if((int)strlen(Dns_conns[conn_id].task_name) == MAX_TASK_NAME-4-1)
    342481                name_too_long = 1;
     482*/
    343483        for( i = 0; i < n_services; i++ )
    344484        {
     
    347487        {
    348488                        dim_print_date_time();
    349                         printf( " Conn %3d : Server %s@%s (PID %d) registered %s\n",
     489                        printf( "Conn %3d : Server %s@%s (PID %d) registered %s\n",
    350490                                conn_id, Dns_conns[conn_id].task_name,
    351491                                Dns_conns[conn_id].node_name,
     
    359499                        if(!strcmp(packet->services[i].service_name, "DUMMY_UPDATE_PACKET"))
    360500                        {
     501                                all_services_registered = 1;
    361502                                do_inform_clients(conn_id);
    362503                                break;
     
    378519                                        {
    379520                                                dim_print_date_time();
    380                                                 printf(" Couldn't write, releasing %d\n",servp->conn_id);
     521                                                printf("Couldn't write, releasing %d\n",servp->conn_id);
    381522                                                fflush(stdout);
    382523                                        }
    383524                                        dim_print_date_time();
    384                                         printf(" Service %s already declared, killing server %s\n",
     525                                        printf("Service %s already declared, killing server %s\n",
    385526                                                servp->serv_name, Dns_conns[servp->conn_id].task_name);
    386527                                        fflush(stdout);
     
    395536                                        {
    396537                                                dim_print_date_time();
    397 printf(" Service %s already declared by conn %d - %s@%s:%d (PID %d), Redeclared by conn %d - %s@%s:%d (PID %d)(same server) - Closing both conns %d %d\n",
     538printf("Service %s already declared by conn %d - %s@%s:%d (PID %d), Redeclared by conn %d - %s@%s:%d (PID %d)(same server) - Closing both conns %d %d\n",
    398539                                                        servp->serv_name, servp->conn_id,
    399540                                                        Dns_conns[servp->conn_id].task_name,
     
    418559                                        else
    419560                                        {
    420                                                 Dns_conns[conn_id].already = 1;
    421 
     561                                                Dns_conns[conn_id].already = servp->conn_id;
     562                                                create_service_entry( conn_id, packet, i, -2);                 
     563/*DUPL
    422564                                                if( !dna_write_nowait(conn_id, &dis_packet, DNS_DIS_HEADER) )
    423565                                                {
     
    426568                                                        fflush(stdout);
    427569                                                }
     570*/
    428571                                                dim_print_date_time();
    429 printf(" Service %s already declared by conn %d - %s@%s:%d (PID %d), killing server conn %d - %s@%s:%d (PID %d) \n",
     572printf("Service %s already declared by conn %d - %s@%s:%d (PID %d), Warning server conn %d - %s@%s:%d (PID %d) \n",
    430573                                                        servp->serv_name, servp->conn_id,
    431574                                                        Dns_conns[servp->conn_id].task_name,
     
    439582                                                        Dns_conns[conn_id].pid);
    440583                                                fflush(stdout);
    441 
     584/*DUPL
    442585                                                release_conn(conn_id);
    443 
    444586                                                return(0);
     587*/
     588                                                if((!all_services_registered) && (n_services < MAX_REGISTRATION_UNIT))
     589                                                        all_services_registered = 1;
    445590                                        }
    446591#ifdef VMS
     
    481626                                                dll_remove((DLL *) servp);
    482627                                                service_remove(&(servp->next));
    483                                                 Curr_n_services--;
    484628                                                free(servp);
    485629                                                Dns_conns[conn_id].n_services--;
     
    489633                                                        {
    490634                                                                dim_print_date_time();
    491                                                                 printf( " Conn %3d : Server %s@%s unregistered All services, releasing it.\n",
     635                                                                printf("Conn %3d : Server %s@%s unregistered All services, releasing it.\n",
    492636                                                                        conn_id, Dns_conns[conn_id].task_name,
    493637                                                                        Dns_conns[conn_id].node_name );
     
    521665                if(!(servp = service_exists(packet->services[i].service_name)))
    522666                {
    523                         servp = (DNS_SERVICE *)malloc(sizeof(DNS_SERVICE));
    524                         if(name_too_long)
    525                         {
    526                                 if(strstr(packet->services[i].service_name,"/CLIENT_LIST"))
    527                                 {
    528                                         strncpy(Dns_conns[conn_id].long_task_name, packet->services[i].service_name,
    529                                                 (size_t)MAX_NAME);
    530                                         ptrt = strstr(Dns_conns[conn_id].long_task_name,"/CLIENT_LIST");
    531                                         *ptrt = '\0';
    532                                 }
    533                         }
    534                         strncpy( servp->serv_name,
    535                                 packet->services[i].service_name,
    536                                 (size_t)MAX_NAME );
    537                         strncpy( servp->serv_def,
    538                                 packet->services[i].service_def,
    539                                 (size_t)MAX_NAME );
    540                         servp->state = 1;
    541                         servp->conn_id = conn_id;
    542                         servp->server_format = vtohl(packet->format);
    543                         servp->serv_id = vtohl(packet->services[i].service_id);
    544                         dll_insert_queue( (DLL *)
    545                                           Dns_conns[conn_id].service_head,
    546                                           (DLL *) servp );
    547                         Dns_conns[conn_id].n_services++;
    548                         service_insert( &(servp->next) );
    549                         servp->node_head = (RED_NODE *) malloc(sizeof(NODE));
    550                         dll_init( (DLL *) servp->node_head );
    551                         Curr_n_services++;
     667                        create_service_entry( conn_id, packet, i, 1);                   
    552668                }
     669        }
     670        if((vtohl(packet->n_services) != 0) && Dns_conns[conn_id].already && all_services_registered)
     671        {
     672/*
     673                dim_print_date_time();
     674printf("Services already declared Warning server\n");
     675*/
     676                warn_server(conn_id);
    553677        }
    554678        if(update_did)
     
    559683                {
    560684                        dim_print_date_time();
    561                         printf( " Conn %3d : Server %s@%s (PID %d) registered %d services\n",
     685                        printf("Conn %3d : Server %s@%s (PID %d) registered %d services\n",
    562686                                conn_id, Dns_conns[conn_id].task_name,
    563687                                Dns_conns[conn_id].node_name,
     
    620744                {
    621745                        dim_print_date_time();
    622                         printf(" Server %s (%s@%s) has been set in error\n",
     746                        printf("Server %s (%s@%s) has been set in error\n",
    623747                                Dns_conns[conn_id].task_name, Net_conns[conn_id].task, Net_conns[conn_id].node);
    624748                        fflush(stdout);
     
    639763                {
    640764                        dim_print_date_time();
    641                         printf(" Conn %3d : Server %s@%s Registration Requested\n",
     765                        printf("Conn %3d : Server %s@%s Registration Requested\n",
    642766                                conn_id, Net_conns[conn_id].task, Net_conns[conn_id].node);
    643767                        fflush(stdout);
     
    647771                {
    648772                        dim_print_date_time();
    649                         printf(" Server Validity: Couldn't write, releasing Conn %3d : Server %s@%s\n",conn_id,
     773                        printf("Server Validity: Couldn't write, releasing Conn %3d : Server %s@%s\n",conn_id,
    650774                                Net_conns[conn_id].task, Net_conns[conn_id].node);
    651775                        fflush(stdout);
     
    676800        {
    677801                dim_print_date_time();
    678                 printf(" Conn %3d : Client %s@%s requested %s\n",
     802                printf("Conn %3d : Client %s@%s requested %s\n",
    679803                        conn_id, Net_conns[conn_id].task, Net_conns[conn_id].node,
    680804                        serv_regp->service_name);
     
    720844                        dic_packet.size = htovl(DNS_DIC_HEADER);
    721845                        dim_print_date_time();
    722                         printf(" Connection from %s refused, stopping client pid=%s\n",
     846                        printf("Connection from %s refused, stopping client pid=%s\n",
    723847                                        Net_conns[conn_id].node,
    724848                                        Net_conns[conn_id].task);
     
    727851                        {
    728852                                dim_print_date_time();
    729                                 printf(" Stop Client: Couldn't write, releasing Conn %3d : Client %s@%s\n",conn_id,
     853                                printf("Stop Client: Couldn't write, releasing Conn %3d : Client %s@%s\n",conn_id,
    730854                                        Net_conns[conn_id].task,
    731855                                        Net_conns[conn_id].node);
     
    773897                                }
    774898                                service_remove(&(servp->next));
    775                                 Curr_n_services--;
    776899                                free(servp);
    777900                        }
     
    815938                                }
    816939                                service_remove(&(servp->next));
    817                                 Curr_n_services--;
    818940                                free(servp);
    819941                        }
     
    850972                servp->conn_id = 0;
    851973                service_insert(&(servp->next));
    852                 Curr_n_services++;
    853974                servp->node_head = (RED_NODE *)malloc(sizeof(NODE));
    854975                dll_init( (DLL *) servp->node_head );
     
    9301051        {
    9311052                dim_print_date_time();
    932                 printf(" Client Request: Couldn't write, releasing Conn %3d : Client %s@%s\n",conn_id,
     1053                printf("Client Request: Couldn't write, releasing Conn %3d : Client %s@%s\n",conn_id,
    9331054                                        Net_conns[conn_id].task,
    9341055                                        Net_conns[conn_id].node);
     
    9621083                                (DLL *) servp)) )
    9631084        {
     1085/* DUPL
    9641086                if( servp->state != -1 )
     1087*/
     1088                if( servp->state > -1 )
    9651089                {
    9661090                        if( !dll_empty((DLL *) servp->node_head))
     
    10141138                {
    10151139                        dim_print_date_time();
    1016                         printf(" Inform Client: Couldn't write, releasing Conn %3d : Client %s@%s\n",nodep->conn_id,
     1140                        printf("Inform Client: Couldn't write, releasing Conn %3d : Client %s@%s\n",nodep->conn_id,
    10171141                                        Net_conns[nodep->conn_id].task,
    10181142                                        Net_conns[nodep->conn_id].node);
     
    10631187                                        {
    10641188                                                dim_print_date_time();
    1065                                                 printf(" Releasing client on conn %d - %s@%s\n",
     1189                                                printf("Releasing client on conn %d - %s@%s\n",
    10661190                                                        i, Net_conns[i].task, Net_conns[i].node);
    10671191                                                fflush(stdout);
     
    10881212                {
    10891213                        dim_print_date_time();
    1090                         printf( " Conn %3d : Server %s@%s died\n",
     1214                        printf("Conn %3d : Server %s@%s died\n",
    10911215                                conn_id, Dns_conns[conn_id].task_name,
    10921216                                Dns_conns[conn_id].node_name);
     
    10981222                        {
    10991223                                dim_print_date_time();
    1100                                 printf( " Conn %3d : Server %s@%s died\n",
     1224                                printf("Conn %3d : Server %s@%s died\n",
    11011225                                        conn_id, Dns_conns[conn_id].task_name,
    11021226                                        Dns_conns[conn_id].node_name);
     
    11191243                        {
    11201244                                service_remove(&(servp->next));
    1121                                 Curr_n_services--;
    11221245                                old_servp = servp;
    11231246                                servp = servp->server_prev;
     
    11521275                {
    11531276                        dim_print_date_time();
    1154                         printf(" Conn %3d : Client %s@%s died\n",
     1277                        printf("Conn %3d : Client %s@%s died\n",
    11551278                                conn_id, Net_conns[conn_id].task, Net_conns[conn_id].node);
    11561279                        fflush(stdout);
     
    11721295                                {
    11731296                                        service_remove(&(servp->next));
    1174                                         Curr_n_services--;
    11751297                                        free( servp );
    11761298                                }
     
    11871309                {
    11881310                        dim_print_date_time();
    1189                         printf(" Conn %3d : Undefined Type %s@%s died\n",
     1311                        printf("Conn %3d : Undefined Type %s@%s died\n",
    11901312                                conn_id, Net_conns[conn_id].task,
    11911313                                Net_conns[conn_id].node);
     
    12811403                                                    (DLL *) servp)) )
    12821404        {
     1405                if(servp->state == -2)
     1406                        continue;
    12831407                strncpy(dns_service_info->name, servp->serv_name, (size_t)MAX_NAME);
    12841408                dns_service_info->status = htovl(1);
     
    14481572        get_node_name(node);
    14491573        dim_print_date_time();
    1450         printf(" DNS version %d starting up on %s\n",DIM_VERSION_NUMBER, node);
     1574        printf("DNS version %d starting up on %s\n",DIM_VERSION_NUMBER, node);
    14511575        fflush(stdout);
    14521576
     
    15061630
    15071631        dim_print_date_time();
    1508         printf(" Connection Statistics :\n");
     1632        printf("Connection Statistics :\n");
    15091633        for(i = 0; i< Curr_N_Conns; i++)
    15101634        {
     
    15951719                                type |= (soft_code << (int)16) & (int)0xFFFF0000;
    15961720                                dim_print_date_time();
    1597                                 printf(" Killing server %s@%s with exit code %d\n",
     1721                                printf("Killing server %s@%s with exit code %d\n",
    15981722                                        Dns_conns[i].task_name, Dns_conns[i].node_name, soft_code);
    15991723                        }
     
    16011725                        {
    16021726                                dim_print_date_time();
    1603                                 printf(" Killing server %s@%s\n",
     1727                                printf("Killing server %s@%s\n",
    16041728                                        Dns_conns[i].task_name, Dns_conns[i].node_name);
    16051729                        }
     
    16091733                        {
    16101734                                dim_print_date_time();
    1611                                 printf(" Kill Server: Couldn't write, releasing %d\n",i);
     1735                                printf("Kill Server: Couldn't write, releasing %d\n",i);
    16121736                                fflush(stdout);
    16131737                                release_conn(i);
     
    16361760        dll_insert_queue((DLL *) Service_hash_table[index],
    16371761                         (DLL *) servp);
     1762        Curr_n_services++;
    16381763}
    16391764
     
    16421767{
    16431768        if( servp->node_head )
     1769        {
    16441770                free( servp->node_head );
    1645         dll_remove( (DLL *) servp );
     1771        }
     1772        if(servp->next)
     1773        {
     1774                dll_remove( (DLL *) servp );
     1775                Curr_n_services--;
     1776        }
    16461777}
    16471778
     
    18341965                dim_print_date_time();
    18351966                conn_id = dis_get_conn_id();
    1836                 printf(" Got Browse Request <%s> from conn: %d %s@%s\n", buffer, conn_id,
     1967                printf("Got Browse Request <%s> from conn: %d %s@%s\n", buffer, conn_id,
    18371968                        Net_conns[conn_id].task,Net_conns[conn_id].node);
    18381969        }
     
    18421973                dim_print_date_time();
    18431974                conn_id = dis_get_conn_id();
    1844                 printf(" Browse Request <%s> found %d services\n", buffer, n);
     1975                printf("Browse Request <%s> found %d services\n", buffer, n);
    18451976        }
    18461977        if(!Rpc_info_size)
Note: See TracChangeset for help on using the changeset viewer.