lib/util/debug.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Elrond               2002
   6    Copyright (C) Simo Sorce           2002
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "replace.h"
  23 #include <talloc.h>
  24 #include "system/filesys.h"
  25 #include "system/syslog.h"
  26 #include "system/locale.h"
  27 #include "time_basic.h"
  28 #include "close_low_fd.h"
  29 #include "memory.h"
  30 #include "util_strlist.h" /* LIST_SEP */
  31 #include "blocking.h"
  32 #include "debug.h"
  33
  34 /* define what facility to use for syslog */
  35 #ifndef SYSLOG_FACILITY
  36 #define SYSLOG_FACILITY LOG_DAEMON
  37 #endif
  38
  39 /* -------------------------------------------------------------------------- **
  40  * Defines...
  41  */
  42
  43 /*
  44  * format_bufr[FORMAT_BUFR_SIZE - 1] should always be reserved
  45  * for a terminating null byte.
  46  */
  47 #define FORMAT_BUFR_SIZE 1024
  48
  49 /* -------------------------------------------------------------------------- **
  50  * This module implements Samba's debugging utility.
  51  *
  52  * The syntax of a debugging log file is represented as:
  53  *
  54  *  <debugfile> :== { <debugmsg> }
  55  *
  56  *  <debugmsg>  :== <debughdr> '\n' <debugtext>
  57  *
  58  *  <debughdr>  :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
  59  *
  60  *  <debugtext> :== { <debugline> }
  61  *
  62  *  <debugline> :== TEXT '\n'
  63  *
  64  * TEXT     is a string of characters excluding the newline character.
  65  * LEVEL    is the DEBUG level of the message (an integer in the range 0..10).
  66  * TIME     is a timestamp.
  67  * FILENAME is the name of the file from which the debug message was generated.
  68  * FUNCTION is the function from which the debug message was generated.
  69  *
  70  * Basically, what that all means is:
  71  *
  72  * - A debugging log file is made up of debug messages.
  73  *
  74  * - Each debug message is made up of a header and text.  The header is
  75  *   separated from the text by a newline.
  76  *
  77  * - The header begins with the timestamp and debug level of the message
  78  *   enclosed in brackets.  The filename and function from which the
  79  *   message was generated may follow.  The filename is terminated by a
  80  *   colon, and the function name is terminated by parenthesis.
  81  *
  82  * - The message text is made up of zero or more lines, each terminated by
  83  *   a newline.
  84  */
  85
  86 /* state variables for the debug system */
  87 static struct {
  88         bool initialized;
  89         int fd;   /* The log file handle */
  90         enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
  91         const char *prog_name;
  92         bool reopening_logs;
  93         bool schedule_reopen_logs;
  94
  95         struct debug_settings settings;
  96         char *debugf;
  97         debug_callback_fn callback;
  98         void *callback_private;
  99 } state = {
 100         .settings = {
 101                 .timestamp_logs = true
 102         },
 103         .fd = 2 /* stderr by default */
 104 };
 105
 106 #if defined(WITH_SYSLOG) || defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
 107 static int debug_level_to_priority(int level)
 108 {
 109         /*
 110          * map debug levels to syslog() priorities
 111          */
 112         static const int priority_map[] = {
 113                 LOG_ERR,     /* 0 */
 114                 LOG_WARNING, /* 1 */
 115                 LOG_NOTICE,  /* 2 */
 116                 LOG_NOTICE,  /* 3 */
 117                 LOG_NOTICE,  /* 4 */
 118                 LOG_NOTICE,  /* 5 */
 119                 LOG_INFO,    /* 6 */
 120                 LOG_INFO,    /* 7 */
 121                 LOG_INFO,    /* 8 */
 122                 LOG_INFO,    /* 9 */
 123         };
 124         int priority;
 125
 126         if( level >= ARRAY_SIZE(priority_map) || level < 0)
 127                 priority = LOG_DEBUG;
 128         else
 129                 priority = priority_map[level];
 130
 131         return priority;
 132 }
 133 #endif
 134
 135 /* -------------------------------------------------------------------------- **
 136  * Debug backends. When logging to DEBUG_FILE, send the log entries to
 137  * all active backends.
 138  */
 139
 140 static void debug_file_log(int msg_level,
 141                            const char *msg, const char *msg_no_nl)
 142 {
 143         ssize_t ret;
 144
 145         check_log_size();
 146         do {
 147                 ret = write(state.fd, msg, strlen(msg));
 148         } while (ret == -1 && errno == EINTR);
 149 }
 150
 151 #ifdef WITH_SYSLOG
 152 static void debug_syslog_reload(bool enabled, bool previously_enabled,
 153                                 const char *prog_name, char *option)
 154 {
 155         if (enabled && !previously_enabled) {
 156 #ifdef LOG_DAEMON
 157                 openlog(prog_name, LOG_PID, SYSLOG_FACILITY);
 158 #else
 159                 /* for old systems that have no facility codes. */
 160                 openlog(prog_name, LOG_PID );
 161 #endif
 162                 return;
 163         }
 164
 165         if (!enabled && previously_enabled) {
 166                 closelog();
 167         }
 168 }
 169
 170 static void debug_syslog_log(int msg_level,
 171                              const char *msg, const char *msg_no_nl)
 172 {
 173         int priority;
 174
 175         priority = debug_level_to_priority(msg_level);
 176
 177         /*
 178          * Specify the facility to interoperate with other syslog
 179          * callers (vfs_full_audit for example).
 180          */
 181         priority |= SYSLOG_FACILITY;
 182
 183         syslog(priority, "%s", msg);
 184 }
 185 #endif /* WITH_SYSLOG */
 186
 187 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
 188 #include <systemd/sd-journal.h>
 189 static void debug_systemd_log(int msg_level,
 190                               const char *msg, const char *msg_no_nl)
 191 {
 192         sd_journal_send("MESSAGE=%s", msg_no_nl,
 193                         "PRIORITY=%d", debug_level_to_priority(msg_level),
 194                         "LEVEL=%d", msg_level,
 195                         NULL);
 196 }
 197 #endif
 198
 199 #ifdef HAVE_LTTNG_TRACEF
 200 #include <lttng/tracef.h>
 201 static void debug_lttng_log(int msg_level,
 202                             const char *msg, const char *msg_no_nl)
 203 {
 204         tracef(msg_no_nl);
 205 }
 206 #endif /* WITH_LTTNG_TRACEF */
 207
 208 #ifdef HAVE_GPFS
 209 #include "gpfswrap.h"
 210 static void debug_gpfs_reload(bool enabled, bool previously_enabled,
 211                               const char *prog_name, char *option)
 212 {
 213         gpfswrap_init();
 214
 215         if (enabled && !previously_enabled) {
 216                 gpfswrap_init_trace();
 217                 return;
 218         }
 219
 220         if (!enabled && previously_enabled) {
 221                 gpfswrap_fini_trace();
 222                 return;
 223         }
 224
 225         if (enabled) {
 226                 /*
 227                  * Trigger GPFS library to adjust state if necessary.
 228                  */
 229                 gpfswrap_query_trace();
 230         }
 231 }
 232
 233 static void debug_gpfs_log(int msg_level,
 234                            const char *msg, const char *msg_no_nl)
 235 {
 236         gpfswrap_add_trace(msg_level, msg_no_nl);
 237 }
 238 #endif /* HAVE_GPFS */
 239
 240 #define DEBUG_RINGBUF_SIZE (1024 * 1024)
 241 #define DEBUG_RINGBUF_SIZE_OPT "size="
 242
 243 static char *debug_ringbuf;
 244 static size_t debug_ringbuf_size;
 245 static size_t debug_ringbuf_ofs;
 246
 247 /* We ensure in debug_ringbuf_log() that this is always \0 terminated */
 248 char *debug_get_ringbuf(void)
 249 {
 250         return debug_ringbuf;
 251 }
 252
 253 /* Return the size of the ringbuf (including a \0 terminator) */
 254 size_t debug_get_ringbuf_size(void)
 255 {
 256         return debug_ringbuf_size;
 257 }
 258
 259 static void debug_ringbuf_reload(bool enabled, bool previously_enabled,
 260                                  const char *prog_name, char *option)
 261 {
 262         bool cmp;
 263         size_t optlen = strlen(DEBUG_RINGBUF_SIZE_OPT);
 264
 265         debug_ringbuf_size = DEBUG_RINGBUF_SIZE;
 266         debug_ringbuf_ofs = 0;
 267
 268         SAFE_FREE(debug_ringbuf);
 269
 270         if (!enabled) {
 271                 return;
 272         }
 273
 274         if (option != NULL) {
 275                 cmp = strncmp(option, DEBUG_RINGBUF_SIZE_OPT, optlen);
 276                 if (cmp == 0) {
 277                         debug_ringbuf_size = (size_t)strtoull(
 278                                 option + optlen, NULL, 10);
 279                 }
 280         }
 281
 282         debug_ringbuf = calloc(debug_ringbuf_size, sizeof(char));
 283         if (debug_ringbuf == NULL) {
 284                 return;
 285         }
 286 }
 287
 288 static void debug_ringbuf_log(int msg_level,
 289                               const char *msg,
 290                               const char *msg_no_nl)
 291 {
 292         size_t msglen = strlen(msg);
 293         size_t allowed_size;
 294
 295         if (debug_ringbuf == NULL) {
 296                 return;
 297         }
 298
 299         /* Ensure the buffer is always \0 terminated */
 300         allowed_size = debug_ringbuf_size - 1;
 301
 302         if (msglen > allowed_size) {
 303                 return;
 304         }
 305
 306         if ((debug_ringbuf_ofs + msglen) < debug_ringbuf_ofs) {
 307                 return;
 308         }
 309
 310         if ((debug_ringbuf_ofs + msglen) > allowed_size) {
 311                 debug_ringbuf_ofs = 0;
 312         }
 313
 314         memcpy(debug_ringbuf + debug_ringbuf_ofs, msg, msglen);
 315         debug_ringbuf_ofs += msglen;
 316 }
 317
 318 static struct debug_backend {
 319         const char *name;
 320         int log_level;
 321         int new_log_level;
 322         void (*reload)(bool enabled, bool prev_enabled,
 323                        const char *prog_name, char *option);
 324         void (*log)(int msg_level, const char *msg, const char *msg_no_nl);
 325         char *option;
 326 } debug_backends[] = {
 327         {
 328                 .name = "file",
 329                 .log = debug_file_log,
 330         },
 331 #ifdef WITH_SYSLOG
 332         {
 333                 .name = "syslog",
 334                 .reload = debug_syslog_reload,
 335                 .log = debug_syslog_log,
 336         },
 337 #endif
 338
 339 #if defined(HAVE_LIBSYSTEMD_JOURNAL) || defined(HAVE_LIBSYSTEMD)
 340         {
 341                 .name = "systemd",
 342                 .log = debug_systemd_log,
 343         },
 344 #endif
 345
 346 #ifdef HAVE_LTTNG_TRACEF
 347         {
 348                 .name = "lttng",
 349                 .log = debug_lttng_log,
 350         },
 351 #endif
 352
 353 #ifdef HAVE_GPFS
 354         {
 355                 .name = "gpfs",
 356                 .reload = debug_gpfs_reload,
 357                 .log = debug_gpfs_log,
 358         },
 359 #endif
 360         {
 361                 .name = "ringbuf",
 362                 .log = debug_ringbuf_log,
 363                 .reload = debug_ringbuf_reload,
 364         },
 365 };
 366
 367 static struct debug_backend *debug_find_backend(const char *name)
 368 {
 369         unsigned i;
 370
 371         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 372                 if (strcmp(name, debug_backends[i].name) == 0) {
 373                         return &debug_backends[i];
 374                 }
 375         }
 376
 377         return NULL;
 378 }
 379
 380 /*
 381  * parse "backend[:option][@loglevel]
 382  */
 383 static void debug_backend_parse_token(char *tok)
 384 {
 385         char *backend_name_option, *backend_name,*backend_level, *saveptr;
 386         char *backend_option;
 387         struct debug_backend *b;
 388
 389         /*
 390          * First parse into backend[:option] and loglevel
 391          */
 392         backend_name_option = strtok_r(tok, "@\0", &saveptr);
 393         if (backend_name_option == NULL) {
 394                 return;
 395         }
 396
 397         backend_level = strtok_r(NULL, "\0", &saveptr);
 398
 399         /*
 400          * Now parse backend[:option]
 401          */
 402         backend_name = strtok_r(backend_name_option, ":\0", &saveptr);
 403         if (backend_name == NULL) {
 404                 return;
 405         }
 406
 407         backend_option = strtok_r(NULL, "\0", &saveptr);
 408
 409         /*
 410          * Find and update backend
 411          */
 412         b = debug_find_backend(backend_name);
 413         if (b == NULL) {
 414                 return;
 415         }
 416
 417         if (backend_level == NULL) {
 418                 b->new_log_level = MAX_DEBUG_LEVEL;
 419         } else {
 420                 b->new_log_level = atoi(backend_level);
 421         }
 422
 423         if (backend_option != NULL) {
 424                 b->option = strdup(backend_option);
 425                 if (b->option == NULL) {
 426                         return;
 427                 }
 428         }
 429 }
 430
 431 /*
 432  * parse "backend1[:option1][@loglevel1] backend2[option2][@loglevel2] ... "
 433  * and enable/disable backends accordingly
 434  */
 435 static void debug_set_backends(const char *param)
 436 {
 437         size_t str_len = strlen(param);
 438         char str[str_len+1];
 439         char *tok, *saveptr;
 440         unsigned i;
 441
 442         /*
 443          * initialize new_log_level to detect backends that have been
 444          * disabled
 445          */
 446         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 447                 SAFE_FREE(debug_backends[i].option);
 448                 debug_backends[i].new_log_level = -1;
 449         }
 450
 451         memcpy(str, param, str_len + 1);
 452
 453         tok = strtok_r(str, LIST_SEP, &saveptr);
 454         if (tok == NULL) {
 455                 return;
 456         }
 457
 458         while (tok != NULL) {
 459                 debug_backend_parse_token(tok);
 460                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
 461         }
 462
 463         /*
 464          * Let backends react to config changes
 465          */
 466         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 467                 struct debug_backend *b = &debug_backends[i];
 468
 469                 if (b->reload) {
 470                         bool enabled = b->new_log_level > -1;
 471                         bool previously_enabled = b->log_level > -1;
 472
 473                         b->reload(enabled, previously_enabled, state.prog_name,
 474                                   b->option);
 475                 }
 476                 b->log_level = b->new_log_level;
 477         }
 478 }
 479
 480 static void debug_backends_log(const char *msg, int msg_level)
 481 {
 482         char msg_no_nl[FORMAT_BUFR_SIZE];
 483         size_t i;
 484         size_t len;
 485
 486         /*
 487          * Some backends already add an extra newline, so also provide
 488          * a buffer without the newline character.
 489          */
 490         len = MIN(strlen(msg), FORMAT_BUFR_SIZE - 1);
 491         if ((len > 0) && (msg[len - 1] == '\n')) {
 492                 len--;
 493         }
 494
 495         memcpy(msg_no_nl, msg, len);
 496         msg_no_nl[len] = '\0';
 497
 498         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 499                 if (msg_level <= debug_backends[i].log_level) {
 500                         debug_backends[i].log(msg_level, msg, msg_no_nl);
 501                 }
 502         }
 503 }
 504
 505 /* -------------------------------------------------------------------------- **
 506  * External variables.
 507  */
 508
 509 /*
 510    used to check if the user specified a
 511    logfile on the command line
 512 */
 513 bool    override_logfile;
 514
 515 static const char *default_classname_table[] = {
 516         [DBGC_ALL] =            "all",
 517         [DBGC_TDB] =            "tdb",
 518         [DBGC_PRINTDRIVERS] =   "printdrivers",
 519         [DBGC_LANMAN] =         "lanman",
 520         [DBGC_SMB] =            "smb",
 521         [DBGC_RPC_PARSE] =      "rpc_parse",
 522         [DBGC_RPC_SRV] =        "rpc_srv",
 523         [DBGC_RPC_CLI] =        "rpc_cli",
 524         [DBGC_PASSDB] =         "passdb",
 525         [DBGC_SAM] =            "sam",
 526         [DBGC_AUTH] =           "auth",
 527         [DBGC_WINBIND] =        "winbind",
 528         [DBGC_VFS] =            "vfs",
 529         [DBGC_IDMAP] =          "idmap",
 530         [DBGC_QUOTA] =          "quota",
 531         [DBGC_ACLS] =           "acls",
 532         [DBGC_LOCKING] =        "locking",
 533         [DBGC_MSDFS] =          "msdfs",
 534         [DBGC_DMAPI] =          "dmapi",
 535         [DBGC_REGISTRY] =       "registry",
 536         [DBGC_SCAVENGER] =      "scavenger",
 537         [DBGC_DNS] =            "dns",
 538         [DBGC_LDB] =            "ldb",
 539         [DBGC_TEVENT] =         "tevent",
 540         [DBGC_AUTH_AUDIT] =     "auth_audit",
 541         [DBGC_AUTH_AUDIT_JSON] = "auth_json_audit",
 542         [DBGC_KERBEROS] =       "kerberos",
 543         [DBGC_DRS_REPL] =       "drs_repl",
 544         [DBGC_SMB2] =           "smb2",
 545         [DBGC_SMB2_CREDITS] =   "smb2_credits",
 546         [DBGC_DSDB_AUDIT]  =    "dsdb_audit",
 547         [DBGC_DSDB_AUDIT_JSON] = "dsdb_json_audit",
 548         [DBGC_DSDB_PWD_AUDIT]  =        "dsdb_password_audit",
 549         [DBGC_DSDB_PWD_AUDIT_JSON] = "dsdb_password_json_audit",
 550         [DBGC_DSDB_TXN_AUDIT]  =        "dsdb_transaction_audit",
 551         [DBGC_DSDB_TXN_AUDIT_JSON] = "dsdb_transaction_json_audit",
 552         [DBGC_DSDB_GROUP_AUDIT] =       "dsdb_group_audit",
 553         [DBGC_DSDB_GROUP_AUDIT_JSON] = "dsdb_group_json_audit",
 554 };
 555
 556 /*
 557  * This is to allow reading of DEBUGLEVEL_CLASS before the debug
 558  * system has been initialized.
 559  */
 560 static const int debug_class_list_initial[ARRAY_SIZE(default_classname_table)];
 561
 562 static size_t debug_num_classes = 0;
 563 int     *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
 564
 565
 566 /* -------------------------------------------------------------------------- **
 567  * Internal variables.
 568  *
 569  *  debug_count     - Number of debug messages that have been output.
 570  *                    Used to check log size.
 571  *
 572  *  current_msg_level    - Internal copy of the message debug level.  Written by
 573  *                    dbghdr() and read by Debug1().
 574  *
 575  *  format_bufr     - Used to format debug messages.  The dbgtext() function
 576  *                    prints debug messages to a string, and then passes the
 577  *                    string to format_debug_text(), which uses format_bufr
 578  *                    to build the formatted output.
 579  *
 580  *  format_pos      - Marks the first free byte of the format_bufr.
 581  *
 582  *
 583  *  log_overflow    - When this variable is true, never attempt to check the
 584  *                    size of the log. This is a hack, so that we can write
 585  *                    a message using DEBUG, from open_logs() when we
 586  *                    are unable to open a new log file for some reason.
 587  */
 588
 589 static int     debug_count    = 0;
 590 static int     current_msg_level   = 0;
 591 static char format_bufr[FORMAT_BUFR_SIZE];
 592 static size_t     format_pos     = 0;
 593 static bool    log_overflow   = false;
 594
 595 /*
 596  * Define all the debug class selection names here. Names *MUST NOT* contain
 597  * white space. There must be one name for each DBGC_<class name>, and they
 598  * must be in the table in the order of DBGC_<class name>..
 599  */
 600
 601 static char **classname_table = NULL;
 602
 603
 604 /* -------------------------------------------------------------------------- **
 605  * Functions...
 606  */
 607
 608 static void debug_init(void);
 609
 610 /***************************************************************************
 611  Free memory pointed to by global pointers.
 612 ****************************************************************************/
 613
 614 void gfree_debugsyms(void)
 615 {
 616         unsigned i;
 617
 618         TALLOC_FREE(classname_table);
 619
 620         if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
 621                 TALLOC_FREE( DEBUGLEVEL_CLASS );
 622                 DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
 623         }
 624
 625         debug_num_classes = 0;
 626
 627         state.initialized = false;
 628
 629         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 630                 SAFE_FREE(debug_backends[i].option);
 631         }
 632 }
 633
 634 /****************************************************************************
 635 utility lists registered debug class names's
 636 ****************************************************************************/
 637
 638 char *debug_list_class_names_and_levels(void)
 639 {
 640         char *buf = NULL;
 641         size_t i;
 642         /* prepare strings */
 643         for (i = 0; i < debug_num_classes; i++) {
 644                 buf = talloc_asprintf_append(buf,
 645                                              "%s:%d%s",
 646                                              classname_table[i],
 647                                              DEBUGLEVEL_CLASS[i],
 648                                              i == (debug_num_classes - 1) ? "\n" : " ");
 649                 if (buf == NULL) {
 650                         return NULL;
 651                 }
 652         }
 653         return buf;
 654 }
 655
 656 /****************************************************************************
 657  Utility to translate names to debug class index's (internal version).
 658 ****************************************************************************/
 659
 660 static int debug_lookup_classname_int(const char* classname)
 661 {
 662         size_t i;
 663
 664         if (!classname) return -1;
 665
 666         for (i=0; i < debug_num_classes; i++) {
 667                 if (strcmp(classname, classname_table[i])==0)
 668                         return i;
 669         }
 670         return -1;
 671 }
 672
 673 /****************************************************************************
 674  Add a new debug class to the system.
 675 ****************************************************************************/
 676
 677 int debug_add_class(const char *classname)
 678 {
 679         int ndx;
 680         int *new_class_list;
 681         char **new_name_list;
 682         int default_level;
 683
 684         if (!classname)
 685                 return -1;
 686
 687         /* check the init has yet been called */
 688         debug_init();
 689
 690         ndx = debug_lookup_classname_int(classname);
 691         if (ndx >= 0)
 692                 return ndx;
 693         ndx = debug_num_classes;
 694
 695         if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
 696                 /* Initial loading... */
 697                 new_class_list = NULL;
 698         } else {
 699                 new_class_list = DEBUGLEVEL_CLASS;
 700         }
 701
 702         default_level = DEBUGLEVEL_CLASS[DBGC_ALL];
 703
 704         new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
 705         if (!new_class_list)
 706                 return -1;
 707         DEBUGLEVEL_CLASS = new_class_list;
 708
 709         DEBUGLEVEL_CLASS[ndx] = default_level;
 710
 711         new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
 712         if (!new_name_list)
 713                 return -1;
 714         classname_table = new_name_list;
 715
 716         classname_table[ndx] = talloc_strdup(classname_table, classname);
 717         if (! classname_table[ndx])
 718                 return -1;
 719
 720         debug_num_classes = ndx + 1;
 721
 722         return ndx;
 723 }
 724
 725 /****************************************************************************
 726  Utility to translate names to debug class index's (public version).
 727 ****************************************************************************/
 728
 729 static int debug_lookup_classname(const char *classname)
 730 {
 731         int ndx;
 732
 733         if (!classname || !*classname)
 734                 return -1;
 735
 736         ndx = debug_lookup_classname_int(classname);
 737
 738         if (ndx != -1)
 739                 return ndx;
 740
 741         DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
 742                   classname));
 743         return debug_add_class(classname);
 744 }
 745
 746 /****************************************************************************
 747  Dump the current registered debug levels.
 748 ****************************************************************************/
 749
 750 static void debug_dump_status(int level)
 751 {
 752         size_t q;
 753
 754         DEBUG(level, ("INFO: Current debug levels:\n"));
 755         for (q = 0; q < debug_num_classes; q++) {
 756                 const char *classname = classname_table[q];
 757                 DEBUGADD(level, ("  %s: %d\n",
 758                                  classname,
 759                                  DEBUGLEVEL_CLASS[q]));
 760         }
 761 }
 762
 763 static bool debug_parse_param(char *param)
 764 {
 765         char *class_name;
 766         char *class_level;
 767         char *saveptr = NULL;
 768         int ndx;
 769
 770         class_name = strtok_r(param, ":", &saveptr);
 771         if (class_name == NULL) {
 772                 return false;
 773         }
 774
 775         class_level = strtok_r(NULL, "\0", &saveptr);
 776         if (class_level == NULL) {
 777                 return false;
 778         }
 779
 780         ndx = debug_lookup_classname(class_name);
 781         if (ndx == -1) {
 782                 return false;
 783         }
 784
 785         DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
 786
 787         return true;
 788 }
 789
 790 /****************************************************************************
 791  Parse the debug levels from smb.conf. Example debug level string:
 792   3 tdb:5 printdrivers:7
 793  Note: the 1st param has no "name:" preceeding it.
 794 ****************************************************************************/
 795
 796 bool debug_parse_levels(const char *params_str)
 797 {
 798         size_t str_len = strlen(params_str);
 799         char str[str_len+1];
 800         char *tok, *saveptr;
 801         size_t i;
 802
 803         /* Just in case */
 804         debug_init();
 805
 806         memcpy(str, params_str, str_len+1);
 807
 808         tok = strtok_r(str, LIST_SEP, &saveptr);
 809         if (tok == NULL) {
 810                 return true;
 811         }
 812
 813         /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
 814          * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
 815          */
 816         if (isdigit(tok[0])) {
 817                 DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(tok);
 818                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
 819         } else {
 820                 DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
 821         }
 822
 823         /* Array is debug_num_classes long */
 824         for (i = DBGC_ALL+1; i < debug_num_classes; i++) {
 825                 DEBUGLEVEL_CLASS[i] = DEBUGLEVEL_CLASS[DBGC_ALL];
 826         }
 827
 828         while (tok != NULL) {
 829                 bool ok;
 830
 831                 ok = debug_parse_param(tok);
 832                 if (!ok) {
 833                         DEBUG(0,("debug_parse_params: unrecognized debug "
 834                                  "class name or format [%s]\n", tok));
 835                         return false;
 836                 }
 837
 838                 tok = strtok_r(NULL, LIST_SEP, &saveptr);
 839         }
 840
 841         debug_dump_status(5);
 842
 843         return true;
 844 }
 845
 846 /* setup for logging of talloc warnings */
 847 static void talloc_log_fn(const char *msg)
 848 {
 849         DEBUG(0,("%s", msg));
 850 }
 851
 852 void debug_setup_talloc_log(void)
 853 {
 854         talloc_set_log_fn(talloc_log_fn);
 855 }
 856
 857
 858 /****************************************************************************
 859 Init debugging (one time stuff)
 860 ****************************************************************************/
 861
 862 static void debug_init(void)
 863 {
 864         size_t i;
 865
 866         if (state.initialized)
 867                 return;
 868
 869         state.initialized = true;
 870
 871         debug_setup_talloc_log();
 872
 873         for (i = 0; i < ARRAY_SIZE(default_classname_table); i++) {
 874                 debug_add_class(default_classname_table[i]);
 875         }
 876
 877         for (i = 0; i < ARRAY_SIZE(debug_backends); i++) {
 878                 debug_backends[i].log_level = -1;
 879                 debug_backends[i].new_log_level = -1;
 880         }
 881 }
 882
 883 void debug_set_settings(struct debug_settings *settings,
 884                         const char *logging_param,
 885                         int syslog_level, bool syslog_only)
 886 {
 887         char fake_param[256];
 888         size_t len = 0;
 889
 890         /*
 891          * This forces in some smb.conf derived values into the debug
 892          * system. There are no pointers in this structure, so we can
 893          * just structure-assign it in
 894          */
 895         state.settings = *settings;
 896
 897         /*
 898          * If 'logging' is not set, create backend settings from
 899          * deprecated 'syslog' and 'syslog only' parameters
 900          */
 901         if (logging_param != NULL) {
 902                 len = strlen(logging_param);
 903         }
 904         if (len == 0) {
 905                 if (syslog_only) {
 906                         snprintf(fake_param, sizeof(fake_param),
 907                                  "syslog@%d", syslog_level - 1);
 908                 } else {
 909                         snprintf(fake_param, sizeof(fake_param),
 910                                  "syslog@%d file@%d", syslog_level -1,
 911                                  MAX_DEBUG_LEVEL);
 912                 }
 913
 914                 logging_param = fake_param;
 915         }
 916
 917         debug_set_backends(logging_param);
 918 }
 919
 920 /**
 921   control the name of the logfile and whether logging will be to stdout, stderr
 922   or a file, and set up syslog
 923
 924   new_log indicates the destination for the debug log (an enum in
 925   order of precedence - once set to DEBUG_FILE, it is not possible to
 926   reset to DEBUG_STDOUT for example.  This makes it easy to override
 927   for debug to stderr on the command line, as the smb.conf cannot
 928   reset it back to file-based logging
 929 */
 930 void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
 931 {
 932         debug_init();
 933         if (state.logtype < new_logtype) {
 934                 state.logtype = new_logtype;
 935         }
 936         if (prog_name) {
 937                 const char *p = strrchr(prog_name, '/');
 938
 939                 if (p) {
 940                         prog_name = p + 1;
 941                 }
 942
 943                 state.prog_name = prog_name;
 944         }
 945         reopen_logs_internal();
 946 }
 947
 948 /***************************************************************************
 949  Set the logfile name.
 950 **************************************************************************/
 951
 952 void debug_set_logfile(const char *name)
 953 {
 954         if (name == NULL || *name == 0) {
 955                 /* this copes with calls when smb.conf is not loaded yet */
 956                 return;
 957         }
 958         TALLOC_FREE(state.debugf);
 959         state.debugf = talloc_strdup(NULL, name);
 960 }
 961
 962 static void debug_close_fd(int fd)
 963 {
 964         if (fd > 2) {
 965                 close(fd);
 966         }
 967 }
 968
 969 bool debug_get_output_is_stderr(void)
 970 {
 971         return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
 972 }
 973
 974 bool debug_get_output_is_stdout(void)
 975 {
 976         return (state.logtype == DEBUG_DEFAULT_STDOUT) || (state.logtype == DEBUG_STDOUT);
 977 }
 978
 979 void debug_set_callback(void *private_ptr, debug_callback_fn fn)
 980 {
 981         debug_init();
 982         if (fn) {
 983                 state.logtype = DEBUG_CALLBACK;
 984                 state.callback_private = private_ptr;
 985                 state.callback = fn;
 986         } else {
 987                 state.logtype = DEBUG_DEFAULT_STDERR;
 988                 state.callback_private = NULL;
 989                 state.callback = NULL;
 990         }
 991 }
 992
 993 static void debug_callback_log(const char *msg, int msg_level)
 994 {
 995         size_t msg_len = strlen(msg);
 996         char msg_copy[msg_len];
 997
 998         if ((msg_len > 0) && (msg[msg_len-1] == '\n')) {
 999                 memcpy(msg_copy, msg, msg_len-1);
1000                 msg_copy[msg_len-1] = '\0';
1001                 msg = msg_copy;
1002         }
1003
1004         state.callback(state.callback_private, msg_level, msg);
1005 }
1006
1007 /**************************************************************************
1008  reopen the log files
1009  note that we now do this unconditionally
1010  We attempt to open the new debug fp before closing the old. This means
1011  if we run out of fd's we just keep using the old fd rather than aborting.
1012  Fix from dgibson@linuxcare.com.
1013 **************************************************************************/
1014
1015 /**
1016   reopen the log file (usually called because the log file name might have changed)
1017 */
1018 bool reopen_logs_internal(void)
1019 {
1020         mode_t oldumask;
1021         int new_fd = 0;
1022         int old_fd = 0;
1023         bool ret = true;
1024
1025         if (state.reopening_logs) {
1026                 return true;
1027         }
1028
1029         /* Now clear the SIGHUP induced flag */
1030         state.schedule_reopen_logs = false;
1031
1032         switch (state.logtype) {
1033         case DEBUG_CALLBACK:
1034                 return true;
1035         case DEBUG_STDOUT:
1036         case DEBUG_DEFAULT_STDOUT:
1037                 debug_close_fd(state.fd);
1038                 state.fd = 1;
1039                 return true;
1040
1041         case DEBUG_DEFAULT_STDERR:
1042         case DEBUG_STDERR:
1043                 debug_close_fd(state.fd);
1044                 state.fd = 2;
1045                 return true;
1046
1047         case DEBUG_FILE:
1048                 break;
1049         }
1050
1051         oldumask = umask( 022 );
1052
1053         if (!state.debugf) {
1054                 return false;
1055         }
1056
1057         state.reopening_logs = true;
1058
1059         new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
1060
1061         if (new_fd == -1) {
1062                 log_overflow = true;
1063                 DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
1064                 log_overflow = false;
1065                 ret = false;
1066         } else {
1067                 smb_set_close_on_exec(new_fd);
1068                 old_fd = state.fd;
1069                 state.fd = new_fd;
1070                 debug_close_fd(old_fd);
1071         }
1072
1073         /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
1074          * to fix problem where smbd's that generate less
1075          * than 100 messages keep growing the log.
1076          */
1077         force_check_log_size();
1078         (void)umask(oldumask);
1079
1080         /*
1081          * If log file was opened or created successfully, take over stderr to
1082          * catch output into logs.
1083          */
1084         if (new_fd != -1) {
1085                 if (dup2(state.fd, 2) == -1) {
1086                         /* Close stderr too, if dup2 can't point it -
1087                            at the logfile.  There really isn't much
1088                            that can be done on such a fundamental
1089                            failure... */
1090                         close_low_fd(2);
1091                 }
1092         }
1093
1094         state.reopening_logs = false;
1095
1096         return ret;
1097 }
1098
1099 /**************************************************************************
1100  Force a check of the log size.
1101  ***************************************************************************/
1102
1103 void force_check_log_size( void )
1104 {
1105         debug_count = 100;
1106 }
1107
1108 _PUBLIC_ void debug_schedule_reopen_logs(void)
1109 {
1110         state.schedule_reopen_logs = true;
1111 }
1112
1113
1114 /***************************************************************************
1115  Check to see if there is any need to check if the logfile has grown too big.
1116 **************************************************************************/
1117
1118 bool need_to_check_log_size( void )
1119 {
1120         int maxlog;
1121
1122         if( debug_count < 100)
1123                 return( false );
1124
1125         maxlog = state.settings.max_log_size * 1024;
1126         if ( state.fd <=2 || maxlog <= 0 ) {
1127                 debug_count = 0;
1128                 return(false);
1129         }
1130         return( true );
1131 }
1132
1133 /**************************************************************************
1134  Check to see if the log has grown to be too big.
1135  **************************************************************************/
1136
1137 void check_log_size( void )
1138 {
1139         int         maxlog;
1140         struct stat st;
1141
1142         /*
1143          *  We need to be root to check/change log-file, skip this and let the main
1144          *  loop check do a new check as root.
1145          */
1146
1147 #if _SAMBA_BUILD_ == 3
1148         if (geteuid() != sec_initial_uid())
1149 #else
1150         if( geteuid() != 0)
1151 #endif
1152         {
1153                 /* We don't check sec_initial_uid() here as it isn't
1154                  * available in common code and we don't generally
1155                  * want to rotate and the possibly lose logs in
1156                  * make test or the build farm */
1157                 return;
1158         }
1159
1160         if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
1161                 return;
1162         }
1163
1164         maxlog = state.settings.max_log_size * 1024;
1165
1166         if (state.schedule_reopen_logs) {
1167             (void)reopen_logs_internal();
1168         }
1169
1170         if (maxlog && (fstat(state.fd, &st) == 0
1171             && st.st_size > maxlog )) {
1172                 (void)reopen_logs_internal();
1173                 if (state.fd > 2 && (fstat(state.fd, &st) == 0
1174                                      && st.st_size > maxlog)) {
1175                         char name[strlen(state.debugf) + 5];
1176
1177                         snprintf(name, sizeof(name), "%s.old", state.debugf);
1178
1179                         (void)rename(state.debugf, name);
1180
1181                         if (!reopen_logs_internal()) {
1182                                 /* We failed to reopen a log - continue using the old name. */
1183                                 (void)rename(name, state.debugf);
1184                         }
1185                 }
1186         }
1187
1188         /*
1189          * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
1190          */
1191
1192         if (state.fd <= 0) {
1193                 /* This code should only be reached in very strange
1194                  * circumstances. If we merely fail to open the new log we
1195                  * should stick with the old one. ergo this should only be
1196                  * reached when opening the logs for the first time: at
1197                  * startup or when the log level is increased from zero.
1198                  * -dwg 6 June 2000
1199                  */
1200                 int fd = open( "/dev/console", O_WRONLY, 0);
1201                 if (fd != -1) {
1202                         smb_set_close_on_exec(fd);
1203                         state.fd = fd;
1204                         DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
1205                                         state.debugf ));
1206                 } else {
1207                         /*
1208                          * We cannot continue without a debug file handle.
1209                          */
1210                         abort();
1211                 }
1212         }
1213         debug_count = 0;
1214 }
1215
1216 /*************************************************************************
1217  Write an debug message on the debugfile.
1218  This is called by dbghdr() and format_debug_text().
1219 ************************************************************************/
1220
1221 static void Debug1(const char *msg)
1222 {
1223         int old_errno = errno;
1224
1225         debug_count++;
1226
1227         switch(state.logtype) {
1228         case DEBUG_CALLBACK:
1229                 debug_callback_log(msg, current_msg_level);
1230                 break;
1231         case DEBUG_STDOUT:
1232         case DEBUG_STDERR:
1233         case DEBUG_DEFAULT_STDOUT:
1234         case DEBUG_DEFAULT_STDERR:
1235                 if (state.fd > 0) {
1236                         ssize_t ret;
1237                         do {
1238                                 ret = write(state.fd, msg, strlen(msg));
1239                         } while (ret == -1 && errno == EINTR);
1240                 }
1241                 break;
1242         case DEBUG_FILE:
1243                 debug_backends_log(msg, current_msg_level);
1244                 break;
1245         };
1246
1247         errno = old_errno;
1248 }
1249
1250 /**************************************************************************
1251  Print the buffer content via Debug1(), then reset the buffer.
1252  Input:  none
1253  Output: none
1254 ****************************************************************************/
1255
1256 static void bufr_print( void )
1257 {
1258         format_bufr[format_pos] = '\0';
1259         (void)Debug1(format_bufr);
1260         format_pos = 0;
1261 }
1262
1263 /***************************************************************************
1264  Format the debug message text.
1265
1266  Input:  msg - Text to be added to the "current" debug message text.
1267
1268  Output: none.
1269
1270  Notes:  The purpose of this is two-fold.  First, each call to syslog()
1271          (used by Debug1(), see above) generates a new line of syslog
1272          output.  This is fixed by storing the partial lines until the
1273          newline character is encountered.  Second, printing the debug
1274          message lines when a newline is encountered allows us to add
1275          spaces, thus indenting the body of the message and making it
1276          more readable.
1277 **************************************************************************/
1278
1279 static void format_debug_text( const char *msg )
1280 {
1281         size_t i;
1282         bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
1283
1284         debug_init();
1285
1286         for( i = 0; msg[i]; i++ ) {
1287                 /* Indent two spaces at each new line. */
1288                 if(timestamp && 0 == format_pos) {
1289                         format_bufr[0] = format_bufr[1] = ' ';
1290                         format_pos = 2;
1291                 }
1292
1293                 /* If there's room, copy the character to the format buffer. */
1294                 if (format_pos < FORMAT_BUFR_SIZE - 1)
1295                         format_bufr[format_pos++] = msg[i];
1296
1297                 /* If a newline is encountered, print & restart. */
1298                 if( '\n' == msg[i] )
1299                         bufr_print();
1300
1301                 /* If the buffer is full dump it out, reset it, and put out a line
1302                  * continuation indicator.
1303                  */
1304                 if (format_pos >= FORMAT_BUFR_SIZE - 1) {
1305                         bufr_print();
1306                         (void)Debug1( " +>\n" );
1307                 }
1308         }
1309
1310         /* Just to be safe... */
1311         format_bufr[format_pos] = '\0';
1312 }
1313
1314 /***************************************************************************
1315  Flush debug output, including the format buffer content.
1316
1317  Input:  none
1318  Output: none
1319 ***************************************************************************/
1320
1321 void dbgflush( void )
1322 {
1323         bufr_print();
1324 }
1325
1326 /***************************************************************************
1327  Print a Debug Header.
1328
1329  Input:  level    - Debug level of the message (not the system-wide debug
1330                     level. )
1331          cls      - Debuglevel class of the calling module.
1332          location - Pointer to a string containing the name of the file
1333                     from which this function was called, or an empty string
1334                     if the __FILE__ macro is not implemented.
1335          func     - Pointer to a string containing the name of the function
1336                     from which this function was called, or an empty string
1337                     if the __FUNCTION__ macro is not implemented.
1338
1339  Output: Always true.  This makes it easy to fudge a call to dbghdr()
1340          in a macro, since the function can be called as part of a test.
1341          Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
1342
1343  Notes:  This function takes care of setting current_msg_level.
1344
1345 ****************************************************************************/
1346
1347 bool dbghdrclass(int level, int cls, const char *location, const char *func)
1348 {
1349         /* Ensure we don't lose any real errno value. */
1350         int old_errno = errno;
1351         bool verbose = false;
1352         char header_str[300];
1353         size_t hs_len;
1354         struct timeval tv;
1355         struct timeval_buf tvbuf;
1356
1357         if( format_pos ) {
1358                 /* This is a fudge.  If there is stuff sitting in the format_bufr, then
1359                  * the *right* thing to do is to call
1360                  *   format_debug_text( "\n" );
1361                  * to write the remainder, and then proceed with the new header.
1362                  * Unfortunately, there are several places in the code at which
1363                  * the DEBUG() macro is used to build partial lines.  That in mind,
1364                  * we'll work under the assumption that an incomplete line indicates
1365                  * that a new header is *not* desired.
1366                  */
1367                 return( true );
1368         }
1369
1370         /* Set current_msg_level. */
1371         current_msg_level = level;
1372
1373         /* Don't print a header if we're logging to stdout. */
1374         if ( state.logtype != DEBUG_FILE ) {
1375                 return( true );
1376         }
1377
1378         /* Print the header if timestamps are turned on.  If parameters are
1379          * not yet loaded, then default to timestamps on.
1380          */
1381         if (!(state.settings.timestamp_logs ||
1382               state.settings.debug_prefix_timestamp)) {
1383                 return true;
1384         }
1385
1386         GetTimeOfDay(&tv);
1387         timeval_str_buf(&tv, false, state.settings.debug_hires_timestamp,
1388                         &tvbuf);
1389
1390         hs_len = snprintf(header_str, sizeof(header_str), "[%s, %2d",
1391                           tvbuf.buf, level);
1392         if (hs_len >= sizeof(header_str)) {
1393                 goto full;
1394         }
1395
1396         if (unlikely(DEBUGLEVEL_CLASS[ cls ] >= 10)) {
1397                 verbose = true;
1398         }
1399
1400         if (verbose || state.settings.debug_pid) {
1401                 hs_len += snprintf(
1402                         header_str + hs_len, sizeof(header_str) - hs_len,
1403                         ", pid=%u", (unsigned int)getpid());
1404                 if (hs_len >= sizeof(header_str)) {
1405                         goto full;
1406                 }
1407         }
1408
1409         if (verbose || state.settings.debug_uid) {
1410                 hs_len += snprintf(
1411                         header_str + hs_len, sizeof(header_str) - hs_len,
1412                         ", effective(%u, %u), real(%u, %u)",
1413                         (unsigned int)geteuid(), (unsigned int)getegid(),
1414                         (unsigned int)getuid(), (unsigned int)getgid());
1415                 if (hs_len >= sizeof(header_str)) {
1416                         goto full;
1417                 }
1418         }
1419
1420         if ((verbose || state.settings.debug_class)
1421             && (cls != DBGC_ALL)) {
1422                 hs_len += snprintf(
1423                         header_str + hs_len, sizeof(header_str) - hs_len,
1424                         ", class=%s", classname_table[cls]);
1425                 if (hs_len >= sizeof(header_str)) {
1426                         goto full;
1427                 }
1428         }
1429
1430         /*
1431          * No +=, see man man strlcat
1432          */
1433         hs_len = strlcat(header_str, "] ", sizeof(header_str));
1434         if (hs_len >= sizeof(header_str)) {
1435                 goto full;
1436         }
1437
1438         if (!state.settings.debug_prefix_timestamp) {
1439                 hs_len += snprintf(
1440                         header_str + hs_len, sizeof(header_str) - hs_len,
1441                         "%s(%s)\n", location, func);
1442                 if (hs_len >= sizeof(header_str)) {
1443                         goto full;
1444                 }
1445         }
1446
1447 full:
1448         (void)Debug1(header_str);
1449
1450         errno = old_errno;
1451         return( true );
1452 }
1453
1454 /***************************************************************************
1455  Add text to the body of the "current" debug message via the format buffer.
1456
1457   Input:  format_str  - Format string, as used in printf(), et. al.
1458           ...         - Variable argument list.
1459
1460   ..or..  va_alist    - Old style variable parameter list starting point.
1461
1462   Output: Always true.  See dbghdr() for more info, though this is not
1463           likely to be used in the same way.
1464
1465 ***************************************************************************/
1466
1467 static inline bool __dbgtext_va(const char *format_str, va_list ap) PRINTF_ATTRIBUTE(1,0);
1468 static inline bool __dbgtext_va(const char *format_str, va_list ap)
1469 {
1470         char *msgbuf = NULL;
1471         bool ret = true;
1472         int res;
1473
1474         res = vasprintf(&msgbuf, format_str, ap);
1475         if (res != -1) {
1476                 format_debug_text(msgbuf);
1477         } else {
1478                 ret = false;
1479         }
1480         SAFE_FREE(msgbuf);
1481         return ret;
1482 }
1483
1484 bool dbgtext_va(const char *format_str, va_list ap)
1485 {
1486         return __dbgtext_va(format_str, ap);
1487 }
1488
1489 bool dbgtext(const char *format_str, ... )
1490 {
1491         va_list ap;
1492         bool ret;
1493
1494         va_start(ap, format_str);
1495         ret = __dbgtext_va(format_str, ap);
1496         va_end(ap);
1497
1498         return ret;
1499 }