util.c

   1 /*
   2  * SARG Squid Analysis Report Generator      http://sarg.sourceforge.net
   3  *                                                            1998, 2010
   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 // #define LEGACY_MY_ATOLL
  28 // #define LEGACY_TESTVALIDUSERCHAR
  29
  30 #include "include/conf.h"
  31 #include "include/defs.h"
  32
  33 #if defined(HAVE_BACKTRACE)
  34 #define USE_GETWORD_BACKTRACE 1
  35 #else
  36 #define USE_GETWORD_BACKTRACE 0
  37 #endif
  38
  39 static char mtab1[12][4]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
  40
  41 //! The list of the HTTP codes to exclude from the report.
  42 static char *excludecode=NULL;
  43
  44 #if USE_GETWORD_BACKTRACE
  45 static void getword_backtrace(void)
  46 {
  47         void *buffer[5];
  48         int i, n;
  49         char **calls;
  50
  51         n=backtrace(buffer,sizeof(buffer)/sizeof(buffer[0]));
  52         if (n<=0) return;
  53         calls=backtrace_symbols(buffer,n);
  54         if (calls) {
  55                 debuga(_("getword backtrace:\n"));
  56                 for (i=0 ; i<n ; i++) {
  57                         fprintf(stderr,"SARG: %d:%s\n",i+1,calls[i]);
  58                 }
  59                 free(calls);
  60         }
  61 }
  62 #endif //USE_GETWORD_BACKTRACE
  63
  64 void getword_start(struct getwordstruct *gwarea, const char *line)
  65 {
  66         gwarea->beginning=line;
  67         gwarea->current=line;
  68         gwarea->modified=0;
  69 }
  70
  71 void getword_restart(struct getwordstruct *gwarea)
  72 {
  73         if (gwarea->modified) {
  74                 debuga(_("Cannot parse again the line as it was modified\n"));
  75                 exit(EXIT_FAILURE);
  76         }
  77         gwarea->current=gwarea->beginning;
  78 }
  79
  80 int getword(char *word, int limit, struct getwordstruct *gwarea, char stop)
  81 {
  82         int x;
  83
  84         for(x=0;((gwarea->current[x]) && (gwarea->current[x] != stop ));x++) {
  85                 if(x>=limit) {
  86                         printf("SARG: getword loop detected after %d bytes.\n",x);
  87                         printf("SARG: Line=\"%s\"\n",gwarea->beginning);
  88                         printf("SARG: Record=\"%s\"\n",gwarea->current);
  89                         printf("SARG: searching for \'x%x\'\n",stop);
  90                         //printf("SARG: Maybe you have a broken record or garbage in your access.log file.\n");
  91                         word[(limit>0) ? limit-1 : 0]='\0';
  92 #if USE_GETWORD_BACKTRACE
  93                         getword_backtrace();
  94 #endif
  95                         return(-1);
  96                 }
  97                 word[x] = gwarea->current[x];
  98         }
  99
 100         word[x] = '\0';
 101         if (gwarea->current[x]) ++x;
 102         gwarea->current+=x;
 103         return(0);
 104 }
 105
 106 int getword_limit(char *word, int limit, struct getwordstruct *gwarea, char stop)
 107 {
 108         int x;
 109
 110         limit--;
 111         for(x=0; x<limit && gwarea->current[x] && gwarea->current[x] != stop ;x++) {
 112                 word[x] = gwarea->current[x];
 113         }
 114         word[x] = '\0';
 115         gwarea->current+=x;
 116         while (*gwarea->current && *gwarea->current != stop)  gwarea->current++;
 117         if (*gwarea->current) ++gwarea->current;
 118         return(0);
 119 }
 120
 121 int getword_multisep(char *word, int limit, struct getwordstruct *gwarea, char stop)
 122 {
 123         int x;
 124
 125         for(x=0;((gwarea->current[x]) && (gwarea->current[x] != stop ));x++) {
 126                 if(x>=limit) {
 127                         printf("SARG: getword_multisep loop detected.\n");
 128                         printf("SARG: Line=\"%s\"\n",gwarea->beginning);
 129                         printf("SARG: Record=\"%s\"\n",gwarea->current);
 130                         printf("SARG: searching for \'x%x\'\n",stop);
 131                         //printf("SARG: Maybe you have a broken record or garbage in your access.log file.\n");
 132                         if (limit>0) word[limit-1]='\0';
 133 #if USE_GETWORD_BACKTRACE
 134                         getword_backtrace();
 135 #endif
 136                         //exit(EXIT_FAILURE);
 137                         return(-1);
 138                 }
 139                 word[x] = gwarea->current[x];
 140         }
 141
 142         word[x] = '\0';
 143         while (gwarea->current[x] && gwarea->current[x]==stop) ++x;
 144         gwarea->current+=x;
 145         return(0);
 146 }
 147
 148 int getword_skip(int limit, struct getwordstruct *gwarea, char stop)
 149 {
 150         int x;
 151
 152         for(x=0;(gwarea->current[x] && (gwarea->current[x] != stop ));x++) {
 153                 if(x>=limit) {
 154                         printf("SARG: getword_skip loop detected after %d bytes.\n",x);
 155                         printf("SARG: Line=\"%s\"\n",gwarea->beginning);
 156                         printf("SARG: Record=\"%s\"\n",gwarea->current);
 157                         printf("SARG: searching for \'x%x\'\n",stop);
 158                         //printf("SARG: Maybe you have a broken record or garbage in your access.log file.\n");
 159 #if USE_GETWORD_BACKTRACE
 160                         getword_backtrace();
 161 #endif
 162                         return(-1);
 163                 }
 164         }
 165
 166         if (gwarea->current[x]) ++x;
 167         gwarea->current+=x;
 168         return(0);
 169 }
 170
 171 int getword_atoll(long long int *number, struct getwordstruct *gwarea, char stop)
 172 {
 173         int x;
 174         int sign=+1;
 175
 176         if (gwarea->current[0] == '-') {
 177                 gwarea->current++;
 178                 sign=-1;
 179         } else if (gwarea->current[0] == '+') {
 180                 gwarea->current++;
 181         }
 182         *number=0LL;
 183         for(x=0;isdigit(gwarea->current[x]);x++) {
 184                 *number=(*number * 10) + gwarea->current[x]-'0';
 185         }
 186         if(gwarea->current[x] && gwarea->current[x]!=stop) {
 187                 printf("SARG: getword_atoll loop detected after %d bytes.\n",x);
 188                 printf("SARG: Line=\"%s\"\n",gwarea->beginning);
 189                 printf("SARG: Record=\"%s\"\n",gwarea->current);
 190                 printf("SARG: searching for \'x%x\'\n",stop);
 191                 //printf("SARG: Maybe you have a broken record or garbage in your access.log file.\n");
 192 #if USE_GETWORD_BACKTRACE
 193                 getword_backtrace();
 194 #endif
 195                 return(-1);
 196         }
 197         *number*=sign;
 198
 199         if (gwarea->current[x]) ++x;
 200         gwarea->current+=x;
 201         return(0);
 202 }
 203
 204
 205 int getword_ptr(char *orig_line,char **word, struct getwordstruct *gwarea, char stop)
 206 {
 207         /*!
 208         \note Why pass the original buffer to the function ? Because we must modify it to
 209         insert the terminating ASCII zero for the word we return and that's not compatible
 210         with getword_restart(). Moreover, getword_start() sometime works on constant strings
 211         so this function require the original buffer to detect any missuse.
 212         */
 213         int x;
 214         int sep;
 215         int start;
 216
 217         if (orig_line && orig_line!=gwarea->beginning) {
 218                 debuga(_("Invalid buffer passed to getword_ptr\n"));
 219                 return(-1);
 220         }
 221
 222         start=(gwarea->current-gwarea->beginning);
 223         if (word && orig_line) *word=orig_line+start;
 224         for(x=0;((gwarea->current[x]) && (gwarea->current[x] != stop ));x++);
 225         sep=(gwarea->current[x]!='\0');
 226         if (word && orig_line) orig_line[start+x] = '\0';
 227         if (sep) ++x;
 228         gwarea->current+=x;
 229         gwarea->modified=1;
 230         return(0);
 231 }
 232
 233 #define MAXLLL 30 //!< Maximum number of digits in long long (a guess).
 234 long long int my_atoll (const char *nptr)
 235 {
 236         long long int returnval=0LL;
 237         int max_digits = MAXLLL ;
 238
 239         // Soak up all the white space
 240         while (isspace( *nptr )) {
 241                 nptr++;
 242         }
 243
 244         //For each character left to right
 245         //change the character to a single digit
 246         //multiply what we had before by 10 and add the new digit
 247
 248         while (--max_digits && isdigit( *nptr ))
 249         {
 250                 returnval = ( returnval * 10 ) + ( *nptr++ - '0' ) ;
 251         }
 252
 253         return returnval;
 254 }
 255
 256 int is_absolute(const char *path)
 257 {
 258         if (*path=='/') return(1);
 259 #ifdef WINDOWS
 260         if (isalpha(path[0]) && path[1]==':') return(1);
 261 #endif
 262         return(0);
 263 }
 264
 265 void my_mkdir(const char *name)
 266 {
 267         char w0[MAXLEN];
 268         int i;
 269         int chars;
 270
 271         if(!is_absolute(name)) {
 272                 debuga(_("Invalid path (%s). Please, use absolute paths only.\n"),name);
 273                 debuga(_("process aborted.\n"));
 274                 exit(EXIT_FAILURE);
 275         }
 276
 277         chars=0;
 278         for (i=0 ; name[i] ; i++) {
 279                 if (i>=sizeof(w0)) {
 280                         debuga(_("directory name too long: %s\n"),name);
 281                         exit(EXIT_FAILURE);
 282                 }
 283                 if (chars>0 && name[i] == '/') {
 284                         w0[i] = '\0';
 285                         if (access(w0, R_OK) != 0) {
 286                                 if (mkdir(w0,0755)) {
 287                                         debuga(_("Cannot create directory %s - %s\n"),w0,strerror(errno));
 288                                         debuga(_("process aborted.\n"));
 289                                         exit(EXIT_FAILURE);
 290                                 }
 291                         }
 292                 }
 293                 if (name[i] != '/') chars++;
 294                 w0[i] = name[i];
 295         }
 296
 297         if (access(name, R_OK) != 0) {
 298                 if (mkdir(name,0755)) {
 299                         debuga(_("Cannot create directory %s - %s\n"),name,strerror(errno));
 300                         debuga(_("process aborted.\n"));
 301                         exit(EXIT_FAILURE);
 302                 }
 303         }
 304 }
 305
 306
 307 void my_lltoa(unsigned long long int n, char *s, int ssize, int len)
 308 {
 309         int i;
 310         int slen = 0;
 311         int j;
 312         char c;
 313
 314         ssize--;
 315         if (len>ssize) {
 316                 debuga(_("The requested number of digits passed to my_lltoa (%d) is bigger than the output buffer size (%d)\n"),len,ssize);
 317                 abort();
 318         }
 319
 320         do {
 321                 s[slen++] = (n % 10) + '0';
 322         } while ((n /= 10) > 0 && slen<ssize);
 323         s[slen] = '\0';
 324
 325         for (i = 0, j = slen-1; i<j; i++, j--) {
 326                 c = s[i];
 327                 s[i] = s[j];
 328                 s[j] = c;
 329         }
 330
 331         if(len>slen) {
 332                 i=len-slen;
 333                 for(j=slen; j>=0; j--)
 334                         s[j+i]=s[j];
 335                 for(j=0 ; j<i ; j++)
 336                         s[j]='0';
 337         }
 338 }
 339
 340 int month2num(const char *month)
 341 {
 342         int m;
 343
 344         for(m=0 ; m<12 && strcmp(mtab1[m],month) != 0; m++);
 345         return(m);
 346 }
 347
 348 int builddia(int day, int month, int year)
 349 {
 350         return(year*10000+month*100+day);
 351 }
 352
 353
 354 void buildymd(const char *dia, const char *mes, const char *ano, char *wdata)
 355 {
 356         int nmes;
 357
 358         nmes=month2num(mes);
 359         sprintf(wdata,"%04d%02d%02d",atoi(ano),nmes+1,atoi(dia));
 360 }
 361
 362
 363 int conv_month(const char *month)
 364 {
 365         int  x;
 366
 367         for(x=0; x<12 && strncmp(mtab1[x],month,3)!=0; x++);
 368         return(x+1);
 369 }
 370
 371
 372 const char *conv_month_name(int month)
 373 {
 374         static char str[4];
 375
 376         if (month<1 || month>12) {
 377                 snprintf(str,sizeof(str),"%03d",month);
 378                 return(str);
 379         }
 380         return(mtab1[month-1]);
 381 }
 382
 383
 384 void name_month(char *month,int month_len)
 385 {
 386         int  x, z=atoi(month)-1;
 387         char m[255];
 388         char w[20];
 389         struct getwordstruct gwarea;
 390
 391         strcpy(m,_("January,February,March,April,May,June,July,August,September,October,November,December"));
 392         getword_start(&gwarea,m);
 393
 394         for(x=0; x<z; x++)
 395                 if (getword_multisep(w,sizeof(w),&gwarea,',')<0) {
 396                         printf("SARG: Maybe you have a broken record or garbage in the names of the months.\n");
 397                         exit(EXIT_FAILURE);
 398                 }
 399         if (getword_multisep(month,month_len,&gwarea,',')<0) {
 400                 printf("SARG: Maybe you have a broken record or garbage in the name of the months.\n");
 401                 exit(EXIT_FAILURE);
 402         }
 403 }
 404
 405
 406 void debuga(const char *msg,...)
 407 {
 408         va_list ap;
 409
 410         fputs(_("SARG: "),stderr);
 411         va_start(ap,msg);
 412         vfprintf(stderr,msg,ap);
 413         va_end(ap);
 414 }
 415
 416
 417 void debugaz(const char *head, const char *msg)
 418 {
 419         fprintf(stderr, "SARG: (util) %s=%s\n",head, msg);
 420 }
 421
 422
 423 char *fixnum(long long int value, int n)
 424 {
 425 #define MAXLEN_FIXNUM 256
 426         char num[MAXLEN_FIXNUM]="";
 427         char buf[MAXLEN_FIXNUM * 2];
 428         char *pbuf;
 429         static char ret[MAXLEN_FIXNUM * 2];
 430         char *pret;
 431         register int i, j, k;
 432         int numlen;
 433         static char abbrev[30];
 434
 435         my_lltoa(value, num, sizeof(num), 0);
 436
 437         if(DisplayedValues==DISPLAY_ABBREV) {
 438                 numlen = strlen(num);
 439                 if(numlen <= 3)
 440                         sprintf(abbrev,"%s",num);
 441                 if(numlen == 4 || numlen == 7 || numlen == 10 || numlen == 13) {
 442                         snprintf(abbrev,2,"%s",num);
 443                         strncat(abbrev,".",1);
 444                         strncat(abbrev,num+1,2);
 445                         if(!n) return(abbrev);
 446                         if(numlen == 4)
 447                                 strncat(abbrev,"K",1);
 448                         else if(numlen == 7)
 449                                 strncat(abbrev,"M",1);
 450                         else if(numlen == 10)
 451                                 strncat(abbrev,"G",1);
 452                         else if(numlen == 13)
 453                                 strncat(abbrev,"T",1);
 454                 }
 455                 if(numlen == 5 || numlen == 8 || numlen == 11 || numlen == 14) {
 456                         snprintf(abbrev,3,"%s",num);
 457                         strncat(abbrev,".",1);
 458                         strncat(abbrev,num+2,2);
 459                         if(!n) return(abbrev);
 460                         if(numlen == 5)
 461                                 strncat(abbrev,"K",1);
 462                         else if(numlen == 8)
 463                                 strncat(abbrev,"M",1);
 464                         else if(numlen == 11)
 465                                 strncat(abbrev,"G",1);
 466                         else if(numlen == 14)
 467                                 strncat(abbrev,"T",1);
 468                 }
 469                 if(numlen == 6 || numlen == 9 || numlen == 12 || numlen == 15) {
 470                         snprintf(abbrev,4,"%s",num);
 471                         strncat(abbrev,".",1);
 472                         strncat(abbrev,num+3,2);
 473                         if(!n) return(abbrev);
 474                         if(numlen == 6)
 475                                 strncat(abbrev,"K",1);
 476                         else if(numlen == 9)
 477                                 strncat(abbrev,"M",1);
 478                         else if(numlen == 12)
 479                                 strncat(abbrev,"G",1);
 480                         else if(numlen == 15)
 481                                 strncat(abbrev,"T",1);
 482                 }
 483
 484                 return(abbrev);
 485         }
 486
 487         bzero(buf, MAXLEN_FIXNUM*2);
 488
 489         pbuf = buf;
 490         pret = ret;
 491         k = 0;
 492
 493         for ( i = strlen(num) - 1, j = 0 ; i > -1; i--) {
 494                 if ( k == 2 && i != 0 )  {
 495                         k = 0;
 496                         pbuf[j++] = num[i];
 497                         pbuf[j++] = (UseComma) ? ',' : '.';
 498                         continue;
 499                 }
 500                 pbuf[j] = num[i];
 501                 j++;
 502                 k++;
 503         }
 504
 505         pret[0]='\0';
 506
 507         for ( i = strlen(pbuf) - 1, j = 0 ; i > -1; i--, j++)
 508                 pret[j] = pbuf[i];
 509
 510         pret[j] = '\0';
 511
 512         return pret;
 513 }
 514
 515
 516 char *fixnum2(long long int value, int n)
 517 {
 518 #define MAXLEN_FIXNUM2 1024
 519         char num[MAXLEN_FIXNUM2];
 520         char buf[MAXLEN_FIXNUM2 * 2];
 521         char *pbuf;
 522         static char ret[MAXLEN_FIXNUM2 * 2];
 523         char *pret;
 524         register int i, j, k;
 525
 526         my_lltoa(value, num, sizeof(num), 0);
 527         bzero(buf, MAXLEN_FIXNUM2*2);
 528
 529         pbuf = buf;
 530         pret = ret;
 531         k = 0;
 532
 533         for ( i = strlen(num) - 1, j = 0 ; i > -1; i--) {
 534                 if ( k == 2 && i != 0 )  {
 535                         k = 0;
 536                         pbuf[j++] = num[i];
 537                         pbuf[j++] = (UseComma) ? ',' : '.';
 538                         continue;
 539                 }
 540                 pbuf[j] = num[i];
 541                 j++;
 542                 k++;
 543         }
 544
 545         pret[0]='\0';
 546
 547         for ( i = strlen(pbuf) - 1, j = 0 ; i > -1; i--, j++)
 548                 pret[j] = pbuf[i];
 549
 550         pret[j] = '\0';
 551
 552         return pret;
 553 }
 554
 555
 556 char *buildtime(long long int elap)
 557 {
 558         int num = elap / 1000;
 559         int hor = 0;
 560         int min = 0;
 561         int sec = 0;
 562         static char buf[12];
 563
 564         buf[0]='\0';
 565
 566         hor=num / 3600;
 567         min=(num % 3600) / 60;
 568         sec=num % 60;
 569         sprintf(buf,"%02d:%02d:%02d",hor,min,sec);
 570
 571         return(buf);
 572 }
 573
 574
 575 void obtdate(const char *dirname, const char *name, char *data)
 576 {
 577         FILE *fp_in;
 578         char wdir[MAXLEN];
 579
 580         sprintf(wdir,"%s%s/sarg-date",dirname,name);
 581         if ((fp_in = fopen(wdir, "rt")) == 0) {
 582                 sprintf(wdir,"%s%s/date",dirname,name);
 583                 if ((fp_in = fopen(wdir, "rt")) == 0) {
 584                         data[0]='\0';
 585                         return;
 586                 }
 587         }
 588
 589         if (!fgets(data,80,fp_in)) {
 590                 debuga(_("Failed to read the date in %s\n"),wdir);
 591                 exit(EXIT_FAILURE);
 592         }
 593         fclose(fp_in);
 594         fixendofline(data);
 595
 596         return;
 597 }
 598
 599
 600 void formatdate(char *date,int date_size,int year,int month,int day,int hour,int minute,int second,int dst)
 601 {
 602         struct tm ltm;
 603         time_t unixtime;
 604         struct tm *fulltm;
 605
 606         memset(&ltm,0,sizeof(ltm));
 607         if (year>=1900) ltm.tm_year=year-1900;
 608         if (month>=1 && month<=12) ltm.tm_mon=month-1;
 609         if (day>=1 && day<=31) ltm.tm_mday=day;
 610         if (hour>=0 && hour<24) ltm.tm_hour=hour;
 611         if (minute>=0 && minute<60) ltm.tm_min=minute;
 612         if (second>=0 && second<60) ltm.tm_sec=second;
 613         ltm.tm_isdst=dst;
 614         unixtime=mktime(&ltm); //fill the missing entries
 615         fulltm=localtime(&unixtime);
 616         //strftime(date,date_size,"%a %b %d %H:%M:%S %Z %Y",fulltm);
 617         strftime(date,date_size,"%c",fulltm);
 618 }
 619
 620
 621 void computedate(int year,int month,int day,struct tm *t)
 622 {
 623         memset(t,0,sizeof(*t));
 624         t->tm_year=year-1900;
 625         t->tm_mon=month-1;
 626         t->tm_mday=day;
 627 }
 628
 629
 630 int obtuser(const char *dirname, const char *name)
 631 {
 632         FILE *fp_in;
 633         char wdir[MAXLEN];
 634         char tuser[20];
 635         int nuser;
 636
 637         sprintf(wdir,"%s%s/sarg-users",dirname,name);
 638         if((fp_in=fopen(wdir,"r"))==NULL) {
 639                 sprintf(wdir,"%s%s/users",dirname,name);
 640                 if((fp_in=fopen(wdir,"r"))==NULL) {
 641                         return(0);
 642                 }
 643         }
 644
 645         if (!fgets(tuser,sizeof(tuser),fp_in)) {
 646                 debuga(_("Failed to read the number of users in %s\n"),wdir);
 647                 exit(EXIT_FAILURE);
 648         }
 649         fclose(fp_in);
 650         nuser=atoi(tuser);
 651
 652         return(nuser);
 653 }
 654
 655
 656 void obttotal(const char *dirname, const char *name, int nuser, long long int *tbytes, long long int *media)
 657 {
 658         FILE *fp_in;
 659         char *buf;
 660         char wdir[MAXLEN];
 661         char user[MAX_USER_LEN];
 662         char sep;
 663         struct getwordstruct gwarea;
 664         longline line;
 665
 666         *tbytes=0;
 667         *media=0;
 668
 669         sprintf(wdir,"%s%s/sarg-general",dirname,name);
 670         if ((fp_in = fopen(wdir, "r")) == 0) {
 671                 sprintf(wdir,"%s%s/general",dirname,name);
 672                 if ((fp_in = fopen(wdir, "r")) == 0) {
 673                         return;
 674                 }
 675         }
 676
 677         if ((line=longline_create())==NULL) {
 678                 debuga(_("Not enough memory to read the file %s\n"),wdir);
 679                 exit(EXIT_FAILURE);
 680         }
 681
 682         while((buf=longline_read(fp_in,line))!=NULL) {
 683                 if (strncmp(buf,"TOTAL\t",6) == 0)
 684                         sep='\t'; //new file
 685                 else if (strncmp(buf,"TOTAL ",6) == 0)
 686                         sep=' '; //old file
 687                 else
 688                         continue;
 689                 getword_start(&gwarea,buf);
 690                 if (getword(user,sizeof(user),&gwarea,sep)<0) {
 691                         debuga(_("There is a invalid user in file %s\n"),wdir);
 692                         exit(EXIT_FAILURE);
 693                 }
 694                 if(strcmp(user,"TOTAL") != 0)
 695                         continue;
 696                 if (getword_skip(MAXLEN,&gwarea,sep)<0) {
 697                         debuga(_("There a broken total number of access in file %s\n"),wdir);
 698                         exit(EXIT_FAILURE);
 699                 }
 700                 if (getword_atoll(tbytes,&gwarea,sep)<0) {
 701                         debuga(_("There is a broken number of bytes in file %s\n"),wdir);
 702                         exit(EXIT_FAILURE);
 703                 }
 704                 break;
 705         }
 706         fclose(fp_in);
 707         longline_destroy(&line);
 708
 709         if (nuser <= 0)
 710                 return;
 711
 712         *media=*tbytes / nuser;
 713         return;
 714 }
 715
 716 int getperiod_fromsarglog(const char *arqtt,struct periodstruct *period)
 717 {
 718         const char *str;
 719         int day0, month0, year0, hour0, minute0;
 720         int day1, month1, year1, hour1, minute1;
 721         int i;
 722
 723         memset(period,0,sizeof(*period));
 724
 725         str=arqtt;
 726         while((str=strstr(str,"sarg-"))!=NULL) {
 727                 str+=5;
 728                 if (!isdigit(str[0]) || !isdigit(str[1])) continue;
 729                 day0=(str[0]-'0')*10+(str[1]-'0');
 730                 str+=2;
 731                 month0=(str[0]-'0')*10+(str[1]-'0');
 732                 if (month0>=12) continue;
 733                 str+=2;
 734                 year0=0;
 735                 for (i=0 ; isdigit(str[i]) && i<4 ; i++) year0=year0*10+(str[i]-'0');
 736                 if (i!=4) continue;
 737                 str+=4;
 738                 if (str[0]!='_') continue;
 739                 str++;
 740
 741                 if (!isdigit(str[0]) || !isdigit(str[1])) continue;
 742                 hour0=(str[0]-'0')*10+(str[1]-'0');
 743                 str+=2;
 744                 if (!isdigit(str[0]) || !isdigit(str[1])) continue;
 745                 minute0=(str[0]-'0')*10+(str[1]-'0');
 746                 str+=2;
 747
 748                 if (*str != '-') continue;
 749                 str++;
 750
 751                 if (!isdigit(str[0]) || !isdigit(str[1])) continue;
 752                 day1=(str[0]-'0')*10+(str[1]-'0');
 753                 str+=2;
 754                 month1=(str[0]-'0')*10+(str[1]-'0');
 755                 if (month1>=12) continue;
 756                 str+=2;
 757                 year1=0;
 758                 for (i=0 ; isdigit(str[i]) && i<4 ; i++) year1=year1*10+(str[i]-'0');
 759                 if (i!=4) continue;
 760                 str+=4;
 761
 762                 if (str[0]!='_') continue;
 763                 str++;
 764
 765                 if (!isdigit(str[0]) || !isdigit(str[1])) continue;
 766                 hour1=(str[0]-'0')*10+(str[1]-'0');
 767                 str+=2;
 768                 if (!isdigit(str[0]) || !isdigit(str[1])) continue;
 769                 minute1=(str[0]-'0')*10+(str[1]-'0');
 770                 str+=2;
 771
 772                 period->start.tm_mday=day0;
 773                 period->start.tm_mon=month0;
 774                 period->start.tm_year=year0-1900;
 775                 period->start.tm_hour=hour0;
 776                 period->start.tm_min=minute0;
 777                 period->end.tm_mday=day1;
 778                 period->end.tm_mon=month1;
 779                 period->end.tm_year=year1-1900;
 780                 period->end.tm_hour=hour1;
 781                 period->end.tm_min=minute1;
 782                 return(0);
 783         }
 784         return(-1);
 785 }
 786
 787 void getperiod_fromrange(struct periodstruct *period,int dfrom,int duntil)
 788 {
 789         memset(&period->start,0,sizeof(period->start));
 790         period->start.tm_mday=dfrom%100;
 791         period->start.tm_mon=(dfrom/100)%100-1;
 792         period->start.tm_year=(dfrom/10000)-1900;
 793
 794         memset(&period->end,0,sizeof(period->end));
 795         period->end.tm_mday=duntil%100;
 796         period->end.tm_mon=(duntil/100)%100-1;
 797         period->end.tm_year=(duntil/10000)-1900;
 798 }
 799
 800 int getperiod_buildtext(struct periodstruct *period)
 801 {
 802         int i;
 803         int range;
 804         char text1[40], text2[40];
 805
 806         if(df[0]=='u') {
 807                 i=strftime(text1, sizeof(text1), "%Y %b %d", &period->start);
 808         }else if(df[0]=='e') {
 809                 i=strftime(text1, sizeof(text1), "%d %b %Y", &period->start);
 810         } else /*if(df[0]=='w')*/ {
 811                 IndexTree=INDEX_TREE_FILE;
 812                 i=strftime(text1, sizeof(text1), "%Y.%U", &period->start);
 813         }
 814         if (i == 0) return(-1);
 815
 816         range=(period->start.tm_year!=period->end.tm_year ||
 817                period->start.tm_mon!=period->end.tm_mon ||
 818                period->start.tm_mday!=period->end.tm_mday);
 819         if (range) {
 820                 if(df[0]=='u') {
 821                         i=strftime(text2, sizeof(text2)-i, "%Y %b %d", &period->end);
 822                 } else if(df[0]=='e') {
 823                         i=strftime(text2, sizeof(text2)-i, "%d %b %Y", &period->end);
 824                 } else {
 825                         i=strftime(text2, sizeof(text2)-i, "%Y.%U", &period->end);
 826                 }
 827                 if (i == 0) return(-1);
 828         }
 829
 830         if (range) {
 831                 snprintf(period->text,sizeof(period->text),"%s-%s",text1,text2);
 832                 snprintf(period->html,sizeof(period->html),"%s&mdash;%s",text1,text2);
 833         } else {
 834                 strncpy(period->text,text1,sizeof(period->text)-1);
 835                 period->text[sizeof(period->text)-1]='\0';
 836                 strncpy(period->html,text1,sizeof(period->html)-1);
 837                 period->html[sizeof(period->html)-1]='\0';
 838         }
 839         return(0);
 840 }
 841
 842 static void copy_images(void)
 843 {
 844         FILE *img_in, *img_ou;
 845         char images[512];
 846         char imgdir[MAXLEN];
 847         char srcfile[MAXLEN];
 848         char dstfile[MAXLEN];
 849         DIR *dirp;
 850         struct dirent *direntp;
 851         char buffer[MAXLEN];
 852         size_t nread;
 853         struct stat info;
 854
 855         if (snprintf(images,sizeof(images),"%simages",outdir)>=sizeof(images)) {
 856                 debuga(_("Cannot copy images to target directory %simages\n"),outdir);
 857                 exit(EXIT_FAILURE);
 858         }
 859         if (access(images,R_OK)!=0) {
 860                 if (mkdir(images,0755)) {
 861                         debuga(_("Cannot create directory %s - %s\n"),images,strerror(errno));
 862                         exit(EXIT_FAILURE);
 863                 }
 864         }
 865
 866         strcpy(imgdir,IMAGEDIR);
 867         dirp = opendir(imgdir);
 868         if(dirp==NULL) {
 869                 debuga(_("(util) Can't open directory %s: %s\n"),imgdir,strerror(errno));
 870                 return;
 871         }
 872         while ((direntp = readdir( dirp )) != NULL ){
 873                 if(direntp->d_name[0]=='.')
 874                         continue;
 875                 sprintf(srcfile,"%s/%s",imgdir,direntp->d_name);
 876                 if (stat(srcfile,&info)) {
 877                         debuga(_("Cannot stat \"%s\" - %s\n"),srcfile,strerror(errno));
 878                         continue;
 879                 }
 880                 if (S_ISREG(info.st_mode)) {
 881                         sprintf(dstfile,"%s/%s",images,direntp->d_name);
 882                         img_in = fopen(srcfile, "rb");
 883                         if(img_in!=NULL) {
 884                                 img_ou = fopen(dstfile, "wb");
 885                                 if(img_ou!=NULL) {
 886                                         while ((nread = fread(buffer,1,sizeof(buffer),img_in))>0) {
 887                                                 if (fwrite(buffer,1,nread,img_ou)!=nread) {
 888                                                         debuga(_("Failed to copy image %s to %s\n"),srcfile,dstfile);
 889                                                         break;
 890                                                 }
 891                                         }
 892                                         fclose(img_ou);
 893                                 } else
 894                                         fprintf(stderr,"SARG: (util): %s %s: %s\n", _("Cannot open file")?_("Cannot open file"):"Can't open/create file", dstfile, strerror(errno));
 895                                 fclose(img_in);
 896                         } else
 897                                 fprintf(stderr,"SARG: (util): %s %s: %s\n", _("Cannot open file")?_("Cannot open file"):"Can't open file", srcfile, strerror(errno));
 898                 }
 899         }
 900         (void) closedir(dirp);
 901
 902         return;
 903 }
 904
 905 int vrfydir(const struct periodstruct *per1, const char *addr, const char *site, const char *us, const char *form)
 906 {
 907         FILE *fp_ou;
 908         int  num=1, count=0;
 909         char wdir[MAXLEN];
 910         char dirname2[MAXLEN];
 911         int y1, y2;
 912         int m1, m2;
 913         int d1, d2;
 914         int wlen, wlen2;
 915         time_t curtime;
 916         struct tm *loctm;
 917
 918         strcpy(wdir,outdir);
 919         wlen=strlen(wdir);
 920         y1=per1->start.tm_year+1900;
 921         y2=per1->end.tm_year+1900;
 922         m1=per1->start.tm_mon+1;
 923         m2=per1->end.tm_mon+1;
 924         d1=per1->start.tm_mday;
 925         d2=per1->end.tm_mday;
 926         if(IndexTree == INDEX_TREE_DATE) {
 927                 wlen+=sprintf(wdir+wlen,"%04d",y1);
 928                 if(y1!=y2) wlen+=sprintf(wdir+wlen,"-%04d",y2);
 929                 if(access(wdir, R_OK) != 0)
 930                         my_mkdir(wdir);
 931
 932                 wlen+=sprintf(wdir+wlen,"/%02d",m1);
 933                 if(m1 != m2) wlen+=sprintf(wdir+wlen,"-%02d",m2);
 934                 if(access(wdir, R_OK) != 0)
 935                         my_mkdir(wdir);
 936
 937                 wlen+=sprintf(wdir+wlen,"/%02d",d1);
 938                 if(d1!=d2) wlen+=sprintf(wdir+wlen,"-%02d",d2);
 939         } else {
 940                 if(df[0] == 'u') {
 941                         wlen=snprintf(wdir+wlen,sizeof(wdir)-wlen,"%04d%s%02d-%04d%s%02d",y1,
 942                                 conv_month_name(m1),d1,y2,conv_month_name(m2),d2);
 943                 } else if(df[0] == 'e') {
 944                         wlen=snprintf(wdir+wlen,sizeof(wdir)-wlen,"%02d%s%04d-%02d%s%04d",d1,
 945                                 conv_month_name(m1),y1,d2,conv_month_name(m2),y2);
 946                 } else if(df[0] == 'w') {
 947                         wlen2=strftime(wdir+wlen, sizeof(wdir)-wlen, "%Y.%U", &per1->start);
 948                         if (wlen2==0) return(-1);
 949                         wlen+=wlen2;
 950                 }
 951         }
 952
 953         if(us[0] != '\0') {
 954                 struct userinfostruct *uinfo=userinfo_find_from_id(us);
 955                 if (uinfo) {
 956                         strcat(wdir,"-");
 957                         strcat(wdir,uinfo->filename);
 958                 }
 959         }
 960         if(addr[0] != '\0') {
 961                 strcat(wdir,"-");
 962                 strcat(wdir,addr);
 963         }
 964         if(site[0] != '\0') {
 965                 strcat(wdir,"-");
 966                 strcat(wdir,site);
 967         }
 968
 969         strcpy(outdirname,wdir);
 970
 971         if(IndexTree != INDEX_TREE_DATE) {
 972                 if(!OverwriteReport) {
 973                         while(num) {
 974                                 if(access(wdir,R_OK) == 0) {
 975                                         sprintf(wdir,"%s.%d",outdirname,num);
 976                                         num++;
 977                                         count++;
 978                                 } else
 979                                         break;
 980                         }
 981
 982                         if(count > 0) {
 983                                 if(debug)
 984                                         debuga(_("File %s already exists, moved to %s\n"),outdirname,wdir);
 985                                 rename(outdirname,wdir);
 986                         }
 987                 } else {
 988                         if(access(outdirname,R_OK) == 0) {
 989                                 unlinkdir(outdirname,1);
 990                         }
 991                 }
 992                 my_mkdir(outdirname);
 993         } else {
 994                 strcpy(dirname2,wdir);
 995                 if(!OverwriteReport) {
 996                         while(num) {
 997                                 if(access(wdir,R_OK) == 0) {
 998                                         sprintf(wdir,"%s.%d",dirname2,num);
 999                                         num++;
1000                                         count++;
1001                                 } else
1002                                         break;
1003                         }
1004
1005                         if(count > 0) {
1006                                 if(debug)
1007                                         debuga(_("File %s already exists, moved to %s\n"),dirname2,wdir);
1008                                 rename(dirname2,wdir);
1009                                 strcpy(dirname2,wdir);
1010                         }
1011                 } else {
1012                         if(access(wdir,R_OK) == 0) {
1013                                 unlinkdir(wdir,1);
1014                         }
1015                 }
1016
1017                 if(access(wdir, R_OK) != 0)
1018                         my_mkdir(wdir);
1019         }
1020
1021         strcpy(dirname2,wdir);
1022
1023         sprintf(wdir,"%s/sarg-date",outdirname);
1024         if ((fp_ou = fopen(wdir, "wt")) == 0) {
1025                 debuga(_("cannot open %s for writing\n"),wdir);
1026                 perror("SARG:");
1027                 exit(EXIT_FAILURE);
1028         }
1029         time(&curtime);
1030         //strftime(wdir,sizeof(wdir),"%a %b %d %H:%M:%S %Z %Y",localtime(&curtime));
1031         loctm=localtime(&curtime);
1032         strftime(wdir,sizeof(wdir),"%Y-%m-%d %H:%M:%S",loctm);
1033         if (fprintf(fp_ou,"%s %d\n",wdir,loctm->tm_isdst)<0) {
1034                 debuga(_("Failed to write the date in %s\n"),wdir);
1035                 perror("SARG:");
1036                 exit(EXIT_FAILURE);
1037         }
1038         if (fclose(fp_ou)==EOF) {
1039                 debuga(_("Failed to write the date in %s\n"),wdir);
1040                 perror("SARG:");
1041                 exit(EXIT_FAILURE);
1042         }
1043
1044         copy_images();
1045         return(0);
1046 }
1047
1048 void strip_latin(char *line)
1049 {
1050         int i,j;
1051         int skip;
1052
1053         j=0;
1054         skip=0;
1055         for (i=0;line[i];i++){
1056                 if (skip){
1057                         if (line[i]==';') skip=0;
1058                 } else {
1059                         if (line[i]=='&')
1060                                 skip=1;
1061                         else
1062                                 line[j++]=line[i];
1063                 }
1064         }
1065         line[j]='\0';
1066         return;
1067 }
1068
1069 void zdate(char *ftime,int ftimesize, const char *DateFormat)
1070 {
1071         time_t t;
1072         struct tm *local;
1073
1074         t = time(NULL);
1075         local = localtime(&t);
1076         if(strcmp(DateFormat,"u") == 0)
1077                 strftime(ftime, ftimesize, "%b/%d/%Y %H:%M", local);
1078         if(strcmp(DateFormat,"e") == 0)
1079                 strftime(ftime, ftimesize, "%d/%b/%Y-%H:%M", local);
1080         if(strcmp(DateFormat,"w") == 0)
1081                 strftime(ftime, ftimesize, "%W-%H-%M", local);
1082         return;
1083 }
1084
1085
1086 char *fixtime(long long int elap)
1087 {
1088         int num = elap / 1000;
1089         int hor = 0;
1090         int min = 0;
1091         int sec = 0;
1092         static char buf[12];
1093
1094         hor=num / 3600;
1095         min=(num % 3600) / 60;
1096         sec=num % 60;
1097
1098         if(hor==0 && min==0 && sec==0)
1099                 strcpy(buf,"0");
1100         else
1101                 sprintf(buf,"%d:%02d:%02d",hor,min,sec);
1102
1103         return buf;
1104 }
1105
1106
1107 void date_from(char *date, int *dfrom, int *duntil)
1108 {
1109         int d0=0;
1110         int m0=0;
1111         int y0=0;
1112         int d1=0;
1113         int m1=0;
1114         int y1=0;
1115
1116         if (isdigit(date[0])) {
1117                 int next=-1;
1118
1119                 if (sscanf(date,"%d/%d/%d%n",&d0,&m0,&y0,&next)!=3 || y0<100 || m0<1 || m0>12 || d0<1 || d0>31 || next<0) {
1120                         debuga(_("The date passed as argument is not formated as dd/mm/yyyy or dd/mm/yyyy-dd/mm/yyyy\n"));
1121                         exit(EXIT_FAILURE);
1122                 }
1123                 if (date[next]=='-') {
1124                         if (sscanf(date+next+1,"%d/%d/%d",&d1,&m1,&y1)!=3 || y1<100 || m1<1 || m1>12 || d1<1 || d1>31) {
1125                                 debuga(_("The date range passed as argument is not formated as dd/mm/yyyy or dd/mm/yyyy-dd/mm/yyyy\n"));
1126                                 exit(EXIT_FAILURE);
1127                         }
1128                 } else if (date[next]!='\0') {
1129                         debuga(_("The date range passed as argument is not formated as dd/mm/yyyy or dd/mm/yyyy-dd/mm/yyyy\n"));
1130                         exit(EXIT_FAILURE);
1131                 } else {
1132                         d1=d0;
1133                         m1=m0;
1134                         y1=y0;
1135                 }
1136         } else {
1137                 int i;
1138                 time_t Today,t1;
1139                 struct tm *Date0,Date1;
1140
1141                 if (time(&Today)==(time_t)-1) {
1142                         debuga(_("Failed to get the current time\n"));
1143                         exit(EXIT_FAILURE);
1144                 }
1145                 if (sscanf(date,"day-%d",&i)==1) {
1146                         if (i<0) {
1147                                 debuga(_("Invalid number of days in -d parameter\n"));
1148                                 exit(EXIT_FAILURE);
1149                         }
1150                         Today-=i*24*60*60;
1151                         Date0=localtime(&Today);
1152                         if (Date0==NULL) {
1153                                 debuga(_("Cannot convert local time: %s\n"),strerror(errno));
1154                                 exit(EXIT_FAILURE);
1155                         }
1156                         y0=y1=Date0->tm_year+1900;
1157                         m0=m1=Date0->tm_mon+1;
1158                         d0=d1=Date0->tm_mday;
1159                 } else if (sscanf(date,"week-%d",&i)==1) {
1160                         /*
1161                         There is no portable way to find the first day of the week even though the
1162                         information is available in the locale. nl_langinfo has the unofficial
1163                         parameters _NL_TIME_FIRST_WEEKDAY and _NL_TIME_WEEK_1STDAY but they are
1164                         undocumented as is their return value and it is discouraged to use them.
1165                         Beside, nl_langinfo isn't available on windows and the first day of the
1166                         week isn't available at all on that system.
1167                         */
1168                         const int FirstWeekDay=1;
1169                         time_t WeekBegin;
1170
1171                         if (i<0) {
1172                                 debuga(_("Invalid number of weeks in -d parameter\n"));
1173                                 exit(EXIT_FAILURE);
1174                         }
1175                         Date0=localtime(&Today);
1176                         if (Date0==NULL) {
1177                                 debuga(_("Cannot convert local time: %s\n"),strerror(errno));
1178                                 exit(EXIT_FAILURE);
1179                         }
1180                         WeekBegin=Today-((Date0->tm_wday-FirstWeekDay+7)%7)*24*60*60;
1181                         WeekBegin-=i*7*24*60*60;
1182                         Date0=localtime(&WeekBegin);
1183                         if (Date0==NULL) {
1184                                 debuga(_("Cannot convert local time: %s\n"),strerror(errno));
1185                                 exit(EXIT_FAILURE);
1186                         }
1187                         y0=Date0->tm_year+1900;
1188                         m0=Date0->tm_mon+1;
1189                         d0=Date0->tm_mday;
1190                         WeekBegin+=6*24*60*60;
1191                         Date0=localtime(&WeekBegin);
1192                         if (Date0==NULL) {
1193                                 debuga(_("Cannot convert local time: %s\n"),strerror(errno));
1194                                 exit(EXIT_FAILURE);
1195                         }
1196                         y1=Date0->tm_year+1900;
1197                         m1=Date0->tm_mon+1;
1198                         d1=Date0->tm_mday;
1199                 } else if (sscanf(date,"month-%d",&i)==1) {
1200                         if (i<0) {
1201                                 debuga(_("Invalid number of months in -d parameter\n"));
1202                                 exit(EXIT_FAILURE);
1203                         }
1204                         Date0=localtime(&Today);
1205                         if (Date0==NULL) {
1206                                 debuga(_("Cannot convert local time: %s\n"),strerror(errno));
1207                                 exit(EXIT_FAILURE);
1208                         }
1209                         if (Date0->tm_mon<i%12) {
1210                                 y0=Date0->tm_year+1900-i/12-1;
1211                                 m0=(Date0->tm_mon+12-i%12)%12+1;
1212                                 d0=1;
1213                         } else {
1214                                 y0=Date0->tm_year+1900-i/12;
1215                                 m0=Date0->tm_mon-i%12+1;
1216                                 d0=1;
1217                         }
1218                         memcpy(&Date1,Date0,sizeof(struct tm));
1219                         Date1.tm_isdst=-1;
1220                         Date1.tm_mday=1;
1221                         if (m0<12) {
1222                                 Date1.tm_mon=m0;
1223                                 Date1.tm_year=y0-1900;
1224                         } else {
1225                                 Date1.tm_mon=0;
1226                                 Date1.tm_year=y0-1900+1;
1227                         }
1228                         t1=mktime(&Date1);
1229                         t1-=24*60*60;
1230                         Date0=localtime(&t1);
1231                         y1=Date0->tm_year+1900;
1232                         m1=Date0->tm_mon+1;
1233                         d1=Date0->tm_mday;
1234                 } else {
1235                         debuga(_("Invalid date range passed on command line\n"));
1236                         exit(EXIT_FAILURE);
1237                 }
1238         }
1239
1240         *dfrom=y0*10000+m0*100+d0;
1241         *duntil=y1*10000+m1*100+d1;
1242         sprintf(date,"%02d/%02d/%04d-%02d/%02d/%04d",d0,m0,y0,d1,m1,y1);
1243         return;
1244 }
1245
1246
1247 char *strlow(char *string)
1248 {
1249         char *s;
1250
1251         if (string)
1252         {
1253                 for (s = string; *s; ++s)
1254                         *s = tolower(*s);
1255         }
1256
1257         return string;
1258 }
1259
1260
1261
1262
1263 char *strup(char *string)
1264 {
1265         char *s;
1266
1267         if (string)
1268         {
1269                 for (s = string; *s; ++s)
1270                         *s = toupper(*s);
1271         }
1272
1273         return string;
1274 }
1275
1276
1277 void removetmp(const char *outdir)
1278 {
1279         FILE *fp_gen;
1280         char filename[256];
1281
1282         if(!RemoveTempFiles)
1283                 return;
1284
1285         if(debug) {
1286                 debuga(_("Purging temporary file sarg-general\n"));
1287         }
1288         if (snprintf(filename,sizeof(filename),"%s/sarg-general",outdir)>=sizeof(filename)) {
1289                 debuga(_("(removetmp) directory too long to remove %s/sarg-period\n"),outdir);
1290                 exit(EXIT_FAILURE);
1291         }
1292         if((fp_gen=fopen(filename,"w"))==NULL){
1293                 debuga(_("(removetmp) Cannot open file %s\n"),filename);
1294                 exit(EXIT_FAILURE);
1295         }
1296         totalger(fp_gen,filename);
1297         if (fclose(fp_gen)==EOF) {
1298                 debuga(_("Failed to close %s after writing the total line - %s\n"),filename,strerror(errno));
1299                 exit(EXIT_FAILURE);
1300         }
1301 }
1302
1303 void load_excludecodes(const char *ExcludeCodes)
1304 {
1305         FILE *fp_in;
1306         char data[80];
1307         int i;
1308         int Stored;
1309         long int MemSize;
1310
1311         if(ExcludeCodes[0] == '\0')
1312                 return;
1313
1314         if((fp_in=fopen(ExcludeCodes,"r"))==NULL) {
1315                 debuga(_("(util) Cannot open file %s (exclude_codes)\n"),ExcludeCodes);
1316                 exit(EXIT_FAILURE);
1317         }
1318
1319         if (fseek(fp_in, 0, SEEK_END)==-1) {
1320                 debuga(_("Failed to move till the end of the excluded codes file %s: %s\n"),ExcludeCodes,strerror(errno));
1321                 exit(EXIT_FAILURE);
1322         }
1323         MemSize = ftell(fp_in);
1324         if (MemSize<0) {
1325                 debuga(_("Cannot get the size of file %s\n"),ExcludeCodes);
1326                 exit(EXIT_FAILURE);
1327         }
1328         if (fseek(fp_in, 0, SEEK_SET)==-1) {
1329                 debuga(_("Failed to rewind the excluded codes file %s: %s\n"),ExcludeCodes,strerror(errno));
1330                 exit(EXIT_FAILURE);
1331         }
1332
1333         MemSize+=1;
1334         if((excludecode=(char *) malloc(MemSize))==NULL) {
1335                 debuga(_("malloc error (%ld)\n"),MemSize);
1336                 exit(EXIT_FAILURE);
1337         }
1338         memset(excludecode,0,MemSize);
1339
1340         Stored=0;
1341         while(fgets(data,sizeof(data),fp_in)!=NULL) {
1342                 if (data[0]=='#') continue;
1343                 for (i=strlen(data)-1 ; i>=0 && (unsigned char)data[i]<=' ' ; i--) data[i]='\0';
1344                 if (i<0) continue;
1345                 if (Stored+i+2>=MemSize) {
1346                         debuga(_("Too many codes to exclude in file %s\n"),ExcludeCodes);
1347                         break;
1348                 }
1349                 strcat(excludecode,data);
1350                 strcat(excludecode,";");
1351                 Stored+=i+1;
1352         }
1353
1354         fclose(fp_in);
1355         return;
1356 }
1357
1358 void free_excludecodes(void)
1359 {
1360         if (excludecode) {
1361                 free(excludecode);
1362                 excludecode=NULL;
1363         }
1364 }
1365
1366 int vercode(const char *code)
1367 {
1368         char *cod;
1369         int clen;
1370
1371         if (excludecode && excludecode[0]!='\0') {
1372                 clen=strlen(code);
1373                 cod=excludecode;
1374                 while (cod) {
1375                         if (strncmp(code,cod,clen)==0 && cod[clen]==';')
1376                                 return 1;
1377                         cod=strchr(cod,';');
1378                         if (cod) cod++;
1379                 }
1380         }
1381         return 0;
1382 }
1383
1384 void fixnone(char *str)
1385 {
1386         int i;
1387
1388         for (i=strlen(str)-1 ; i>=0 && (unsigned char)str[i]<=' ' ; i--);
1389         if(i==3 && strncmp(str,"none",4) == 0)
1390                 str[0]='\0';
1391
1392         return;
1393 }
1394
1395 void fixendofline(char *str)
1396 {
1397         int i;
1398
1399         for (i=strlen(str)-1 ; i>=0 && (unsigned char)str[i]<=' ' ; i--) str[i]=0;
1400 }
1401
1402 #ifdef LEGACY_TESTVALIDUSERCHAR
1403 int testvaliduserchar(const char *user)
1404 {
1405         int x=0;
1406         int y=0;
1407
1408         for (y=0; y<strlen(UserInvalidChar); y++) {
1409                 for (x=0; x<strlen(user); x++) {
1410                         if(user[x] == UserInvalidChar[y])
1411                                 return 1;
1412                 }
1413         }
1414         return 0;
1415 }
1416 #else
1417 int testvaliduserchar(const char *user)
1418 {
1419         char * p_UserInvalidChar = UserInvalidChar ;
1420         const char * p_user ;
1421
1422         while( *p_UserInvalidChar ) {
1423                 p_user = user ;
1424                 while ( *p_user ) {
1425                         if( *p_UserInvalidChar == *p_user )
1426                                 return 1;
1427                         p_user++ ;
1428                 }
1429                 p_UserInvalidChar++ ;
1430         }
1431         return 0;
1432 }
1433 #endif
1434
1435 int compar( const void *a, const void *b )
1436 {
1437         if( *(int *)a > *(int *)b ) return 1;
1438         if( *(int *)a < *(int *)b ) return -1;
1439         return 0;
1440 }
1441
1442 int getnumlist( char *buf, numlist *list, const int len, const int maxvalue )
1443 {
1444         int i, j, d, flag, r1, r2;
1445         char *pbuf, **bp, *strbufs[ 24 ];
1446
1447         bp = strbufs;
1448         strtok( buf, " \t" );
1449         for( *bp = strtok( NULL, "," ), list->len = 0; *bp; *bp = strtok( NULL, "," ) ) {
1450                 if( ++bp >= &strbufs[ 24 ] )
1451                         break;
1452                 list->len++;
1453         }
1454         if( ! list->len )
1455                 return -1;
1456         d = 0;
1457         for( i = 0; i < list->len; i++ ) {
1458                 if( strchr( strbufs[ i ], '-' ) != 0 ) {
1459                         pbuf = strbufs[ i ];
1460                         strtok( pbuf, "-" );
1461                         pbuf = strtok( NULL, "\0" );
1462                         r1 = atoi( strbufs[ i ] );
1463                         if( ( r2 = atoi( pbuf ) ) >= maxvalue || r1 >= r2 )
1464                                 return -1;
1465                         if( i + d + ( r2 - r1 ) + 1 <= len ) {
1466                                 for( j = r1; j <= r2; j++ )
1467                                         list->list[ i + d++ ] = j;
1468                                 d--;
1469                         }
1470                 }
1471                 else
1472                         if( ( list->list[ i + d ] = atoi( strbufs[ i ] ) ) >= maxvalue )
1473                                 return 1;
1474         }
1475         list->len += d;
1476         qsort( list->list, list->len, sizeof( int ), compar );
1477         do {
1478                 flag = 0;
1479                 for( i = 0; i < list->len - 1; i++ )
1480                         if( list->list[ i ] == list->list[ i + 1 ] ) {
1481                                 for( j = i + 1; j < list->len; j++ )
1482                                         list->list[ j - 1 ] = list->list[ j ];
1483                                 list->len--;
1484                                 flag = 1;
1485                                 break;
1486                         }
1487         } while( flag );
1488         return 0;
1489 }
1490
1491
1492 char *get_size(const char *path, const char *file)
1493 {
1494         FILE *fp;
1495         static char response[255];
1496         char cmd[255];
1497         char *ptr;
1498
1499         if (snprintf(cmd,sizeof(cmd),"du -skh %s%s",path,file)>=sizeof(cmd)) {
1500                 debuga(_("Cannot get disk space because the path %s%s is too long\n"),path,file);
1501                 exit(EXIT_FAILURE);
1502         }
1503         if ((fp = popen(cmd, "r")) == NULL) {
1504                 debuga(_("Cannot get disk space with command %s\n"),cmd);
1505                 exit(EXIT_FAILURE);
1506         }
1507         if (!fgets(response, sizeof(response), fp)) {
1508                 debuga(_("Cannot get disk size with command %s\n"),cmd);
1509                 exit(EXIT_FAILURE);
1510         }
1511         ptr=strchr(response,'\t');
1512         if (ptr==NULL) {
1513                 debuga(_("The command %s failed\n"),cmd);
1514                 exit(EXIT_FAILURE);
1515         }
1516         pclose(fp);
1517         *ptr='\0';
1518
1519         return (response);
1520 }
1521
1522 void show_info(FILE *fp_ou)
1523 {
1524         char ftime[127];
1525
1526         if(!ShowSargInfo) return;
1527         zdate(ftime, sizeof(ftime), DateFormat);
1528         fprintf(fp_ou,"<div class=\"info\">%s <a href='%s'>%s-%s</a> %s %s</div>\n",_("Generated by"),URL,PGM,VERSION,_("on"),ftime);
1529 }
1530
1531 void show_sarg(FILE *fp_ou, int depth)
1532 {
1533         int i;
1534
1535         if(!ShowSargLogo) return;
1536         fputs("<div class=\"logo\"><a href=\"http://sarg.sourceforge.net\"><img src=\"",fp_ou);
1537         for (i=0 ; i<depth ; i++)
1538                 fputs("../",fp_ou);
1539         fputs("images/sarg.png\" title=\"SARG, Squid Analysis Report Generator. Logo by Osamu Matsuzaki\" alt=\"Sarg\"></a>&nbsp;Squid Analysis Report Generator</div>\n",fp_ou);
1540 }
1541
1542 void write_logo_image(FILE *fp_ou)
1543 {
1544         if(LogoImage[0]!='\0')
1545                 fprintf(fp_ou, "<div class=\"logo\"><img src=\"%s\" width=\"%s\" height=\"%s\" alt=\"Logo\">&nbsp;%s</div>\n",LogoImage,Width,Height,LogoText);
1546 }
1547
1548 void write_html_head(FILE *fp_ou, int depth, const char *page_title,int javascript)
1549 {
1550         int i;
1551
1552         fputs("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">\n<html>\n",fp_ou);
1553         fprintf(fp_ou, "<head>\n  <meta http-equiv=\"Content-Type\" content=\"text/html; charset=%s\">\n",CharSet);
1554         if (page_title) fprintf(fp_ou,"<title>%s</title>\n",page_title);
1555         css(fp_ou);
1556         if ((javascript & HTML_JS_SORTTABLE)!=0 && SortTableJs[0]) {
1557                 fputs("<script type=\"text/javascript\" src=\"",fp_ou);
1558                 if (strncmp(SortTableJs,"../",3)==0) {
1559                         for (i=0 ; i<depth ; i++) fputs("../",fp_ou);
1560                 }
1561                 fputs(SortTableJs,fp_ou);
1562                 fputs("\"></script>\n",fp_ou);
1563         }
1564         fputs("</head>\n<body>\n",fp_ou);
1565 }
1566
1567 void write_html_header(FILE *fp_ou, int depth, const char *page_title,int javascript)
1568 {
1569         write_html_head(fp_ou,depth,page_title,javascript);
1570         write_logo_image(fp_ou);
1571         show_sarg(fp_ou, depth);
1572         fprintf(fp_ou,"<div class=\"title\"><table cellpadding=\"0\" cellspacing=\"0\">\n<tr><th class=\"title_c\">%s</th></tr>\n",Title);
1573 }
1574
1575 void close_html_header(FILE *fp_ou)
1576 {
1577         fputs("</table></div>\n",fp_ou);
1578 }
1579
1580 int write_html_trailer(FILE *fp_ou)
1581 {
1582         show_info(fp_ou);
1583         if (fputs("</body>\n</html>\n",fp_ou)==EOF) return(-1);
1584         return(0);
1585 }
1586
1587 void output_html_string(FILE *fp_ou,const char *str,int maxlen)
1588 {
1589         int i=0;
1590
1591         while (*str && (maxlen<=0 || i<maxlen)) {
1592                 switch (*str) {
1593                         case '&':
1594                                 fputs("&amp;",fp_ou);
1595                                 break;
1596                         case '<':
1597                                 fputs("&lt;",fp_ou);
1598                                 break;
1599                         case '>':
1600                                 fputs("&gt;",fp_ou);
1601                                 break;
1602                         case '"':
1603                                 fputs("&quot;",fp_ou);
1604                                 break;
1605                         case '\'':
1606                                 fputs("&#39;",fp_ou);
1607                                 break;
1608                         default:
1609                                 fputc(*str,fp_ou);
1610                 }
1611                 str++;
1612                 i++;
1613         }
1614         if (maxlen>0 && i>=maxlen)
1615                 fputs("&hellip;",fp_ou);
1616 }
1617
1618 void output_html_url(FILE *fp_ou,const char *url)
1619 {
1620         while (*url) {
1621                 if (*url=='&')
1622                         fputs("&amp;",fp_ou);
1623                 else
1624                         fputc(*url,fp_ou);
1625                 url++;
1626         }
1627 }
1628
1629 void url_hostname(const char *url,char *hostname,int hostsize)
1630 {
1631         int i;
1632
1633         hostsize--;
1634         for (i=0 ; i<hostsize && url[i] && url[i]!='/' ; i++)
1635                 hostname[i]=url[i];
1636         hostname[i]='\0';
1637 }
1638
1639 void url_module(const char *url, char *w2)
1640 {
1641         int x, y;
1642         char w[255];
1643
1644         y=0;
1645         for(x=strlen(url)-1; x>=0; x--) {
1646                 if(url[x] == '/' || y>=sizeof(w)-1) break;
1647                 w[y++]=url[x];
1648         }
1649         if (x<0) {
1650                 w2[0]='\0';
1651                 return;
1652         }
1653
1654         x=0;
1655         for(y=y-1; y>=0; y--) {
1656                 w2[x++]=w[y];
1657         }
1658         w2[x]='\0';
1659 }
1660
1661 void url_to_file(const char *url,char *file,int filesize)
1662 {
1663         int i,skip;
1664
1665         filesize--;
1666         skip=0;
1667         for(i=0; i<filesize && *url; url++) {
1668                 if(isalnum(*url) || *url=='-' || *url=='_' || *url=='.' || *url=='%') {
1669                         file[i++]=*url;
1670                         skip=0;
1671                 } else {
1672                         if (!skip) file[i++]='_';
1673                         skip=1;
1674                 }
1675         }
1676         file[i]='\0';
1677 }
1678
1679 void version(void)
1680 {
1681         printf(_("SARG Version: %s\n"),VERSION);
1682         exit(EXIT_SUCCESS);
1683 }
1684
1685 char *get_param_value(const char *param,char *line)
1686 {
1687         int plen;
1688
1689         while (*line==' ' || *line=='\t') line++;
1690         plen=strlen(param);
1691         if (strncasecmp(line,param,plen)) return(NULL);
1692         if (line[plen]!=' ' && line[plen]!='\t') return(NULL);
1693         line+=plen;
1694         while (*line==' ' || *line=='\t') line++;
1695         return(line);
1696 }
1697
1698 void unlinkdir(const char *dir,int contentonly)
1699 {
1700         struct stat st;
1701         DIR *dirp;
1702         struct dirent *direntp;
1703         char dname[MAXLEN];
1704         int err;
1705
1706         dirp=opendir(dir);
1707         if (!dirp) return;
1708         while ((direntp = readdir(dirp)) != NULL) {
1709                 if (direntp->d_name[0] == '.' && (direntp->d_name[1] == '\0' ||
1710                     (direntp->d_name[1] == '.' && direntp->d_name[2] == '\0')))
1711                         continue;
1712                 if (snprintf(dname,sizeof(dname),"%s/%s",dir,direntp->d_name)>=sizeof(dname)) {
1713                         debuga(_("directory name to delete too long: %s/%s\n"),dir,direntp->d_name);
1714                         exit(EXIT_FAILURE);
1715                 }
1716 #ifdef HAVE_LSTAT
1717                 err=lstat(dname,&st);
1718 #else
1719                 err=stat(dname,&st);
1720 #endif
1721                 if (err) {
1722                         debuga(_("cannot stat %s\n"),dname);
1723                         exit(EXIT_FAILURE);
1724                 }
1725                 if (S_ISREG(st.st_mode)) {
1726                         if (unlink(dname)) {
1727                                 debuga(_("cannot delete %s - %s\n"),dname,strerror(errno));
1728                                 exit(EXIT_FAILURE);
1729                         }
1730                 } else if (S_ISDIR(st.st_mode)) {
1731                         unlinkdir(dname,0);
1732                 } else {
1733                         debuga(_("unknown path type %s\n"),dname);
1734                 }
1735         }
1736         closedir(dirp);
1737
1738         if (!contentonly) {
1739                 if (rmdir(dir)) {
1740                         debuga(_("cannot delete %s - %s\n"),dir,strerror(errno));
1741                         exit(EXIT_FAILURE);
1742                 }
1743         }
1744 }
1745