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