fix to safe_strdup prototype.
[debian/dhcpd-pools.git] / src / output.c
1 /* http://dhcpd-pools.sourceforge.net/
2 ** Copyright 2006- Sami Kerola <kerolasa@iki.fi>
3 **
4 ** This program is free software: you can redistribute it and/or modify
5 ** it under the terms of the GNU General Public License as published by
6 ** the Free Software Foundation, either version 3 of the License, or
7 ** (at your option) any later version.
8 **
9 ** This program is distributed in the hope that it will be useful,
10 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
11 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 ** GNU General Public License for more details.
13 **
14 ** You should have received a copy of the GNU General Public License
15 ** along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #ifdef HAVE_CONFIG_H
19 #include <config.h>
20 #endif
21
22 #include <stdio.h>
23 #include <sys/socket.h>
24 #include <netinet/in.h>
25 #include <arpa/inet.h>
26 #include <err.h>
27
28 #include "dhcpd-pools.h"
29
30 int output_txt(void)
31 {
32         unsigned int i;
33         struct in_addr first, last;
34         struct range_t *range_p;
35         struct shared_network_t *shared_p;
36         int ret;
37         FILE *outfile;
38
39         if (config.output_file[0]) {
40                 outfile = fopen(config.output_file, "w+");
41                 if (outfile == NULL) {
42                         err(EXIT_FAILURE, "output_txt: %s",
43                             config.output_file);
44                 }
45         } else {
46                 outfile = stdout;
47         }
48
49         range_p = ranges;
50         shared_p = shared_networks;
51
52         if (config.output_limit[0] & output_limit_bit_1) {
53                 fprintf(outfile, "Ranges:\n");
54                 fprintf
55                     (outfile,
56                      "shared net name     first ip           last ip            max   cur    percent  touch   t+c  t+c perc");
57                 if (0 < num_backups) {
58                         fprintf(outfile, "     bu  bu perc");
59                 }
60                 fprintf(outfile, "\n");
61         }
62         if (config.output_limit[1] & output_limit_bit_1) {
63                 for (i = 0; i < num_ranges; i++) {
64                         first.s_addr = ntohl(range_p->first_ip + 1);
65                         last.s_addr = ntohl(range_p->last_ip - 1);
66
67                         if (range_p->shared_net) {
68                                 fprintf(outfile, "%-20s",
69                                         range_p->shared_net->name);
70                         } else {
71                                 fprintf(outfile, "not_defined         ");
72                         }
73                         fprintf(outfile, "%-16s", inet_ntoa(first));
74                         fprintf(outfile,
75                                 " - %-16s %5lu %5lu %10.3f  %5lu %5lu %9.3f",
76                                 inet_ntoa(last),
77                                 range_p->last_ip - range_p->first_ip - 1,
78                                 range_p->count,
79                                 (float) (100 * range_p->count) /
80                                 (range_p->last_ip - range_p->first_ip - 1),
81                                 range_p->touched,
82                                 range_p->touched + range_p->count,
83                                 (float) (100 *
84                                          (range_p->touched +
85                                           range_p->count)) /
86                                 (range_p->last_ip - range_p->first_ip -
87                                  1));
88                         if (0 < num_backups) {
89                                 fprintf(outfile, "%7lu %8.3f",
90                                         range_p->backups,
91                                         (float) (100 * range_p->backups) /
92                                         (range_p->last_ip -
93                                          range_p->first_ip - 1));
94                         }
95                         fprintf(outfile, "\n");
96                         range_p++;
97                 }
98         }
99         if (config.output_limit[1] & output_limit_bit_1
100             && config.output_limit[0] & output_limit_bit_2) {
101                 fprintf(outfile, "\n");
102         }
103         if (config.output_limit[0] & output_limit_bit_2) {
104                 fprintf(outfile, "Shared networks:\n");
105                 fprintf(outfile,
106                         "name                   max   cur     percent  touch    t+c  t+c perc");
107                 if (0 < num_backups) {
108                         fprintf(outfile, "     bu  bu perc");
109                 }
110                 fprintf(outfile, "\n");
111         }
112         if (config.output_limit[1] & output_limit_bit_2) {
113                 for (i = 0; i < num_shared_networks; i++) {
114                         shared_p++;
115                         fprintf(outfile,
116                                 "%-20s %5lu %5lu %10.3f %7lu %6lu %9.3f",
117                                 shared_p->name, shared_p->available,
118                                 shared_p->used,
119                                 (float) (100 * shared_p->used) /
120                                 shared_p->available, shared_p->touched,
121                                 shared_p->touched + shared_p->used,
122                                 (float) (100 *
123                                          (shared_p->touched +
124                                           shared_p->used)) /
125                                 shared_p->available);
126                         if (0 < num_backups) {
127                                 fprintf(outfile, "%7lu %8.3f",
128                                         shared_p->backups,
129                                         (float) (100 * shared_p->backups) /
130                                         shared_p->available);
131                         }
132
133                         fprintf(outfile, "\n");
134                 }
135         }
136         if (config.output_limit[1] & output_limit_bit_2
137             && config.output_limit[0] & output_limit_bit_3) {
138                 fprintf(outfile, "\n");
139         }
140         if (config.output_limit[0] & output_limit_bit_3) {
141                 fprintf(outfile, "Sum of all ranges:\n");
142                 fprintf(outfile,
143                         "name                   max   cur     percent  touch    t+c  t+c perc");
144
145                 if (0 < num_backups) {
146                         fprintf(outfile, "     bu  bu perc");
147                 }
148                 fprintf(outfile, "\n");
149         }
150         if (config.output_limit[1] & output_limit_bit_3) {
151                 fprintf(outfile, "%-20s %5lu %5lu %10.3f %7lu %6lu %9.3f",
152                         shared_networks->name,
153                         shared_networks->available,
154                         shared_networks->used,
155                         (float) (100 * shared_networks->used) /
156                         shared_networks->available,
157                         shared_networks->touched,
158                         shared_networks->touched + shared_networks->used,
159                         (float) (100 *
160                                  (shared_networks->touched +
161                                   shared_networks->used)) /
162                         shared_networks->available);
163
164                 if (0 < num_backups) {
165                         fprintf(outfile, "%7lu %8.3f",
166                                 shared_networks->backups,
167                                 (float) (100 * shared_networks->backups) /
168                                 shared_networks->available);
169                 }
170                 fprintf(outfile, "\n");
171         }
172         if (outfile == stdout) {
173                 ret = fflush(stdout);
174                 if (ret) {
175                         warn("output_txt: fflush");
176                 }
177         } else {
178                 ret = fclose(outfile);
179                 if (ret) {
180                         warn("output_txt: fclose");
181                 }
182         }
183
184         return 0;
185 }
186
187 int output_xml(void)
188 {
189         unsigned int i;
190         struct in_addr first, last;
191         struct range_t *range_p;
192         struct shared_network_t *shared_p;
193         struct macaddr_t *macaddr_p;
194         int ret;
195         FILE *outfile;
196
197         if (config.output_file[0]) {
198                 outfile = fopen(config.output_file, "w+");
199                 if (outfile == NULL) {
200                         err(EXIT_FAILURE, "output_xml: %s",
201                             config.output_file);
202                 }
203         } else {
204                 outfile = stdout;
205         }
206
207         range_p = ranges;
208         shared_p = shared_networks;
209
210         fprintf(outfile, "<dhcpstatus>\n");
211
212         if (macaddr != NULL) {
213                 for (macaddr_p = macaddr; macaddr_p->next != NULL;
214                      macaddr_p = macaddr_p->next) {
215                         fprintf(outfile,
216                                 "<active_lease>\n\t<ip>%s</ip>\n\t<macaddress>%s</macaddress>\n</active_lease>\n",
217                                 macaddr_p->ip, macaddr_p->ethernet);
218                 }
219         }
220
221         if (config.output_limit[1] & output_limit_bit_1) {
222                 for (i = 0; i < num_ranges; i++) {
223                         first.s_addr = ntohl(range_p->first_ip + 1);
224                         last.s_addr = ntohl(range_p->last_ip - 1);
225                         fprintf(outfile, "<subnet>\n");
226                         if (range_p->shared_net) {
227                                 fprintf(outfile,
228                                         "\t<location>%s</location>\n",
229                                         range_p->shared_net->name);
230                         } else {
231                                 fprintf(outfile,
232                                         "\t<location></location>\n");
233                         }
234
235                         fprintf(outfile, "\t<network></network>\n");
236                         fprintf(outfile, "\t<netmask></netmask>\n");
237                         fprintf(outfile, "\t<range>%s ", inet_ntoa(first));
238                         fprintf(outfile, "- %s</range>\n",
239                                 inet_ntoa(last));
240                         fprintf(outfile, "\t<gateway></gateway>\n");
241                         fprintf(outfile, "\t<defined>%lu</defined>\n",
242                                 range_p->last_ip - range_p->first_ip - 1);
243                         fprintf(outfile, "\t<used>%lu</used>\n",
244                                 range_p->count);
245                         fprintf(outfile, "\t<free>%lu</free>\n",
246                                 range_p->last_ip - range_p->first_ip - 1 -
247                                 range_p->count);
248                         range_p++;
249                         fprintf(outfile, "</subnet>\n");
250                 }
251         }
252
253         if (config.output_limit[1] & output_limit_bit_2) {
254                 for (i = 0; i < num_shared_networks; i++) {
255                         shared_p++;
256                         fprintf(outfile, "<shared-network>\n");
257                         fprintf(outfile, "\t<location>%s</location>\n",
258                                 shared_p->name);
259                         fprintf(outfile, "\t<defined>%lu</defined>\n",
260                                 shared_p->available);
261                         fprintf(outfile, "\t<used>%lu</used>\n",
262                                 shared_p->used);
263                         fprintf(outfile, "\t<free>%lu</free>\n",
264                                 shared_p->available - shared_p->used);
265                         fprintf(outfile, "</shared-network>\n");
266                 }
267         }
268
269         if (config.output_limit[0] & output_limit_bit_3) {
270                 fprintf(outfile, "<summary>\n");
271                 fprintf(outfile, "\t<location>%s</location>\n",
272                         shared_networks->name);
273                 fprintf(outfile, "\t<defined>%lu</defined>\n",
274                         shared_networks->available);
275                 fprintf(outfile, "\t<used>%lu</used>\n",
276                         shared_networks->used);
277                 fprintf(outfile, "\t<free>%lu</free>\n",
278                         shared_networks->available -
279                         shared_networks->used);
280                 fprintf(outfile, "</summary>\n");
281         }
282
283         fprintf(outfile, "</dhcpstatus>\n");
284         if (outfile == stdout) {
285                 ret = fflush(stdout);
286                 if (ret) {
287                         warn("output_xml: fflush");
288                 }
289         } else {
290                 ret = fclose(outfile);
291                 if (ret) {
292                         warn("output_xml: fclose");
293                 }
294         }
295
296         return 0;
297 }
298
299 void html_header(FILE * f)
300 {
301         fprintf(f,
302                 "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \n");
303         fprintf(f, "  \"http://www.w3.org/TR/html4/strict.dtd\">\n");
304         fprintf(f, "<html>\n");
305         fprintf(f, "<head>\n");
306         fprintf(f, "<meta http-equiv=\"Content-Type\" ");
307         fprintf(f, "content=\"text/html; charset=iso-8859-1\">\n");
308         fprintf(f, "  <title>ISC dhcpd stats</title>\n");
309         fprintf(f, "  <style  TYPE=\"text/css\">\n");
310         fprintf(f, "  <!--\n");
311         fprintf(f, "    table.dhcpd-pools {\n");
312         fprintf(f, "      color: black;\n");
313         fprintf(f, "      vertical-align: middle;\n");
314         fprintf(f, "      text-align: center;\n");
315         fprintf(f, "    }\n");
316         fprintf(f, "    table.dhcpd-pools th.section {\n");
317         fprintf(f, "      color: black;\n");
318         fprintf(f, "      font-size: large;\n");
319         fprintf(f, "      vertical-align: middle;\n");
320         fprintf(f, "      text-align: left;\n");
321         fprintf(f, "    }\n");
322         fprintf(f, "    table.dhcpd-pools th.calign {\n");
323         fprintf(f, "      color: black;\n");
324         fprintf(f, "      vertical-align: middle;\n");
325         fprintf(f, "      text-align: center;\n");
326         fprintf(f, "      text-decoration: underline;\n");
327         fprintf(f, "    }\n");
328         fprintf(f, "    table.dhcpd-pools th.ralign {\n");
329         fprintf(f, "      color: black;\n");
330         fprintf(f, "      vertical-align: middle;\n");
331         fprintf(f, "      text-align: right;\n");
332         fprintf(f, "      text-decoration: underline;\n");
333         fprintf(f, "    }\n");
334         fprintf(f, "    table.dhcpd-pools td.calign {\n");
335         fprintf(f, "      color: black;\n");
336         fprintf(f, "      vertical-align: middle;\n");
337         fprintf(f, "      text-align: center;\n");
338         fprintf(f, "    }\n");
339         fprintf(f, "    table.dhcpd-pools td.ralign {\n");
340         fprintf(f, "      color: black;\n");
341         fprintf(f, "      vertical-align: middle;\n");
342         fprintf(f, "      text-align: right;\n");
343         fprintf(f, "    }\n");
344         fprintf(f, "    p.created {\n");
345         fprintf(f, "      font-size: small;\n");
346         fprintf(f, "      color: grey;\n");
347         fprintf(f, "    }\n");
348         fprintf(f, "    p.updated {\n");
349         fprintf(f, "      font-size: small;\n");
350         fprintf(f, "      color: grey;\n");
351         fprintf(f, "      font-style: italic;\n");
352         fprintf(f, "    }\n");
353         fprintf(f, "  -->\n");
354         fprintf(f, "  </style>\n");
355         fprintf(f, "</head>\n");
356         fprintf(f, "<body>\n");
357 }
358
359 void html_footer(FILE * f)
360 {
361         fprintf(f, "<p><br></p>\n");
362         fprintf(f, "<hr>\n");
363         fprintf(f, "<p class=created>\nData generated by ");
364         fprintf(f, "<a href=\"%s\">", PACKAGE_URL);
365         fprintf(f, "dhcpd-pools</a>.\n</p>\n");
366         fprintf(f, "<p class=updated>\n");
367         fprintf(f, "<script type=\"text/javascript\">\n");
368         fprintf(f, "  document.write(\"Last Updated On \" + ");
369         fprintf(f, "document.lastModified + \".\")\n");
370         fprintf(f, "</script>\n<br>\n</p>\n");
371         fprintf(f, "</body>\n");
372         fprintf(f, "</html>\n");
373 }
374
375 void newrow(FILE * f)
376 {
377         fprintf(f, "<tr>\n");
378 }
379
380 void endrow(FILE * f)
381 {
382         fprintf(f, "</tr>\n\n");
383 }
384
385 void output_line(FILE * f, char *type, char *class, char *text)
386 {
387         fprintf(f, "  <%s class=%s>%s</%s>\n", type, class, text, type);
388 }
389
390 void output_long(FILE * f, char *type, unsigned long unlong)
391 {
392         fprintf(f, "  <%s class=ralign>%lu</%s>\n", type, unlong, type);
393 }
394
395 void output_float(FILE * f, char *type, float fl)
396 {
397         fprintf(f, "  <%s class=ralign>%.3f</%s>\n", type, fl, type);
398 }
399
400 void table_start(FILE * f)
401 {
402         fprintf(f, "<table width=\"75%%\" ");
403         fprintf(f, "class=\"dhcpd-pools\" ");
404         fprintf(f, "summary=\"ISC dhcpd pool usage report\">\n");
405 }
406
407 void table_end(FILE * f)
408 {
409         fprintf(f, "</table>\n");
410 }
411
412 void newsection(FILE * f, char *title)
413 {
414         newrow(f);
415         output_line(f, "td", "calign", "&nbsp;");
416         endrow(f);
417         newrow(f);
418         output_line(f, "th", "section", title);
419         endrow(f);
420 }
421
422 int output_html(void)
423 {
424         unsigned int i;
425         struct in_addr first, last;
426         struct range_t *range_p;
427         struct shared_network_t *shared_p;
428         int ret;
429         FILE *outfile;
430         if (config.output_file[0]) {
431                 outfile = fopen(config.output_file, "w+");
432                 if (outfile == NULL) {
433                         err(EXIT_FAILURE, "output_html: %s",
434                             config.output_file);
435                 }
436         } else {
437                 outfile = stdout;
438         }
439
440         range_p = ranges;
441         shared_p = shared_networks;
442         if (fullhtml) {
443                 html_header(outfile);
444         }
445         table_start(outfile);
446         if (config.output_limit[0] & output_limit_bit_1) {
447                 newsection(outfile, "Ranges:");
448                 newrow(outfile);
449                 output_line(outfile, "th", "calign", "shared net name");
450                 output_line(outfile, "th", "calign", "first ip");
451                 output_line(outfile, "th", "calign", "last ip");
452                 output_line(outfile, "th", "ralign", "max");
453                 output_line(outfile, "th", "ralign", "cur");
454                 output_line(outfile, "th", "ralign", "percent");
455                 output_line(outfile, "th", "ralign", "touch");
456                 output_line(outfile, "th", "ralign", "t+c");
457                 output_line(outfile, "th", "ralign", "t+c perc");
458                 if (0 < num_backups) {
459                         output_line(outfile, "th", "ralign", "bu");
460                         output_line(outfile, "th", "ralign", "bu perc");
461                 }
462                 endrow(outfile);
463         }
464         if (config.output_limit[1] & output_limit_bit_1) {
465                 for (i = 0; i < num_ranges; i++) {
466                         first.s_addr = ntohl(range_p->first_ip + 1);
467                         last.s_addr = ntohl(range_p->last_ip - 1);
468                         newrow(outfile);
469                         if (range_p->shared_net) {
470                                 output_line(outfile, "td", "calign",
471                                             range_p->shared_net->name);
472                         } else {
473                                 output_line(outfile, "td", "calign",
474                                             "not_defined");
475                         }
476                         output_line(outfile, "td", "calign",
477                                     inet_ntoa(first));
478                         output_line(outfile, "td", "calign",
479                                     inet_ntoa(last));
480                         output_long(outfile, "td",
481                                     range_p->last_ip - range_p->first_ip -
482                                     1);
483                         output_long(outfile, "td", range_p->count);
484                         output_float(outfile, "td",
485                                      (float) (100 * range_p->count) /
486                                      (range_p->last_ip -
487                                       range_p->first_ip - 1));
488                         output_long(outfile, "td", range_p->touched);
489                         output_long(outfile, "td",
490                                     range_p->touched + range_p->count);
491                         output_float(outfile, "td",
492                                      (float) (100 *
493                                               (range_p->touched +
494                                                range_p->count)) /
495                                      (range_p->last_ip -
496                                       range_p->first_ip - 1));
497                         if (0 < num_backups) {
498                                 output_long(outfile, "td",
499                                             range_p->backups);
500                                 output_float(outfile, "td",
501                                              (float) (100 *
502                                                       range_p->backups) /
503                                              (range_p->last_ip -
504                                               range_p->first_ip - 1));
505                         }
506                         endrow(outfile);
507                         range_p++;
508                 }
509         }
510         table_end(outfile);
511         table_start(outfile);
512         if (config.output_limit[0] & output_limit_bit_2) {
513                 newsection(outfile, "Shared networks:");
514                 newrow(outfile);
515                 output_line(outfile, "th", "calign", "name");
516                 output_line(outfile, "th", "ralign", "max");
517                 output_line(outfile, "th", "ralign", "cur");
518                 output_line(outfile, "th", "ralign", "percent");
519                 output_line(outfile, "th", "ralign", "touch");
520                 output_line(outfile, "th", "ralign", "t+c");
521                 output_line(outfile, "th", "ralign", "t+c perc");
522                 if (0 < num_backups) {
523                         output_line(outfile, "th", "ralign", "bu");
524                         output_line(outfile, "th", "ralign", "bu perc");
525                 }
526                 endrow(outfile);
527         }
528         if (config.output_limit[1] & output_limit_bit_2) {
529                 for (i = 0; i < num_shared_networks; i++) {
530                         shared_p++;
531                         newrow(outfile);
532                         output_line(outfile, "td", "calign",
533                                     shared_p->name);
534                         output_long(outfile, "td", shared_p->available);
535                         output_long(outfile, "td", shared_p->used);
536                         output_float(outfile, "td",
537                                      (float) (100 * shared_p->used) /
538                                      shared_p->available);
539                         output_long(outfile, "td", shared_p->touched);
540                         output_long(outfile, "td",
541                                     shared_p->touched + shared_p->used);
542                         output_float(outfile, "td",
543                                      (float) (100 *
544                                               (shared_p->touched +
545                                                shared_p->used)) /
546                                      shared_p->available);
547                         if (0 < num_backups) {
548                                 output_long(outfile, "td",
549                                             shared_p->backups);
550                                 output_float(outfile, "td",
551                                              (float) (100 *
552                                                       shared_p->backups) /
553                                              shared_p->available);
554                         }
555
556                         endrow(outfile);
557                 }
558         }
559         if (config.output_limit[0] & output_limit_bit_3) {
560                 newsection(outfile, "Sum of all ranges:");
561                 newrow(outfile);
562                 output_line(outfile, "th", "calign", "name");
563                 output_line(outfile, "th", "ralign", "max");
564                 output_line(outfile, "th", "ralign", "cur");
565                 output_line(outfile, "th", "ralign", "percent");
566                 output_line(outfile, "th", "ralign", "touch");
567                 output_line(outfile, "th", "ralign", "t+c");
568                 output_line(outfile, "th", "ralign", "t+c perc");
569                 if (0 < num_backups) {
570                         output_line(outfile, "th", "ralign", "bu");
571                         output_line(outfile, "th", "ralign", "bu perc");
572                 }
573
574                 endrow(outfile);
575         }
576         if (config.output_limit[1] & output_limit_bit_3) {
577                 newrow(outfile);
578                 output_line(outfile, "td", "calign",
579                             shared_networks->name);
580                 output_long(outfile, "td", shared_networks->available);
581                 output_long(outfile, "td", shared_networks->used);
582                 output_float(outfile, "td",
583                              (float) (100 * shared_networks->used) /
584                              shared_networks->available);
585                 output_long(outfile, "td", shared_networks->touched);
586                 output_long(outfile, "td",
587                             shared_networks->touched +
588                             shared_networks->used);
589                 output_float(outfile, "td",
590                              (float) (100 *
591                                       (shared_networks->touched +
592                                        shared_networks->used)) /
593                              shared_networks->available);
594                 if (0 < num_backups) {
595                         output_long(outfile, "td",
596                                     shared_networks->backups);
597                         output_float(outfile, "td",
598                                      (float) (100 *
599                                               shared_networks->backups) /
600                                      shared_networks->available);
601                 }
602                 endrow(outfile);
603         }
604         table_end(outfile);
605         if (fullhtml) {
606                 html_footer(outfile);
607         }
608         if (outfile == stdout) {
609                 ret = fflush(stdout);
610                 if (ret) {
611                         warn("output_html: fflush");
612                 }
613         } else {
614                 ret = fclose(outfile);
615                 if (ret) {
616                         warn("output_html: fclose");
617                 }
618         }
619         return 0;
620 }
621
622 int output_csv(void)
623 {
624         unsigned int i;
625         struct in_addr first, last;
626         struct range_t *range_p;
627         struct shared_network_t *shared_p;
628         FILE *outfile;
629         int ret;
630         if (config.output_file[0]) {
631                 outfile = fopen(config.output_file, "w+");
632                 if (outfile == NULL) {
633                         err(EXIT_FAILURE, "output_csv: %s",
634                             config.output_file);
635                 }
636         } else {
637                 outfile = stdout;
638         }
639
640         range_p = ranges;
641         shared_p = shared_networks;
642         if (config.output_limit[0] & output_limit_bit_1) {
643                 fprintf(outfile, "\"Ranges:\"\n");
644                 fprintf
645                     (outfile,
646                      "\"shared net name\",\"first ip\",\"last ip\",\"max\",\"cur\",\"percent\",\"touch\",\"t+c\",\"t+c perc\"");
647                 if (0 < num_backups) {
648                         fprintf(outfile, ",\"bu\",\"bu perc\"");
649                 }
650                 fprintf(outfile, "\n");
651         }
652         if (config.output_limit[1] & output_limit_bit_1) {
653                 for (i = 0; i < num_ranges; i++) {
654                         first.s_addr = ntohl(range_p->first_ip + 1);
655                         last.s_addr = ntohl(range_p->last_ip - 1);
656                         if (range_p->shared_net) {
657                                 fprintf(outfile, "\"%s\",",
658                                         range_p->shared_net->name);
659                         } else {
660                                 fprintf(outfile, "\"not_defined\",");
661                         }
662                         fprintf(outfile, "\"%s\",", inet_ntoa(first));
663                         fprintf(outfile,
664                                 "\"%s\",\"%lu\",\"%lu\",\"%.3f\",\"%lu\",\"%lu\",\"%.3f\"",
665                                 inet_ntoa(last),
666                                 range_p->last_ip - range_p->first_ip - 1,
667                                 range_p->count,
668                                 (float) (100 * range_p->count) /
669                                 (range_p->last_ip - range_p->first_ip - 1),
670                                 range_p->touched,
671                                 range_p->touched + range_p->count,
672                                 (float) (100 *
673                                          (range_p->touched +
674                                           range_p->count)) /
675                                 (range_p->last_ip - range_p->first_ip -
676                                  1));
677                         if (0 < num_backups) {
678                                 fprintf(outfile, ",\"%lu\",\"%.3f\"",
679                                         range_p->backups,
680                                         (float) (100 * range_p->backups) /
681                                         (range_p->last_ip -
682                                          range_p->first_ip - 1));
683                         }
684
685                         fprintf(outfile, "\n");
686                         range_p++;
687                 }
688                 fprintf(outfile, "\n");
689         }
690         if (config.output_limit[0] & output_limit_bit_2) {
691                 fprintf(outfile, "\"Shared networks:\"\n");
692                 fprintf(outfile,
693                         "\"name\",\"max\",\"cur\",\"percent\",\"touch\",\"t+c\",\"t+c perc\"");
694                 if (0 < num_backups) {
695                         fprintf(outfile, ",\"bu\",\"bu perc\"");
696                 }
697                 fprintf(outfile, "\n");
698         }
699         if (config.output_limit[1] & output_limit_bit_2) {
700
701                 for (i = 0; i < num_shared_networks; i++) {
702                         shared_p++;
703                         fprintf(outfile,
704                                 "\"%s\",\"%lu\",\"%lu\",\"%.3f\",\"%lu\",\"%lu\",\"%.3f\"",
705                                 shared_p->name, shared_p->available,
706                                 shared_p->used,
707                                 (float) (100 * shared_p->used) /
708                                 shared_p->available, shared_p->touched,
709                                 shared_p->touched + shared_p->used,
710                                 (float) (100 *
711                                          (shared_p->touched +
712                                           shared_p->used)) /
713                                 shared_p->available);
714                         if (0 < num_backups) {
715                                 fprintf(outfile, ",\"%lu\",\"%.3f\"",
716                                         shared_p->backups,
717                                         (float) (100 * shared_p->backups) /
718                                         shared_p->available);
719                         }
720
721                         fprintf(outfile, "\n");
722                 }
723                 fprintf(outfile, "\n");
724         }
725         if (config.output_limit[0] & output_limit_bit_3) {
726                 fprintf(outfile, "\"Sum of all ranges:\"\n");
727                 fprintf(outfile,
728                         "\"name\",\"max\",\"cur\",\"percent\",\"touch\",\"t+c\",\"t+c perc\"");
729                 if (0 < num_backups) {
730                         fprintf(outfile, ",\"bu\",\"bu perc\"");
731                 }
732                 fprintf(outfile, "\n");
733         }
734         if (config.output_limit[1] & output_limit_bit_3) {
735
736                 fprintf(outfile,
737                         "\"%s\",\"%lu\",\"%lu\",\"%.3f\",\"%lu\",\"%lu\",\"%.3f\"",
738                         shared_networks->name, shared_networks->available,
739                         shared_networks->used,
740                         (float) (100 * shared_networks->used) /
741                         shared_networks->available,
742                         shared_networks->touched,
743                         shared_networks->touched + shared_networks->used,
744                         (float) (100 *
745                                  (shared_networks->touched +
746                                   shared_networks->used)) /
747                         shared_networks->available);
748                 if (0 < num_backups) {
749                         fprintf(outfile, "%7lu %8.3f",
750                                 shared_networks->backups,
751                                 (float) (100 * shared_networks->backups) /
752                                 shared_networks->available);
753                 }
754                 fprintf(outfile, "\n");
755         }
756         if (outfile == stdout) {
757                 ret = fflush(stdout);
758                 if (ret) {
759                         warn("output_cvs: fflush");
760                 }
761
762         } else {
763                 ret = fclose(outfile);
764                 if (ret) {
765                         warn("output_cvs: fclose");
766                 }
767
768         }
769         return 0;
770 }