redirector.c

   1 /*
   2  * SARG Squid Analysis Report Generator      http://sarg.sourceforge.net
   3  *                                                            1998, 2012
   4  *
   5  * SARG donations:
   6  *      please look at http://sarg.sourceforge.net/donations.php
   7  * Support:
   8  *     http://sourceforge.net/projects/sarg/forums/forum/363374
   9  * ---------------------------------------------------------------------
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  24  *
  25  */
  26
  27 #include "include/conf.h"
  28 #include "include/defs.h"
  29
  30 static char **files_done = NULL;
  31 static int nfiles_done = 0;
  32
  33 //! The number of invalid lines found in the redirector report.
  34 static int RedirectorErrors=0;
  35
  36 static void parse_log(FILE *fp_ou,char *buf)
  37 {
  38         char leks[5], sep[2], res[MAXLEN];
  39         char hour[15];
  40         char source[128], list[128];
  41         char full_url[MAX_URL_LEN];
  42         const char *url;
  43         char user[MAX_USER_LEN];
  44         char ip[45];
  45         long long int lmon, lday, lyear;
  46         int mon, day, year;
  47         int  idata=0;
  48         bool id_is_ip;
  49         struct getwordstruct gwarea;
  50         struct getwordstruct gwarea1;
  51         struct userinfostruct *uinfo;
  52
  53         getword_start(&gwarea,buf);
  54         if(RedirectorLogFormat[0] != '\0') {
  55                 getword_start(&gwarea1,RedirectorLogFormat);
  56                 leks[0]='\0';
  57                 if (getword(leks,sizeof(leks),&gwarea1,'#')<0) {
  58                         debuga(_("Invalid \"redirector_log_format\" option in your sarg.conf (too many characters before first tag)\n"));
  59                         exit(EXIT_FAILURE);
  60                 }
  61                 year=0;
  62                 mon=0;
  63                 day=0;
  64                 hour[0]='\0';
  65                 source[0]='\0';
  66                 list[0]='\0';
  67                 ip[0]='\0';
  68                 user[0]='\0';
  69                 full_url[0]='\0';
  70                 while(strcmp(leks,"end") != 0) {
  71                         if (getword(leks,sizeof(leks),&gwarea1,'#')<0) {
  72                                 debuga(_("Invalid \"redirector_log_format\" option in your sarg.conf (missing # at end of tag)\n"));
  73                                 exit(EXIT_FAILURE);
  74                         }
  75                         if (getword(sep,sizeof(sep),&gwarea1,'#')<0) {
  76                                 debuga(_("Invalid \"redirector_log_format\" option in your sarg.conf (too many characters in column separator)\n"));
  77                                 exit(EXIT_FAILURE);
  78                         }
  79                         if(strcmp(leks,"end") != 0) {
  80                                 if (getword_limit(res,sizeof(res),&gwarea,sep[0])<0) {
  81                                         debuga(_("Parsing of tag \"%s\" in redirector log %s returned no result\n"),leks,wentp);
  82                                         RedirectorErrors++;
  83                                         return;
  84                                 }
  85                                 if(strcmp(leks,"year") == 0) {
  86                                         year=atoi(res);
  87                                 } else if(strcmp(leks,"mon") == 0) {
  88                                         mon=atoi(res);
  89                                 } else if(strcmp(leks,"day") == 0) {
  90                                         day=atoi(res);
  91                                 } else if(strcmp(leks,"hour") == 0) {
  92                                         if (strlen(res)>=sizeof(hour)) {
  93                                                 debuga(_("Hour string too long in redirector log file %s\n"),wentp);
  94                                                 RedirectorErrors++;
  95                                                 return;
  96                                         }
  97                                         strcpy(hour,res);
  98                                 } else if(strcmp(leks,"source") == 0) {
  99                                         if (strlen(res)>=sizeof(source)) {
 100                                                 debuga(_("Banning source name too long in redirector log file %s\n"),wentp);
 101                                                 RedirectorErrors++;
 102                                                 return;
 103                                         }
 104                                         strcpy(source,res);
 105                                 } else if(strcmp(leks,"list") == 0) {
 106                                         if (strlen(res)>=sizeof(list)) {
 107                                                 debuga(_("Banning list name too long in redirector log file %s\n"),wentp);
 108                                                 RedirectorErrors++;
 109                                                 return;
 110                                         }
 111                                         strcpy(list,res);
 112                                 } else if(strcmp(leks,"ip") == 0) {
 113                                         if (strlen(res)>=sizeof(ip)) {
 114                                                 debuga(_("IP address too long in redirector log file %s\n"),wentp);
 115                                                 RedirectorErrors++;
 116                                                 return;
 117                                         }
 118                                         strcpy(ip,res);
 119                                 } else if(strcmp(leks,"user") == 0) {
 120                                         if (strlen(res)>=sizeof(user)) {
 121                                                 debuga(_("User ID too long in redirector log file %s\n"),wentp);
 122                                                 RedirectorErrors++;
 123                                                 return;
 124                                         }
 125                                         strcpy(user,res);
 126                                 } else if(strcmp(leks,"url") == 0) {
 127                                         /*
 128                                          * Don't worry about the url being truncated as we only keep the host name
 129                                          * any way...
 130                                          */
 131                                         safe_strcpy(full_url,res,sizeof(full_url));
 132                                 }
 133                         }
 134                 }
 135         } else {
 136                 if (getword_atoll(&lyear,&gwarea,'-')<0 || getword_atoll(&lmon,&gwarea,'-')<0 ||
 137                                 getword_atoll(&lday,&gwarea,' ')<0) {
 138                         debuga(_("Invalid date found in file %s\n"),wentp);
 139                         RedirectorErrors++;
 140                         return;
 141                 }
 142                 year=(int)lyear;
 143                 mon=(int)lmon;
 144                 day=(int)lday;
 145                 if (getword(hour,sizeof(hour),&gwarea,' ')<0) {
 146                         debuga(_("Invalid time found in file %s\n"),wentp);
 147                         RedirectorErrors++;
 148                         return;
 149                 }
 150                 if (getword_skip(MAXLEN,&gwarea,'(')<0 || getword(source,sizeof(source),&gwarea,'/')<0) {
 151                         debuga(_("Invalid redirected source in file %s\n"),wentp);
 152                         RedirectorErrors++;
 153                         return;
 154                 }
 155                 if (getword(list,sizeof(list),&gwarea,'/')<0) {
 156                         debuga(_("Invalid redirected list in file %s\n"),wentp);
 157                         RedirectorErrors++;
 158                         return;
 159                 }
 160                 if (getword_skip(MAXLEN,&gwarea,' ')<0 || getword_limit(full_url,sizeof(full_url),&gwarea,' ')<0) {
 161                         debuga(_("Invalid URL in file %s\n"),wentp);
 162                         RedirectorErrors++;
 163                         return;
 164                 }
 165                 if (getword(ip,sizeof(ip),&gwarea,'/')<0) {
 166                         debuga(_("Invalid source IP in file %s\n"),wentp);
 167                         RedirectorErrors++;
 168                         return;
 169                 }
 170                 if (getword_skip(MAXLEN,&gwarea,' ')<0 || getword(user,sizeof(user),&gwarea,' ')<0) {
 171                         debuga(_("Invalid user in file %s\n"),wentp);
 172                         RedirectorErrors++;
 173                         return;
 174                 }
 175         }
 176         url=process_url(full_url,false);
 177
 178         //sprintf(warea,"%04d%02d%02d",year,mon,day);
 179
 180         if(RedirectorFilterOutDate) {
 181                 idata = year*10000+mon*100+day;
 182                 if(idata < dfrom || idata > duntil)
 183                         return;
 184         }
 185
 186         if(UserIp) {
 187                 strcpy(user,ip);
 188                 id_is_ip=true;
 189         } else {
 190                 id_is_ip=false;
 191                 if(strcmp(user,"-") == 0 || strcmp(user," ") == 0 || strcmp(user,"") == 0) {
 192                         if(RecordsWithoutUser == RECORDWITHOUTUSER_IP) {
 193                                 strcpy(user,ip);
 194                                 id_is_ip=true;
 195                         }
 196                         if(RecordsWithoutUser == RECORDWITHOUTUSER_IGNORE)
 197                                 return;
 198                         if(RecordsWithoutUser == RECORDWITHOUTUSER_EVERYBODY)
 199                                 strcpy(user,"everybody");
 200                 }
 201         }
 202         uinfo=userinfo_find_from_id(user);
 203         if (!uinfo) {
 204                 uinfo=userinfo_create(user);
 205                 uinfo->id_is_ip=id_is_ip;
 206                 uinfo->no_report=true;
 207                 if(Ip2Name && id_is_ip) ip2name(user,sizeof(user));
 208                 user_find(uinfo->label,MAX_USER_LEN, user);
 209         }
 210         fprintf(fp_ou,"%s\t%04d%02d%02d\t%s\t%s\t%s\t",uinfo->id,year,mon,day,hour,ip,url);
 211         if (source[0] && list[0])
 212                 fprintf(fp_ou,"%s/%s\n",source,list);
 213         else if (source[0])
 214                 fprintf(fp_ou,"%s\n",source);
 215         else
 216                 fprintf(fp_ou,"%s\n",list);
 217         redirector_count++;
 218 }
 219
 220 static void read_log(const char *wentp, FILE *fp_ou,int dfrom,int duntil)
 221 {
 222         FILE *fp_in = NULL;
 223         char *buf;
 224         int  i;
 225         longline line;
 226
 227         if(debug) {
 228                 debuga(_("Reading redirector log file %s\n"),wentp);
 229         }
 230
 231         /* With squidGuard, you can log groups in only one log file.
 232                 We must parse each log files only one time.  Example :
 233                 dest porn {
 234                         domainlist porn/domains
 235                         urllist    porn/urls
 236                         log file1.log
 237                 }
 238                 dest aggressive {
 239                         domainlist aggressive/domains
 240                         urllist    aggressive/urls
 241                         log file2.log
 242                 }
 243                 dest audio-video {
 244                         domainlist audio-video/domains
 245                         urllist    audio-video/urls
 246                         log file1.log
 247                 }
 248         */
 249         for (i=0; i<nfiles_done; i++)
 250                 if (!strcmp(wentp, files_done[i])) return;
 251
 252         nfiles_done++;
 253         files_done = realloc(files_done, nfiles_done*sizeof(char *));
 254         if (!files_done) {
 255                 debuga(_("Not enough memory to store the name of the new redirector log to be read - %s\n"),strerror(errno));
 256                 exit(EXIT_FAILURE);
 257         }
 258         files_done[nfiles_done-1] = strdup(wentp);
 259         if (!files_done[nfiles_done-1]) {
 260                 debuga(_("Not enough memory to store the name of the new redirector log to be read - %s\n"),strerror(errno));
 261                 exit(EXIT_FAILURE);
 262         }
 263
 264         if ((fp_in=fopen(wentp,"r"))==NULL) {
 265                 debuga(_("(squidguard) Cannot open log file %s\n"),wentp);
 266                 exit(EXIT_FAILURE);
 267         }
 268
 269         if ((line=longline_create())==NULL) {
 270                 debuga(_("Not enough memory to read the redirector log\n"));
 271                 exit(EXIT_FAILURE);
 272         }
 273
 274         while ((buf=longline_read(fp_in,line)) != NULL) {
 275                 parse_log(fp_ou,buf);
 276         }
 277         fclose(fp_in);
 278         longline_destroy(&line);
 279         return;
 280 }
 281
 282
 283 void redirector_log(void)
 284 {
 285         FILE *fp_ou = NULL, *fp_guard = NULL;
 286         char buf[MAXLEN];
 287         char guard_in[MAXLEN];
 288         char guard_ou[MAXLEN];
 289         char logdir[MAXLEN];
 290         char user[MAXLEN];
 291         char tmp6[MAXLEN];
 292         int i;
 293         int  y;
 294         int cstatus;
 295         int dfrom, duntil;
 296         char *str;
 297         char *str2;
 298
 299         str2 = user;
 300
 301         if(SquidGuardConf[0] == '\0' && NRedirectorLogs == 0) {
 302                 if (debugz) debugaz(_("No redirector logs provided to produce that kind of report\n"));
 303                 return;
 304         }
 305
 306         snprintf(guard_in,sizeof(guard_in),"%s/redirector.int_unsort",tmp);
 307         snprintf(guard_ou,sizeof(guard_ou),"%s/redirector.int_log",tmp);
 308         if((fp_ou=fopen(guard_in,"a"))==NULL) {
 309                 debuga(_("(squidguard) Cannot open log file %s\n"),guard_in);
 310                 exit(EXIT_FAILURE);
 311         }
 312
 313         dfrom=(period.start.tm_year+1900)*10000+(period.start.tm_mon+1)*100+period.start.tm_mday;
 314         duntil=(period.end.tm_year+1900)*10000+(period.end.tm_mon+1)*100+period.end.tm_mday;
 315
 316         if (NRedirectorLogs>0) {
 317                 for (i=0 ; i<NRedirectorLogs ; i++)
 318                         read_log(RedirectorLogs[i],fp_ou,dfrom,duntil);
 319         } else {
 320                 if(access(SquidGuardConf, R_OK) != 0) {
 321                         debuga(_("Cannot open squidGuard config file: %s\n"),SquidGuardConf);
 322                         exit(EXIT_FAILURE);
 323                 }
 324
 325                 if((fp_guard=fopen(SquidGuardConf,"r"))==NULL) {
 326                         debuga(_("(squidguard) Cannot open log file %s\n"),SquidGuardConf);
 327                         exit(EXIT_FAILURE);
 328                 }
 329
 330                 logdir[0]=0;
 331                 while(fgets(buf,sizeof(buf),fp_guard)!=NULL) {
 332                         fixendofline(buf);
 333                         if((str=get_param_value("logdir",buf))!=NULL) {
 334                                 /*
 335                                 We want to tolerate spaces inside the directory name but we must also
 336                                 remove the trailing spaces left by the editor after the directory name.
 337                                 This should not be a problem as nobody use a file name with trailing spaces.
 338                                 */
 339                                 for (y=strlen(str)-1 ; y>=0 && (unsigned char)str[y]<=' ' ; y--);
 340                                 if (y>=sizeof(logdir)-1) y=sizeof(logdir)-2;
 341                                 logdir[y+1] = '\0';
 342                                 while (y>=0) {
 343                                         logdir[y] = str[y];
 344                                         y--;
 345                                 }
 346                         } else if((str=get_param_value("log",buf))!=NULL) {
 347                                 if((str2=get_param_value("anonymous",str))!=NULL)
 348                                         str=str2;
 349
 350                                 /*
 351                                 If logdir is defined, we prepend it to the log file name, otherwise, we assume
 352                                 the log directive provides an absolute file name to the log file. Therefore,
 353                                 we don't need to add an additionnal / at the beginning of the log file name.
 354                                 */
 355                                 y=(logdir[0]) ? sprintf(wentp,"%s/",logdir) : 0;
 356                                 /*
 357                                 Spaces are allowed in the name of the log file. The file name ends at the first #
 358                                 because it is assumed it is an end of line comment. Any space before the # is then
 359                                 removed. Any control character (i.e. a character with a code lower than 32) ends
 360                                 the file name. That includes the terminating zero.
 361                                 */
 362                                 while((unsigned char)*str>=' ' && *str!='#' && y<sizeof(wentp)-1)
 363                                         wentp[y++]=*str++;
 364                                 if(*str=='#') {
 365                                         str--;
 366                                         while(*str==' ' && y>0) {
 367                                                 str--;
 368                                                 y--;
 369                                         }
 370                                 }
 371                                 wentp[y]=0;
 372                                 read_log(wentp,fp_ou,dfrom,duntil);
 373                         }
 374                 }
 375         }
 376
 377         if (fp_guard) fclose(fp_guard);
 378         if (fp_ou) fclose(fp_ou);
 379
 380         if (files_done) {
 381                 for (y=0; y<nfiles_done; y++)
 382                         if (files_done[y]) free(files_done[y]);
 383                 free(files_done);
 384         }
 385
 386         if(debug) {
 387                 debuga(_("Sorting file: %s\n"),guard_ou);
 388         }
 389
 390         if (snprintf(tmp6,sizeof(tmp6),"sort -t \"\t\" -k 1,1 -k 2,2 -k 4,4 \"%s\" -o \"%s\"",guard_in, guard_ou)>=sizeof(tmp6)) {
 391                 debuga(_("Sort command too long when sorting file \"%s\" to \"%s\"\n"),guard_in,guard_ou);
 392                 exit(EXIT_FAILURE);
 393         }
 394         cstatus=system(tmp6);
 395         if (!WIFEXITED(cstatus) || WEXITSTATUS(cstatus)) {
 396                 debuga(_("sort command return status %d\n"),WEXITSTATUS(cstatus));
 397                 debuga(_("sort command: %s\n"),tmp6);
 398                 exit(EXIT_FAILURE);
 399         }
 400
 401         if (unlink(guard_in)) {
 402                 debuga(_("Cannot delete %s - %s\n"),guard_in,strerror(errno));
 403                 exit(EXIT_FAILURE);
 404         }
 405         return;
 406 }
 407
 408 static void show_ignored_redirector(FILE *fp_ou,int count)
 409 {
 410         char ignored[80];
 411
 412         snprintf(ignored,sizeof(ignored),ngettext("%d more redirector entry not shown here&hellip;","%d more redirector entries not shown here&hellip;",count),count);
 413         fprintf(fp_ou,"<tr><td class=\"data\"></td><td class=\"data\"></td><td class=\"data\"></td><td class=\"data2 more\">%s</td><td class=\"data\"></td></tr>\n",ignored);
 414 }
 415
 416 void redirector_report(void)
 417 {
 418         FILE *fp_in = NULL, *fp_ou = NULL;
 419
 420         char *buf;
 421         char *url;
 422         char squidguard_in[MAXLEN];
 423         char report[MAXLEN];
 424         char ip[45];
 425         char rule[255];
 426         char oip[45];
 427         char user[MAXLEN];
 428         char ouser[MAXLEN];
 429         char data[15];
 430         char hora[15];
 431         char ouser2[255];
 432         char oname[MAXLEN];
 433         bool  z=false;
 434         int  count=0;
 435         long long int data2;
 436         bool new_user;
 437         struct getwordstruct gwarea;
 438         const struct userinfostruct *uinfo;
 439         struct tm t;
 440         longline line;
 441
 442         ouser[0]='\0';
 443         ouser2[0]='\0';
 444
 445         snprintf(squidguard_in,sizeof(squidguard_in),"%s/redirector.int_log",tmp);
 446         if(!redirector_count) {
 447                 unlink(squidguard_in);
 448                 if (debugz) debugaz(_("Redirector report not generated because it is empty\n"));
 449                 return;
 450         }
 451
 452         snprintf(report,sizeof(report),"%s/redirector.html",outdirname);
 453
 454         if((fp_in=fopen(squidguard_in,"r"))==NULL) {
 455                 debuga(_("(squidguard) Cannot open log file %s\n"),squidguard_in);
 456                 exit(EXIT_FAILURE);
 457         }
 458
 459         if((fp_ou=fopen(report,"w"))==NULL) {
 460                 debuga(_("(squidguard) Cannot open log file %s\n"),report);
 461                 exit(EXIT_FAILURE);
 462         }
 463
 464         if ((line=longline_create())==NULL) {
 465                 debuga(_("Not enough memory to read the processed redirector log\n"));
 466                 exit(EXIT_FAILURE);
 467         }
 468
 469         write_html_header(fp_ou,(IndexTree == INDEX_TREE_DATE) ? 3 : 1,_("Redirector report"),HTML_JS_NONE);
 470         fputs("<tr><td class=\"header_c\">",fp_ou);
 471         fprintf(fp_ou,_("Period: %s"),period.html);
 472         fputs("</td></tr>\n",fp_ou);
 473         fprintf(fp_ou,"<tr><th class=\"header_c\">%s</th></tr>\n",_("Redirector report"));
 474         close_html_header(fp_ou);
 475
 476         fputs("<div class=\"report\"><table cellpadding=1 cellspacing=2>\n",fp_ou);
 477         fprintf(fp_ou,"<tr><th class=\"header_l\">%s</th><th class=\"header_l\">%s</th><th class=\"header_l\">%s</th><th class=\"header_l\">%s</th><th class=\"header_l\">%s</th></tr>\n",_("USERID"),_("IP/NAME"),_("DATE/TIME"),_("ACCESSED SITE"),_("RULE"));
 478
 479         while((buf=longline_read(fp_in,line))!=NULL) {
 480                 getword_start(&gwarea,buf);
 481                 if (getword(user,sizeof(user),&gwarea,'\t')<0) {
 482                         debuga(_("Invalid user in file %s\n"),squidguard_in);
 483                         exit(EXIT_FAILURE);
 484                 }
 485                 if (getword_atoll(&data2,&gwarea,'\t')<0) {
 486                         debuga(_("Invalid date in file %s\n"),squidguard_in);
 487                         exit(EXIT_FAILURE);
 488                 }
 489                 if (getword(hora,sizeof(hora),&gwarea,'\t')<0) {
 490                         debuga(_("Invalid time in file %s\n"),squidguard_in);
 491                         exit(EXIT_FAILURE);
 492                 }
 493                 if (getword(ip,sizeof(ip),&gwarea,'\t')<0) {
 494                         debuga(_("Invalid IP address in file %s\n"),squidguard_in);
 495                         exit(EXIT_FAILURE);
 496                 }
 497                 if (getword_ptr(buf,&url,&gwarea,'\t')<0) {
 498                         debuga(_("Invalid URL in file %s\n"),squidguard_in);
 499                         exit(EXIT_FAILURE);
 500                 }
 501                 if (getword(rule,sizeof(rule),&gwarea,'\n')<0) {
 502                         debuga(_("Invalid rule in file %s\n"),squidguard_in);
 503                         exit(EXIT_FAILURE);
 504                 }
 505
 506                 uinfo=userinfo_find_from_id(user);
 507                 if (!uinfo) {
 508                         debuga(_("Unknown user ID %s in file %s\n"),user,squidguard_in);
 509                         exit(EXIT_FAILURE);
 510                 }
 511
 512                 computedate(data2/10000,(data2/100)%10,data2%100,&t);
 513                 strftime(data,sizeof(data),"%x",&t);
 514
 515                 new_user=false;
 516                 if(!z) {
 517                         strcpy(ouser,user);
 518                         strcpy(oip,ip);
 519                         strcpy(oname,ip);
 520                         if (Ip2Name && !uinfo->id_is_ip) ip2name(oname,sizeof(oname));
 521                         z=true;
 522                         new_user=true;
 523                 } else {
 524                         if(strcmp(ouser,user) != 0) {
 525                                 strcpy(ouser,user);
 526                                 new_user=true;
 527                         }
 528                         if(strcmp(oip,ip) != 0) {
 529                                 strcpy(oip,ip);
 530                                 strcpy(oname,ip);
 531                                 if (Ip2Name && !uinfo->id_is_ip) ip2name(oname,sizeof(oname));
 532                                 new_user=true;
 533                         }
 534                 }
 535
 536                 if(SquidGuardReportLimit) {
 537                         if(strcmp(ouser2,uinfo->label) == 0) {
 538                                 count++;
 539                         } else {
 540                                 if(count>SquidGuardReportLimit && SquidGuardReportLimit>0)
 541                                         show_ignored_redirector(fp_ou,count-SquidGuardReportLimit);
 542                                 count=1;
 543                                 strcpy(ouser2,uinfo->label);
 544                         }
 545                         if(count > SquidGuardReportLimit)
 546                                 continue;
 547                 }
 548
 549                 if (new_user)
 550                         fprintf(fp_ou,"<tr><td class=\"data2\">%s</td><td class=\"data2\">%s</td>",uinfo->label,ip);
 551                 else
 552                         fputs("<tr><td class=\"data2\"></td><td class=\"data2\"></td>",fp_ou);
 553                 fprintf(fp_ou,"<td class=\"data2\">%s-%s</td><td class=\"data2\">",data,hora);
 554                 output_html_link(fp_ou,url,100);
 555                 fprintf(fp_ou,"</td><td class=\"data2\">%s</td></tr>\n",rule);
 556         }
 557         fclose(fp_in);
 558         longline_destroy(&line);
 559
 560         if(count>SquidGuardReportLimit && SquidGuardReportLimit>0)
 561                 show_ignored_redirector(fp_ou,count-SquidGuardReportLimit);
 562
 563         fputs("</table>\n",fp_ou);
 564
 565         if (RedirectorErrors>0)
 566         {
 567                 fputs("<div class=\"warn\"><span>",fp_ou);
 568                 fprintf(fp_ou,ngettext("%d error found in the log file. Some entries may be missing.","%d errors found in the log file. Some entries may be missing.",RedirectorErrors),RedirectorErrors);
 569                 fputs("</span></div>\n",fp_ou);
 570         }
 571
 572         fputs("</div>\n",fp_ou);
 573         if (write_html_trailer(fp_ou)<0)
 574                 debuga(_("Write error in file %s\n"),report);
 575         if (fclose(fp_ou)==EOF)
 576                 debuga(_("Failed to close file %s - %s\n"),report,strerror(errno));
 577
 578         if (unlink(squidguard_in)) {
 579                 debuga(_("Cannot delete %s - %s\n"),squidguard_in,strerror(errno));
 580                 exit(EXIT_FAILURE);
 581         }
 582
 583         return;
 584 }