## modules/ud/ud_main.c

/* [<][>][^][v][top][bottom][index][help] */

## DEFINITIONS

This source file includes following functions.

1. get_NRTM_fd
2. UD_do_nrtm
3. UD_do_updates

       1 /***************************************
       2   $Revision: 1.41 $
       3
       4   Wrapper for NRTM client
       5
       6   Status: NOT REVUED, NOT TESTED
       7
       8  Author(s):       Andrei Robachevsky
       9
      10   ******************/ /******************
      11   Modification History:
      12         andrei (17/01/2000) Created.
      13   ******************/ /******************
      14   Copyright (c) 2000,2001,2002                      RIPE NCC
      15
      16   All Rights Reserved
      17
      18   Permission to use, copy, modify, and distribute this software and its
      19   documentation for any purpose and without fee is hereby granted,
      20   provided that the above copyright notice appear in all copies and that
      21   both that copyright notice and this permission notice appear in
      22   supporting documentation, and that the name of the author not be
      23   used in advertising or publicity pertaining to distribution of the
      24   software without specific, written prior permission.
      25
      26   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
      27   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
      28   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
      29   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
      30   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
      31   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
      32  ***************************************/
      33
      34 #include "rip.h"
      35
      36 #include <sys/types.h>
      37 #include <sys/socket.h>
      38 #include <netinet/in.h>
      39 #include <arpa/inet.h>
      40 #include <fcntl.h>
      41 #include <signal.h>
      42 #include <sys/poll.h>
      43
      44
      45 /* here we store sockets for update threads */
      46 /* they are from SV module */
      47 extern int SV_update_sock[];
      48
      49 /* here is the shutdown pipe for update threads */
      50 /* also from SV module (apologies for breaking encapsulation) */
      51 extern int SV_shutdown_recv_fd;
      52
      53 /* Response time to swtching updates on and off */
      54 #define TIMEOUT 60
      55
      56 /* timeout between successive attempts to establish connection with server */
      57 #define PM_CONNECTION_TIMEOUT 10
      58
      59 /* Maximum number of objects(serials) we can consume at a time */
      60 #define SBUNCH 1000
      61
      62 /* Timeout in seconds when reading (writing) from DBupdate */
      63 #define STREAM_TIMEOUT 120
      64
      65 /************************************************************
      66 * int get_NRTM_fd()                                         *
      67 *                                                           *
      68 * Gets the NRTM stream                                      *
      69 *                                                           *
      70 * First tries to request the serials from the NRTM server   *
      71 * If the name of the server appears to be not a network name*
      72 * it tries to open the file with this name                  *
      73 *                                                           *
      74 * nrtm - pointer to _nrtm structure                         *
      75 * upto_last - if==1 then requests to download serials using *
      76 * LAST keyword                                              *
      77 *                                                           *
      78 * Returns:                                                  *
      79 * A file descriptor for a data stream                       *
      80 * -1 - error                                                *
      81 *                                                           *
      82 ************************************************************/
      83 int get_NRTM_fd(struct _nrtm *nrtm, int upto_last, char *source)
         /* [<][>][^][v][top][bottom][index][help] */
      84 {
      85 int sockfd;
      86 struct hostent *hptr;
      87 struct sockaddr_in serv_addr;
      88 struct in_addr *paddr;
      89 char host_info[STR_XXL];
      90 GString *line_buff;
      91 int fd;
      92 int ret;
      93 struct hostent result;
      94 int error;
      95 int network;
      96
      97 int so_keepalive =1;
      98
      99 /* fprintf(stderr, "Making connection to NRTM server ...\n");*/
     100  if ((sockfd=socket(AF_INET, SOCK_STREAM, 0))==-1){
     101    ER_perror(FAC_UD, UD_FS, "cannot create socket");
     102    return(-1);
     103  }
     104
     105 /* set keepalive option so we can reconnect in case there was no connectivity */
     106 /* with primary. See bug 100 for details. Default timeout is 2hours           */
     107  if ((error=setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &so_keepalive, sizeof(so_keepalive))) == -1){
     108    ER_perror(FAC_UD, UD_FS, "cannot set KEEPALIVE socket option");
     109    return(-1);
     110  }
     111 #ifdef __linux__
     112  if(gethostbyname_r(nrtm->server,  &result, host_info, sizeof(host_info), &hptr, &error)<0)  hptr=NULL;
     113 #else/* default is Solaris implementation */
     114  hptr=gethostbyname_r(nrtm->server,  &result, host_info, sizeof(host_info), &error);
     115 #endif
     116
     117  /* Check if it is a network stream or a file */
     118  if (hptr) { /* this is a network stream*/
     119    paddr=(struct in_addr *)hptr->h_addr;
     120    bzero(&serv_addr, sizeof(serv_addr));
     121    serv_addr.sin_family=AF_INET;
     122    serv_addr.sin_port=nrtm->port;
     123    memcpy(&serv_addr.sin_addr, paddr, sizeof(struct in_addr));
     124 /*   fprintf(stderr,"Trying %s port %d\n", inet_ntoa(serv_addr.sin_addr), nrtm->port);*/
     125    if(connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr))==-1) {
     126      ER_perror(FAC_UD, UD_FS, "cannot connect, errno:%d", errno);
     127      close(sockfd);
     128      return(-1);
     129    }
     130 /*   fprintf(stderr, "Sending Invitation\n"); */
     131
     132    /* Request all available serials (upto LAST), or SBUNCH of them */
     133    line_buff = g_string_sized_new(STR_L);
     134    if(upto_last==1)
     135       g_string_sprintf(line_buff, "-g %s:%d:%ld-LAST\n", source, nrtm->version, nrtm->current_serial+1);
     136    else if(upto_last==-1) /* persistent mirroring */
     137       g_string_sprintf(line_buff, "-k -g %s:%d:%ld-LAST\n", source, nrtm->version, nrtm->current_serial+1);
     138    else
     139       g_string_sprintf(line_buff, "-g %s:%d:%ld-%ld\n", source, nrtm->version, nrtm->current_serial+1, nrtm->current_serial+SBUNCH);
     140    ret=SK_write(sockfd, line_buff->str, line_buff->len, NULL, NULL );
     141    g_string_free(line_buff, TRUE);
     142    if(ret != 1) {
     143            ER_perror(FAC_UD, UD_FS, "cannot write");
     144            close(sockfd);
     145            return(-1);
     146    }
     147    fd=sockfd;
     148    network=1;
     149 /*   fprintf(stderr, "Returning stream pointer\n"); */
     150  }
     151  else { /* this is a file stream*/
     152    network=0;
     153    close(sockfd);
     154 /*   fprintf(stderr, "Trying file ...\n");*/
     155    if((fd=open(nrtm->server, O_RDONLY, 0666))==-1) {
     156       ER_perror(FAC_UD, UD_FS, "cannot open");
     157       return(-1);
     158    }
     159  }
     160  return(fd);
     161 }
     162
     163
     164
     165 /************************************************************
     166 *  void UD_do_nrtm()                                        *
     167 *                                                           *
     168 * Processes NRTM stream                                     *
     169 *                                                           *
     170 * It cycles requesting objects from the NRTM server,        *
     171 * processing them and then sleeping a specified amount of   *
     172 * time.                                                     *
     173 *                                                           *
     174 * It starts by requesting SBUNCH number of serials and does *
     175 * so untill no serials are received (actually a warning     *
     176 * is received saying that the requested range is invalid)   *
     177 * This approach avoids excessive load on the NRTM server    *
     178 *                                                           *
     179 * After that it requests serials using LAST keyward keeping *
     180 * almost in sync with the server                            *
     181 *                                                           *
     182 ************************************************************/
     183
     184 void UD_do_nrtm(void *arg)
         /* [<][>][^][v][top][bottom][index][help] */
     185 {
     186 int source = (int)arg;
     187 UD_stream_t ud_stream;
     188 struct _nrtm *nrtm;
     189 int nrtm_delay;
     190 int do_update=1;
     191 int do_server;
     192 int nrtm_fd;
     193 int num_ok;
     194 int upto_last;
     195 GString *ta_activity;
     196 ca_dbSource_t *source_hdl = ca_get_SourceHandleByPosition(source);
     197 char *db_host, *db_name, *db_user, *db_passwd;
     198 int db_port;
     199 /* get source we are going to mirror */
     200 char *source_name = ca_get_srcname(source_hdl);
     201
     202   { /* set up the lohgging path */
     203    int res;
     204    char *er_ud_def = ca_get_er_ud_def; /* something like 'RIPUPDLOG basename' */
     205    GString *er_def;
     206    char *erret = NULL;
     207
     208    er_def = g_string_sized_new(256);
     209    g_string_sprintf(er_def, "%s %s", er_ud_def, source_name);
     210    fprintf(stderr, "[%s]\n", er_def->str);
     211    if( (res = ER_macro_spec(er_def->str, &erret)) != 0 ) {
     212         fputs(erret, stderr);
     213         die;
     214         /* or some other error handling */
     215    }
     216    UT_free(erret); /* the response is allocated and must be freed */
     217    g_string_free(er_def, TRUE);
     218    UT_free(er_ud_def);
     219   }
     220
     221   /* load the dictionary */
     222   rpsl_load_dictionary(RPSL_DICT_CORE);
     223
     224   nrtm=UT_calloc(1, sizeof(struct _nrtm));
     225   if(nrtm==NULL) {
     226           ER_perror(FAC_UD, UD_MEM, "cannot allocate memory");
     227           die;
     228   }
     229 /* get mode of operation: protected/unprotected (dummy) */
     230   memset(&ud_stream, 0, sizeof(ud_stream));
     231   ud_stream.source_hdl=source_hdl;
     232   ud_stream.ud_mode=ca_get_srcmode(source_hdl);
     233   nrtm_delay=ca_get_srcnrtmdelay(source_hdl);
     234   /* Zero delay means persistent connection */
     235   if (nrtm_delay==0) ud_stream.ud_mode |= B_PERSIST_MIRR;
     236
     237   fprintf(stderr, "Mode of operation:\n");
     238   if(IS_DUMMY_ALLOWED(ud_stream.ud_mode))fprintf(stderr, "* dummy allowed\n");
     239   else fprintf(stderr, "* dummy not allowed\n");
     240
     241   if(IS_UPDATE(ud_stream.ud_mode))fprintf(stderr, "* DBupdate\n");
     242   else if(IS_NRTM_CLNT(ud_stream.ud_mode)) {
     243
     244            if(IS_PERSIST_MIRR(ud_stream.ud_mode))fprintf(stderr, "* NRTM: persistent conection\n");
     245            else fprintf(stderr, "* NRTM\n");
     246         }
     247         else fprintf(stderr, "* STATIC\n");
     248
     249   if(IS_STANDALONE(ud_stream.ud_mode))fprintf(stderr, "* running standalone\n");
     250    else fprintf(stderr, "* running as a server\n");
     251
     252   if(IS_NO_NHR(ud_stream.ud_mode))fprintf(stderr, "* NHR is not maintained\n");
     253    else fprintf(stderr, "* NHR is maintained\n");
     254
     255
     256 /* get mirror server */
     257   nrtm->server=ca_get_srcnrtmhost(source_hdl);
     258
     259
     260 /* get mirror port */
     261   nrtm->port = htons(ca_get_srcnrtmport(source_hdl));
     262   printf("XXX nrtm_port=%d\n", ntohs(nrtm->port));
     263
     264 /* get mirror version */
     265   nrtm->version=ca_get_srcnrtmprotocolvers(source_hdl);
     266
     267
     268 /* get error log facility */
     269 /*   logfilename=ca_get_srcnrtmlog(source_hdl); */
     270
     271    db_host = ca_get_srcdbmachine(source_hdl);
     272    db_port = ca_get_srcdbport(source_hdl);
     273    db_name = ca_get_srcdbname(source_hdl);
     274    db_user = ca_get_srcdbuser(source_hdl);
     275    db_passwd = ca_get_srcdbpassword(source_hdl);
     276
     277 /* Connect to the database */
     278   ER_dbg_va(FAC_UD, ASP_UD_SQL, "%s making SQL connection to %s@%s ...", UD_TAG, db_name, db_host);
     279   ud_stream.db_connection=SQ_get_connection(db_host, db_port, db_name, db_user, db_passwd);
     280
     281
     282   if(! ud_stream.db_connection) {
     283     ER_perror(FAC_UD, UD_SQL, "no connection to SQL server");
     284     die;
     285   }
     286
     287   ud_stream.num_skip=0;
     288   ud_stream.load_pass=0;
     289   ud_stream.nrtm=nrtm;
     290
     291   if(IS_PERSIST_MIRR(ud_stream.ud_mode))upto_last=-1; /* the faster the better */
     292   else upto_last=0; /* let's start gradually if the backlog is > SBUNCH (1000) serials*/
     293
     294 /*+++ main cycle +++*/
     295
     296  do {
     297   do_update=CO_get_do_update();
     298   if(do_update) {
     299
     300    /* Check connection to the database and try to reconnect */
     301    if(SQ_ping(ud_stream.db_connection)) {
     302     ER_inf_va(FAC_UD, ASP_UD_UPDLOG, "%s connection to SQL server timed out - reistablishing", UD_TAG);
     303    }
     304
     305   /* get current serial */
     306    nrtm->current_serial=PM_get_current_serial(ud_stream.db_connection);
     307
     308    if(nrtm->current_serial == -1) {
     309       ER_perror(FAC_UD, UD_SQL, "cannot obtain current serial: %ld", nrtm->current_serial);
     310      die;
     311    }
     312
     313    ER_inf_va(FAC_UD, ASP_UD_UPDLOG, "%s connecting to NRTM server [%s:%d] (current serial=%ld)",
     314                                     UD_TAG, nrtm->server, ntohs(nrtm->port), nrtm->current_serial);
     315
     316   /* Get file descriptor of the data stream (RPSL format, use mirror reflector to convert if needed)*/
     317     nrtm_fd=get_NRTM_fd(nrtm, upto_last, source_name);
     318     if (nrtm_fd==-1) {
     319      ER_inf_va(FAC_UD, ASP_UD_OBJ, "%s Cannot open data stream. Trying...", UD_TAG);
     320      SV_sleep(PM_CONNECTION_TIMEOUT);
     321      continue;
     322     }
     323
     324
     325     /* make a record for thread accounting */
     326     TA_add(nrtm_fd, "nrtm_clnt");
     327     ta_activity = g_string_sized_new(STR_M);
     328     g_string_sprintf(ta_activity, "[%s]%ld->",
     329                      source_name, nrtm->current_serial);
     330     TA_setactivity(ta_activity->str);
     331
     332
     333    ud_stream.condat.sock = nrtm_fd;
     334    ud_stream.log.num_ok=0;
     335    ud_stream.log.num_failed=0;
     336
     337
     338    ER_dbg_va(FAC_UD, ASP_UD_UPDLOG, "%s starting processing stream", UD_TAG);
     339
     340 /***************** process stream ****************/
     341
     342       num_ok=UD_process_stream(&ud_stream);
     343
     344 /***************** process stream ****************/
     345
     346    ER_dbg_va(FAC_UD, ASP_UD_UPDLOG, "%s processing stream finished", UD_TAG);
     347
     348   /* close the socket of the NRTM stream */
     349    close(ud_stream.condat.sock);
     350
     351
     352
     353    ER_inf_va(FAC_UD, ASP_UD_OBJ, "%s forwarded to serial:%ld", UD_TAG, (nrtm->current_serial+num_ok));
     354
     355    /* set activity for thread record */
     356    g_string_sprintf(ta_activity, "[%s]->%ld",
     357                     source_name, (nrtm->current_serial+num_ok));
     358    TA_setactivity(ta_activity->str);
     359    g_string_free(ta_activity, TRUE);
     360
     361 /* if we are NOT in persistent mode */
     362    if(!IS_PERSIST_MIRR(ud_stream.ud_mode)) {
     363      /* Now we can process serials in normal way (upto LAST)*/
     364      if(num_ok==0) upto_last=1;
     365      /* get delay */
     366      nrtm_delay=ca_get_srcnrtmdelay(source_hdl);
     367    } else
     368      /* we need to delay the next attempt not to have a birst of requests */
     369      nrtm_delay=TIMEOUT;
     370      /* sleep the delay seconds or untill the shutdown requested */
     371      SV_sleep(nrtm_delay);
     372
     373   } /* if do_updates */
     374   else SV_sleep(TIMEOUT);
     375
     376
     377   TA_delete();
     378
     379  } while((do_server=CO_get_do_server()));  /* main cycle */
     380
     381 /*   fclose(ud_stream.log.logfile);*/
     382    UT_free(source_name);
     383 /* free data associated with nrtm structure */
     384  if(nrtm) {
     385    UT_free(nrtm->server);
     386    UT_free(nrtm);
     387  }
     388
     389  /* That's all. Close connection to the DB */
     390  SQ_close_connection(ud_stream.db_connection);
     391  UT_free(db_host);
     392  UT_free(db_name);
     393  UT_free(db_user);
     394  UT_free(db_passwd);
     395
     396  ER_dbg_va(FAC_UD, ASP_UD_UPDLOG, "%s NRTM client stopped", UD_TAG);
     397 } /* UD_do_nrtm() */
     398
     399 /************************************************************
     400 *  void UD_do_updates()                                     *
     401 *                                                           *
     402 * Processes updates                                         *
     403 *                                                           *
     404 * It cycles accepting connections and processing them       *
     405 * (interactive server). This assures that there is only     *
     406 * one write thread per database/source.                     *
     407 *                                                           *
     408 ************************************************************/
     409
     410 void UD_do_updates(void *arg)
         /* [<][>][^][v][top][bottom][index][help] */
     411 {
     412 int source = (int)arg;
     413 int listening_socket = SV_update_sock[source];
     414 int connected_socket;
     415 UD_stream_t ud_stream;
     416 int do_update=1;
     417 int num_ok;
     418 ca_dbSource_t *source_hdl = ca_get_SourceHandleByPosition(source);
     419 char *db_host, *db_name, *db_user, *db_passwd;
     420 int db_port;
     421 ip_addr_t address;
     422 char *source_name;
     423 struct pollfd pfd[2];
     424
     425    source_name = ca_get_srcname(source_hdl);
     426
     427   { /* set up the lohgging path */
     428    /* get source we are going to update */
     429    int res;
     430    char *er_ud_def = ca_get_er_ud_def; /* something like 'RIPUPDLOG basename' */
     431    GString *er_def;
     432    char *erret = NULL;
     433
     434
     435    er_def = g_string_sized_new(256);
     436    g_string_sprintf(er_def, "%s %s", er_ud_def, source_name);
     437    if( (res = ER_macro_spec(er_def->str, &erret)) != 0 ) {
     438         fputs(erret, stderr);
     439         die;
     440         /* or some other error handling */
     441    }
     442    UT_free(erret); /* the response is allocated and must be freed */
     443    g_string_free(er_def, TRUE);
     444    UT_free(er_ud_def);
     445   }
     446
     447   /* load the dictionary */
     448     rpsl_load_dictionary(RPSL_DICT_CORE);
     449
     450
     451 /* get mode of operation: protected/unprotected (dummy) */
     452   memset(&ud_stream, 0, sizeof(ud_stream));
     453   ud_stream.source_hdl=source_hdl;
     454   ud_stream.ud_mode=ca_get_srcmode(source_hdl);
     455
     456   fprintf(stderr, "Mode of operation:\n");
     457   if(IS_DUMMY_ALLOWED(ud_stream.ud_mode))fprintf(stderr, "* dummy allowed\n");
     458    else fprintf(stderr, "* dummy not allowed\n");
     459   if(IS_UPDATE(ud_stream.ud_mode))fprintf(stderr, "* DBupdate\n");
     460    else fprintf(stderr, "* NRTM\n");
     461   if(IS_STANDALONE(ud_stream.ud_mode))fprintf(stderr, "* running standalone\n");
     462    else fprintf(stderr, "* running as a server\n");
     463
     464
     465 /* get the database */
     466   db_host = ca_get_srcdbmachine(source_hdl);
     467   db_port = ca_get_srcdbport(source_hdl);
     468   db_name = ca_get_srcdbname(source_hdl);
     469   db_user = ca_get_srcdbuser(source_hdl);
     470   db_passwd = ca_get_srcdbpassword(source_hdl);
     471
     472 /* Connect to the database */
     473   ER_dbg_va(FAC_UD, ASP_UD_UPDLOG, "%s making SQL connection to %s@%s ...", UD_TAG, db_name, db_host);
     474   ud_stream.db_connection=SQ_get_connection(db_host, db_port, db_name, db_user, db_passwd);
     475
     476   if(! ud_stream.db_connection) {
     477    ER_perror(FAC_UD, UD_SQL, "no connection to SQL server\n");
     478    die;
     479   }
     480
     481
     482   ud_stream.condat.rd_timeout.tv_sec=STREAM_TIMEOUT;
     483   ud_stream.num_skip=0;
     484   ud_stream.load_pass=0;
     485   ud_stream.nrtm=NULL;
     486
     487   /* set up poll structure */
     488   pfd[0].fd = listening_socket;
     489   pfd[0].events = POLLIN;
     490   pfd[1].fd = SV_shutdown_recv_fd;
     491   pfd[1].events = POLLIN;
     492
     493 /*+++ main cycle +++*/
     494
     495 do { /* be alive while do_server is 1. do_server is turned off by SIGINT */
     496
     497    /* make a record for thread accounting */
     498    TA_add(listening_socket, "update");
     499    TA_setactivity("waiting");
     500
     501    /* check for input */
     502    if (poll(pfd, 2, -1) == -1) {
     503         ER_perror(FAC_SV, 1, "UD_do_updates got error %d on poll; %s",
     504                   errno, strerror(errno));
     505         continue;
     506    }
     507
     508    /* shutdown */
     509    if (pfd[1].revents != 0) break;
     510
     511    /* accept connection */
     512    connected_socket = SK_accept_connection(listening_socket);
     513    if(connected_socket==-1) continue;
     514
     515    /* check if the client is authorised to update */
     516    SK_getpeerip(connected_socket, &address);
     517    if(!AA_can_ripupdate(&address, source_name)){
     518    char *hostaddress;
     519    sk_conn_st condat;
     520    char buff[STR_L];
     521
     522     memset( &condat, 0, sizeof(sk_conn_st));
     523     condat.wr_timeout.tv_sec=STREAM_TIMEOUT;
     524     condat.sock = connected_socket;
     525     SK_getpeerip(connected_socket, &(condat.rIP));
     526     memcpy( &(condat.eIP), &(condat.rIP), sizeof(ip_addr_t));
     527     hostaddress = SK_getpeername(connected_socket);
     528     condat.ip = hostaddress;
     529
     530     ER_inf_va(FAC_UD, ASP_UD_UPDLOG, "[%s] --  Not authorized to update the source %s", hostaddress, source_name);
     531     sprintf(buff, "\n%%ERROR:406: not authorized to update the database\n\n\n");
     532     SK_cd_puts(&condat, buff);
     533     SK_cd_close(&(condat));
     534
     535     UT_free(hostaddress);
     536     /* start the next loop */
     537     continue;
     538    }
     539
     540    /* make a record for thread accounting */
     541    TA_delete(); /* Delete 'waiting' record */
     542    TA_add(connected_socket, "update");
     543
     544
     545    ud_stream.condat.sock = connected_socket;
     546    ud_stream.condat.rtc = 0;
     547
     548
     549    ER_dbg_va(FAC_UD, ASP_UD_UPDLOG, "%s Connection accepted...", UD_TAG);
     550
     551    ud_stream.log.num_ok=0;
     552    ud_stream.log.num_failed=0;
     553
     554
     555    while((do_update=CO_get_do_update())!=1) {
     556            TA_setactivity("suspended");
     557            /* if shutdown was requested - break */
     558            if(SV_sleep(3*TIME_SLICE)) break;
     559    }
     560
     561    if(do_update) {
     562      /* Check connection to the database and try to reconnect*/
     563      if(SQ_ping(ud_stream.db_connection)) {
     564        ER_perror(FAC_UD, UD_SQL, "%s", SQ_error(ud_stream.db_connection));
     565        die;
     566      }
     567
     568      ER_dbg_va(FAC_UD, ASP_UD_UPDLOG, "%s starting processing object", UD_TAG);
     569
     570      /***************** process stream ****************/
     571
     572       num_ok=UD_process_stream(&ud_stream);
     573
     574      /***************** process stream ****************/
     575
     576       ER_dbg_va(FAC_UD, ASP_UD_OBJ, "%s processing object finished", UD_TAG);
     577
     578      /* close the socket of the NRTM stream */
     579      close(ud_stream.condat.sock);
     580
     581    }  /* if do_update*/
     582
     583
     584    TA_delete();
     585
     586 } while (CO_get_do_server());  /* main cycle */
     587
     588 /*   fclose(ud_stream.log.logfile); */
     589  /* That's all. Close connection to the DB */
     590  SQ_close_connection(ud_stream.db_connection);
     591  UT_free(db_host);
     592  UT_free(db_name);
     593  UT_free(db_user);
     594  UT_free(db_passwd);
     595  UT_free(source_name);
     596
     597
     598  ER_inf_va(FAC_UD, ASP_UD_UPDLOG, "%s update server stopped", UD_TAG);
     599 } /* UD_do_update() */
     600
     601
     602
     603

/* [<][>][^][v][top][bottom][index][help] */