[1] | 1 | /* SAMHAIN file system integrity testing */
|
---|
| 2 | /* Copyright (C) 1999, 2000 Rainer Wichmann */
|
---|
| 3 | /* */
|
---|
| 4 | /* This program is free software; you can redistribute it */
|
---|
| 5 | /* and/or modify */
|
---|
| 6 | /* it under the terms of the GNU General Public License as */
|
---|
| 7 | /* published by */
|
---|
| 8 | /* the Free Software Foundation; either version 2 of the License, or */
|
---|
| 9 | /* (at your option) any later version. */
|
---|
| 10 | /* */
|
---|
| 11 | /* This program is distributed in the hope that it will be useful, */
|
---|
| 12 | /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
|
---|
| 13 | /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
|
---|
| 14 | /* GNU General Public License for more details. */
|
---|
| 15 | /* */
|
---|
| 16 | /* You should have received a copy of the GNU General Public License */
|
---|
| 17 | /* along with this program; if not, write to the Free Software */
|
---|
| 18 | /* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
---|
| 19 |
|
---|
| 20 | #include "config_xor.h"
|
---|
| 21 |
|
---|
| 22 | #include <string.h>
|
---|
| 23 | #include <stdio.h>
|
---|
| 24 | #include <stdlib.h>
|
---|
| 25 |
|
---|
| 26 | #if TIME_WITH_SYS_TIME
|
---|
| 27 | #include <sys/time.h>
|
---|
| 28 | #include <time.h>
|
---|
| 29 | #else
|
---|
| 30 | #if HAVE_SYS_TIME_H
|
---|
| 31 | #include <sys/time.h>
|
---|
| 32 | #else
|
---|
| 33 | #include <time.h>
|
---|
| 34 | #endif
|
---|
| 35 | #endif
|
---|
[131] | 36 | #include <unistd.h>
|
---|
[1] | 37 |
|
---|
| 38 |
|
---|
| 39 | #ifdef SH_WITH_SERVER
|
---|
| 40 |
|
---|
| 41 |
|
---|
| 42 | #include "samhain.h"
|
---|
| 43 | #include "sh_forward.h"
|
---|
| 44 | #include "sh_error.h"
|
---|
| 45 | #include "sh_unix.h"
|
---|
| 46 | #include "sh_utils.h"
|
---|
| 47 | #include "sh_html.h"
|
---|
| 48 |
|
---|
| 49 | #undef FIL__
|
---|
| 50 | #define FIL__ _("sh_html.c")
|
---|
| 51 |
|
---|
| 52 |
|
---|
| 53 | s_stat server_status;
|
---|
| 54 |
|
---|
| 55 |
|
---|
| 56 |
|
---|
| 57 | static
|
---|
| 58 | char * replace_stat (char * line)
|
---|
| 59 | {
|
---|
| 60 | st_format rep_serv_tab[] = {
|
---|
| 61 | { 'T', S_FMT_TIME, 0, 0, NULL},
|
---|
| 62 | { 'S', S_FMT_TIME, 0, 0, NULL},
|
---|
| 63 | { 'L', S_FMT_TIME, 0, 0, NULL},
|
---|
| 64 | { 'O', S_FMT_ULONG, 0, 0, NULL},
|
---|
| 65 | { 'A', S_FMT_ULONG, 0, 0, NULL},
|
---|
| 66 | { 'M', S_FMT_ULONG, 0, 0, NULL},
|
---|
| 67 | {'\0', S_FMT_ULONG, 0, 0, NULL},
|
---|
| 68 | };
|
---|
| 69 |
|
---|
| 70 | rep_serv_tab[0].data_ulong = (unsigned long) time(NULL);
|
---|
| 71 | rep_serv_tab[1].data_ulong = server_status.start;
|
---|
| 72 | rep_serv_tab[2].data_ulong = server_status.last;
|
---|
| 73 | rep_serv_tab[3].data_ulong = server_status.conn_open;
|
---|
| 74 | rep_serv_tab[4].data_ulong = server_status.conn_total;
|
---|
| 75 | rep_serv_tab[5].data_ulong = server_status.conn_max;
|
---|
| 76 |
|
---|
| 77 | return (sh_util_formatted(line, rep_serv_tab));
|
---|
| 78 | }
|
---|
| 79 |
|
---|
| 80 |
|
---|
| 81 | static
|
---|
| 82 | int sh_html_head(SL_TICKET ticket)
|
---|
| 83 | {
|
---|
| 84 | long status = SL_ENONE;
|
---|
| 85 | SL_TICKET fd = (-1);
|
---|
| 86 | char line[512];
|
---|
| 87 | char endhead[512];
|
---|
| 88 | char outline[1024];
|
---|
| 89 | char ts1[81];
|
---|
| 90 | char ts2[81];
|
---|
| 91 | time_t now;
|
---|
| 92 | struct tm * time_ptr;
|
---|
[131] | 93 | #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
|
---|
| 94 | struct tm time_tm;
|
---|
| 95 | #endif
|
---|
[1] | 96 |
|
---|
| 97 | char * formatted;
|
---|
| 98 | char * qstr;
|
---|
| 99 |
|
---|
| 100 | char * p;
|
---|
| 101 |
|
---|
| 102 | SL_ENTER(_("sh_html_head"));
|
---|
| 103 |
|
---|
| 104 | p = sh_util_strconcat(DEFAULT_DATAROOT, _("/head.html"), NULL);
|
---|
| 105 |
|
---|
| 106 | if (p)
|
---|
| 107 | {
|
---|
[248] | 108 | fd = sl_open_read (FIL__, __LINE__, p, SL_YESPRIV);
|
---|
[1] | 109 | SH_FREE(p);
|
---|
| 110 | }
|
---|
| 111 |
|
---|
| 112 | if (!SL_ISERROR(fd))
|
---|
| 113 | {
|
---|
[34] | 114 | while (!SL_ISERROR(status) && sh_unix_getline (fd, line, sizeof(line)) > 0)
|
---|
[1] | 115 | {
|
---|
| 116 | formatted = replace_stat (line);
|
---|
| 117 | if (formatted)
|
---|
| 118 | {
|
---|
| 119 | status = sl_write_line (ticket, formatted, sl_strlen(formatted));
|
---|
| 120 | SH_FREE(formatted);
|
---|
| 121 | }
|
---|
| 122 | }
|
---|
| 123 | sl_close(fd);
|
---|
| 124 | }
|
---|
| 125 | else
|
---|
| 126 | {
|
---|
[34] | 127 | qstr = sh_util_basename(DEFAULT_HTML_FILE);
|
---|
[1] | 128 | if (qstr != NULL)
|
---|
| 129 | {
|
---|
| 130 | sl_snprintf(endhead, 511,
|
---|
| 131 | _("<meta http-equiv=%crefresh%c content=%c120; URL=./%s%c></HEAD><BODY>"),
|
---|
| 132 | 34, 34, 34, qstr, 34);
|
---|
| 133 | SH_FREE(qstr);
|
---|
| 134 | }
|
---|
| 135 | else
|
---|
| 136 | {
|
---|
| 137 | sl_snprintf(endhead, 511, _("</HEAD><BODY>"));
|
---|
| 138 | }
|
---|
| 139 |
|
---|
| 140 | status =
|
---|
| 141 | sl_write_line (ticket,
|
---|
| 142 | _("<HTML><HEAD><TITLE>Report</TITLE>"),
|
---|
| 143 | sizeof("<HTML><HEAD><TITLE>Report</TITLE>")-1);
|
---|
| 144 | if (!SL_ISERROR(status))
|
---|
| 145 | status =
|
---|
| 146 | sl_write_line (ticket, endhead, strlen(endhead));
|
---|
| 147 | if (!SL_ISERROR(status))
|
---|
| 148 | status =
|
---|
| 149 | sl_write_line (ticket,
|
---|
| 150 | _("<H1>Samhain Server Report</H1>"),
|
---|
| 151 | sizeof("<H1>Samhain Server Report</H1>")-1);
|
---|
| 152 | if (!SL_ISERROR(status))
|
---|
| 153 | {
|
---|
[131] | 154 | #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
|
---|
| 155 | time_ptr = localtime_r (&(server_status.start), &time_tm);
|
---|
| 156 | #else
|
---|
[1] | 157 | time_ptr = localtime (&(server_status.start));
|
---|
[131] | 158 | #endif
|
---|
[1] | 159 | if (time_ptr != NULL)
|
---|
[383] | 160 | strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
|
---|
[1] | 161 | now = time(NULL);
|
---|
[131] | 162 | #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
|
---|
| 163 | time_ptr = localtime_r (&now, &time_tm);
|
---|
| 164 | #else
|
---|
[1] | 165 | time_ptr = localtime (&now);
|
---|
[131] | 166 | #endif
|
---|
[1] | 167 | if (time_ptr != NULL)
|
---|
[383] | 168 | strftime (ts2, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
|
---|
[1] | 169 |
|
---|
| 170 | sl_snprintf(outline, 1023,
|
---|
| 171 | _("<p>Time:<BR>Now: %s<BR>Start: %s</p>"),
|
---|
| 172 | ts2, ts1);
|
---|
| 173 | status =
|
---|
| 174 | sl_write_line (ticket, outline, sl_strlen(outline));
|
---|
| 175 | }
|
---|
| 176 | if (!SL_ISERROR(status))
|
---|
| 177 | {
|
---|
| 178 | sl_snprintf(outline, 1023,
|
---|
| 179 | _("<p>Connections (max. %d simultaneous):"\
|
---|
| 180 | "<BR>Now: %d<BR>Total: %ld</p>"),
|
---|
| 181 | server_status.conn_max,
|
---|
| 182 | server_status.conn_open,
|
---|
| 183 | server_status.conn_total);
|
---|
| 184 | status =
|
---|
| 185 | sl_write_line (ticket, outline, sl_strlen(outline));
|
---|
| 186 | if (server_status.last > (time_t) 0)
|
---|
| 187 | {
|
---|
[131] | 188 | #if defined(HAVE_PTHREAD) && defined (_POSIX_THREAD_SAFE_FUNCTIONS) && defined(HAVE_LOCALTIME_R)
|
---|
| 189 | time_ptr = localtime_r (&(server_status.last), &time_tm);
|
---|
| 190 | #else
|
---|
[1] | 191 | time_ptr = localtime (&(server_status.last));
|
---|
[131] | 192 | #endif
|
---|
[1] | 193 | if (time_ptr != NULL)
|
---|
[383] | 194 | strftime (ts1, 80, _("%d-%m-%Y %H:%M:%S"), time_ptr);
|
---|
[1] | 195 | sl_snprintf(outline, 1023,
|
---|
| 196 | _("<p>Last connection at %s</p>"),
|
---|
| 197 | ts1);
|
---|
| 198 | status =
|
---|
| 199 | sl_write_line (ticket, outline, sl_strlen(outline));
|
---|
| 200 | }
|
---|
| 201 | }
|
---|
| 202 | if (!SL_ISERROR(status))
|
---|
| 203 | status =
|
---|
| 204 | sl_write_line (ticket,
|
---|
| 205 | _("<center><table cellpadding=5 cellspacing=2 border=2>"),
|
---|
| 206 | sizeof("<center><table cellpadding=5 cellspacing=2 border=2>")-1);
|
---|
| 207 | }
|
---|
| 208 |
|
---|
| 209 | if (SL_ISERROR(status))
|
---|
| 210 | SL_RETURN((-1), _("sh_html_head"));
|
---|
| 211 |
|
---|
| 212 | SL_RETURN((0), _("sh_html_head"));
|
---|
| 213 | }
|
---|
| 214 |
|
---|
| 215 | static
|
---|
| 216 | int sh_html_foot(SL_TICKET ticket)
|
---|
| 217 | {
|
---|
| 218 | long status = SL_ENONE;
|
---|
| 219 | SL_TICKET fd = (-1);
|
---|
| 220 | char line[512];
|
---|
| 221 | char * p;
|
---|
| 222 |
|
---|
| 223 | SL_ENTER(_("sh_html_foot"));
|
---|
| 224 |
|
---|
| 225 | p = sh_util_strconcat(DEFAULT_DATAROOT, _("/foot.html"), NULL);
|
---|
| 226 |
|
---|
| 227 | if (p)
|
---|
| 228 | {
|
---|
[248] | 229 | fd = sl_open_read (FIL__, __LINE__, p, SL_YESPRIV);
|
---|
[1] | 230 | SH_FREE(p);
|
---|
| 231 | }
|
---|
| 232 |
|
---|
| 233 | if (!SL_ISERROR(fd))
|
---|
| 234 | {
|
---|
[34] | 235 | while (!SL_ISERROR(status) && sh_unix_getline (fd, line, sizeof(line)) > 0)
|
---|
[1] | 236 | {
|
---|
| 237 | status = sl_write_line (ticket, line, sl_strlen(line));
|
---|
| 238 | }
|
---|
| 239 | sl_close(fd);
|
---|
| 240 | }
|
---|
| 241 | else
|
---|
| 242 | {
|
---|
| 243 | status = sl_write_line (ticket, _("</table></center></BODY></HTML>"),
|
---|
| 244 | sizeof("</table></center></BODY></HTML>")-1);
|
---|
| 245 | }
|
---|
| 246 | if (SL_ISERROR(status))
|
---|
| 247 | SL_RETURN((-1), _("sh_html_foot"));
|
---|
| 248 |
|
---|
| 249 | SL_RETURN((0), _("sh_html_foot"));
|
---|
| 250 | }
|
---|
| 251 |
|
---|
| 252 |
|
---|
| 253 | static
|
---|
| 254 | char * replace_tab (const char * line, char * host, char * status,
|
---|
| 255 | char * timestamp)
|
---|
| 256 | {
|
---|
| 257 | st_format rep_serv_tab[] = {
|
---|
| 258 | { 'H', S_FMT_STRING, 0, 0, NULL},
|
---|
| 259 | { 'S', S_FMT_STRING, 0, 0, NULL},
|
---|
| 260 | { 'T', S_FMT_STRING, 0, 0, NULL},
|
---|
| 261 | {'\0', S_FMT_ULONG, 0, 0, NULL},
|
---|
| 262 | };
|
---|
| 263 | char * p;
|
---|
| 264 |
|
---|
| 265 | SL_ENTER(_("replace_tab"));
|
---|
| 266 |
|
---|
| 267 | rep_serv_tab[0].data_str = host;
|
---|
| 268 | rep_serv_tab[1].data_str = status;
|
---|
| 269 | rep_serv_tab[2].data_str = timestamp;
|
---|
| 270 |
|
---|
| 271 | p = sh_util_formatted(line, rep_serv_tab);
|
---|
| 272 | SL_RETURN(p, _("replace_tab"));
|
---|
| 273 | }
|
---|
| 274 |
|
---|
| 275 | static char * entry_orig = NULL;
|
---|
| 276 | static size_t entry_size = 0;
|
---|
| 277 |
|
---|
| 278 | static
|
---|
[170] | 279 | int sh_html_get_entry (void)
|
---|
[1] | 280 | {
|
---|
| 281 | long retval = SL_ENONE;
|
---|
| 282 | SL_TICKET fd = (-1);
|
---|
| 283 | char line[512];
|
---|
| 284 | size_t line_size;
|
---|
| 285 | size_t add_size = 0;
|
---|
| 286 | char * p;
|
---|
| 287 |
|
---|
| 288 | SL_ENTER(_("sh_html_get_entry"));
|
---|
| 289 |
|
---|
| 290 | p = sh_util_strconcat(DEFAULT_DATAROOT, _("/entry.html"), NULL);
|
---|
| 291 |
|
---|
| 292 | entry_size = 0;
|
---|
| 293 | if (entry_orig != NULL)
|
---|
| 294 | {
|
---|
| 295 | free (entry_orig);
|
---|
| 296 | entry_orig = NULL;
|
---|
| 297 | entry_size = 0;
|
---|
| 298 | }
|
---|
| 299 |
|
---|
| 300 | if (p)
|
---|
| 301 | {
|
---|
[248] | 302 | fd = sl_open_read (FIL__, __LINE__, p, SL_YESPRIV);
|
---|
[1] | 303 | SH_FREE(p);
|
---|
| 304 | }
|
---|
| 305 | if (!SL_ISERROR(fd))
|
---|
| 306 | {
|
---|
[34] | 307 | while (!SL_ISERROR(retval) && sh_unix_getline (fd, line, sizeof(line)) > 0)
|
---|
[1] | 308 | {
|
---|
| 309 | line_size = sl_strlen(line);
|
---|
| 310 | add_size = 0;
|
---|
| 311 | if (entry_orig != NULL)
|
---|
| 312 | {
|
---|
[473] | 313 | char * ptr = realloc(entry_orig, /* free() ok */
|
---|
[22] | 314 | entry_size + line_size + 1);
|
---|
[473] | 315 | if (ptr) {
|
---|
| 316 | entry_orig = ptr;
|
---|
| 317 | add_size = line_size;
|
---|
| 318 | } else {
|
---|
| 319 | { free(entry_orig); entry_orig = NULL; }
|
---|
| 320 | }
|
---|
[1] | 321 | }
|
---|
| 322 | else
|
---|
| 323 | {
|
---|
[454] | 324 | entry_orig = calloc(1, line_size + 1); /* free() ok */
|
---|
[22] | 325 | if (entry_orig) { entry_orig[0] = '\0'; add_size = line_size; }
|
---|
[1] | 326 | }
|
---|
| 327 | if (!entry_orig)
|
---|
| 328 | {
|
---|
| 329 | entry_size = 0;
|
---|
[383] | 330 | /* add_size = 0; *//* never read */
|
---|
[1] | 331 | SL_RETURN( 0, _("sh_html_get_entry"));
|
---|
| 332 | }
|
---|
| 333 |
|
---|
[22] | 334 | sl_strlcat(&entry_orig[entry_size], line, line_size + 1);
|
---|
[1] | 335 | entry_size += add_size;
|
---|
[25] | 336 | SH_VALIDATE_EQ(entry_orig[entry_size], '\0');
|
---|
[1] | 337 | }
|
---|
| 338 | sl_close(fd);
|
---|
| 339 | }
|
---|
| 340 | SL_RETURN( entry_size, _("sh_html_get_entry"));
|
---|
| 341 | }
|
---|
| 342 |
|
---|
| 343 | static
|
---|
| 344 | int sh_html_entry (SL_TICKET ticket,
|
---|
| 345 | char * host, char * status, char * timestamp, int flag)
|
---|
| 346 | {
|
---|
| 347 | char outline[1024];
|
---|
| 348 | long retval = SL_ENONE;
|
---|
| 349 |
|
---|
| 350 | char * formatted;
|
---|
| 351 |
|
---|
| 352 | SL_ENTER(_("sh_html_entry"));
|
---|
| 353 |
|
---|
| 354 | if (entry_size > 0 && entry_orig != NULL)
|
---|
| 355 | {
|
---|
| 356 | formatted = replace_tab(entry_orig, host, status, timestamp);
|
---|
| 357 | if (formatted)
|
---|
| 358 | {
|
---|
| 359 | retval = sl_write_line (ticket, formatted, sl_strlen(formatted));
|
---|
| 360 | SH_FREE(formatted);
|
---|
| 361 | }
|
---|
| 362 | }
|
---|
| 363 | else
|
---|
| 364 | {
|
---|
| 365 | sl_snprintf(outline, 1023,
|
---|
| 366 | _("<tr><td>%s</td><td>%s</td><td>%s</td></tr>"),
|
---|
| 367 | host, status, timestamp);
|
---|
| 368 | retval = sl_write_line (ticket, outline, sl_strlen(outline));
|
---|
| 369 | }
|
---|
| 370 |
|
---|
| 371 | /* write a status line
|
---|
| 372 | */
|
---|
| 373 | if ((flag == 1) && (!SL_ISERROR(retval)))
|
---|
| 374 | {
|
---|
| 375 | sl_snprintf(outline, 1023,
|
---|
| 376 | _("<!-- \n[STATUS:] %s %s %s\n -->"),
|
---|
| 377 | host, status, timestamp);
|
---|
| 378 | retval = sl_write_line (ticket, outline, sl_strlen(outline));
|
---|
| 379 | }
|
---|
| 380 |
|
---|
| 381 | if (SL_ISERROR(retval))
|
---|
| 382 | SL_RETURN((-1), _("sh_html_entry"));
|
---|
| 383 |
|
---|
| 384 | SL_RETURN((0), _("sh_html_entry"));
|
---|
| 385 | }
|
---|
| 386 |
|
---|
| 387 | typedef struct _sort_arr {
|
---|
| 388 | char msg[TIM_MAX];
|
---|
| 389 | char tim[TIM_MAX];
|
---|
| 390 | } sort_arr;
|
---|
| 391 |
|
---|
| 392 | static sort_arr sort_stat[CLT_MAX];
|
---|
| 393 |
|
---|
| 394 | static
|
---|
| 395 | int comp_arr (const void * ao, const void * bo)
|
---|
| 396 | {
|
---|
[170] | 397 | const sort_arr * a;
|
---|
| 398 | const sort_arr * b;
|
---|
[1] | 399 |
|
---|
| 400 | if (ao == NULL && bo == NULL)
|
---|
| 401 | return 0;
|
---|
| 402 | else if (ao == NULL && bo != NULL)
|
---|
| 403 | return (-1);
|
---|
| 404 | else if (ao != NULL && bo == NULL)
|
---|
| 405 | return (1);
|
---|
| 406 |
|
---|
[170] | 407 | a = (const sort_arr *) ao;
|
---|
| 408 | b = (const sort_arr *) bo;
|
---|
[1] | 409 |
|
---|
| 410 | return ((-1) * sl_strcmp(a->tim, b->tim));
|
---|
| 411 | }
|
---|
| 412 |
|
---|
| 413 | static
|
---|
| 414 | int sh_html_print_one (SL_TICKET ticket, client_t * top)
|
---|
| 415 | {
|
---|
| 416 | int status;
|
---|
| 417 | int clt_status;
|
---|
| 418 | int i, n;
|
---|
| 419 |
|
---|
| 420 | SL_ENTER(_("sh_html_print_one"));
|
---|
| 421 |
|
---|
| 422 | if (top == NULL)
|
---|
| 423 | SL_RETURN((0), _("sh_html_print_one"));
|
---|
| 424 |
|
---|
| 425 | clt_status = top->status_now;
|
---|
| 426 | status = sh_html_entry (ticket,
|
---|
| 427 | top->hostname,
|
---|
| 428 | _(clt_stat[clt_status]),
|
---|
| 429 | top->timestamp[clt_status],
|
---|
| 430 | 1);
|
---|
| 431 |
|
---|
| 432 | n = 0;
|
---|
| 433 |
|
---|
| 434 | if (clt_status != CLT_INACTIVE)
|
---|
| 435 | {
|
---|
| 436 | for (i = 1; i < CLT_MAX; ++i)
|
---|
| 437 | {
|
---|
| 438 | if (top->status_arr[i] != CLT_INACTIVE)
|
---|
| 439 | {
|
---|
| 440 | clt_status = top->status_arr[i];
|
---|
| 441 | sl_strlcpy(sort_stat[n].msg, _(clt_stat[clt_status]), TIM_MAX);
|
---|
| 442 | sl_strlcpy(sort_stat[n].tim, top->timestamp[clt_status],TIM_MAX);
|
---|
| 443 | ++n;
|
---|
| 444 | }
|
---|
| 445 | }
|
---|
| 446 | }
|
---|
| 447 |
|
---|
| 448 | if (n > 0)
|
---|
| 449 | {
|
---|
| 450 | qsort(&(sort_stat[0]), n, sizeof(sort_arr), comp_arr);
|
---|
| 451 |
|
---|
| 452 | for (i = 1; i < n; ++i)
|
---|
| 453 | {
|
---|
| 454 | status = sh_html_entry (ticket,
|
---|
| 455 | " ",
|
---|
| 456 | sort_stat[i].msg,
|
---|
| 457 | sort_stat[i].tim,
|
---|
| 458 | 0);
|
---|
| 459 | }
|
---|
| 460 | }
|
---|
| 461 |
|
---|
| 462 | if (SL_ISERROR(status))
|
---|
| 463 | SL_RETURN((-1), _("sh_html_print_one"));
|
---|
| 464 |
|
---|
| 465 | SL_RETURN((0), _("sh_html_print_one"));
|
---|
| 466 | }
|
---|
| 467 |
|
---|
| 468 | #include "zAVLTree.h"
|
---|
| 469 |
|
---|
| 470 | int sh_html_write(void * inptr)
|
---|
| 471 | {
|
---|
| 472 | long fd;
|
---|
| 473 | zAVLCursor avlcursor;
|
---|
| 474 | client_t * item;
|
---|
| 475 | zAVLTree * top = (zAVLTree *) inptr;
|
---|
| 476 |
|
---|
| 477 | SL_ENTER(_("sh_html_write"));
|
---|
| 478 |
|
---|
| 479 | if (0 != (fd = tf_trust_check (DEFAULT_HTML_FILE, SL_YESPRIV)))
|
---|
| 480 | {
|
---|
| 481 | sh_error_handle((-1), FIL__, __LINE__, fd, MSG_E_TRUST,
|
---|
| 482 | (long) sh.effective.uid,
|
---|
| 483 | DEFAULT_HTML_FILE);
|
---|
| 484 | SL_RETURN((-1), _("sh_html_write"));
|
---|
| 485 | }
|
---|
| 486 |
|
---|
| 487 |
|
---|
[248] | 488 | fd = sl_open_write_trunc (FIL__, __LINE__, DEFAULT_HTML_FILE, SL_YESPRIV);
|
---|
[1] | 489 |
|
---|
| 490 | if (SL_ISERROR(fd))
|
---|
| 491 | {
|
---|
| 492 | sh_error_handle((-1), FIL__, __LINE__, fd, MSG_E_ACCESS,
|
---|
| 493 | (long) sh.effective.uid,
|
---|
| 494 | DEFAULT_HTML_FILE);
|
---|
| 495 | SL_RETURN((-1), _("sh_html_write"));
|
---|
| 496 | }
|
---|
| 497 |
|
---|
| 498 | sh_html_get_entry();
|
---|
| 499 |
|
---|
| 500 | sh_html_head(fd);
|
---|
| 501 | for (item = (client_t *) zAVLFirst(&avlcursor, top); item;
|
---|
| 502 | item = (client_t *) zAVLNext(&avlcursor))
|
---|
| 503 | sh_html_print_one (fd, item);
|
---|
| 504 | sh_html_foot(fd);
|
---|
| 505 | sl_close(fd);
|
---|
| 506 |
|
---|
| 507 | SL_RETURN((0), _("sh_html_write"));
|
---|
| 508 | }
|
---|
| 509 |
|
---|
[415] | 510 | int sh_html_zero()
|
---|
| 511 | {
|
---|
| 512 | long fd;
|
---|
| 513 |
|
---|
| 514 | SL_ENTER(_("sh_html_zero"));
|
---|
| 515 |
|
---|
| 516 | if (0 != (fd = tf_trust_check (DEFAULT_HTML_FILE, SL_YESPRIV)))
|
---|
| 517 | {
|
---|
| 518 | SL_RETURN((-1), _("sh_html_zero"));
|
---|
| 519 | }
|
---|
| 520 |
|
---|
| 521 | fd = sl_open_write_trunc (FIL__, __LINE__, DEFAULT_HTML_FILE, SL_YESPRIV);
|
---|
| 522 |
|
---|
| 523 | if (SL_ISERROR(fd))
|
---|
| 524 | {
|
---|
| 525 | SL_RETURN((-1), _("sh_html_zero"));
|
---|
| 526 | }
|
---|
| 527 |
|
---|
| 528 | sh_html_head(fd);
|
---|
| 529 | sh_html_foot(fd);
|
---|
| 530 |
|
---|
| 531 | sl_close(fd);
|
---|
| 532 |
|
---|
| 533 | SL_RETURN((0), _("sh_html_zero"));
|
---|
| 534 | }
|
---|
| 535 |
|
---|
[1] | 536 | /* SH_WITH_SERVER */
|
---|
| 537 | #endif
|
---|
| 538 |
|
---|
| 539 |
|
---|
| 540 |
|
---|
| 541 |
|
---|
| 542 |
|
---|
| 543 |
|
---|
| 544 |
|
---|
| 545 |
|
---|
| 546 |
|
---|
| 547 |
|
---|
| 548 |
|
---|
| 549 |
|
---|
| 550 |
|
---|
| 551 |
|
---|
| 552 |
|
---|