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