source3/utils/status.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    status reporting
   4    Copyright (C) Andrew Tridgell 1994-1998
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18
  19    Revision History:
  20
  21    12 aug 96: Erik.Devriendt@te6.siemens.be
  22    added support for shared memory implementation of share mode locking
  23
  24    21-Jul-1998: rsharpe@ns.aus.com (Richard Sharpe)
  25    Added -L (locks only) -S (shares only) flags and code
  26
  27 */
  28
  29 /*
  30  * This program reports current SMB connections
  31  */
  32
  33 #include "includes.h"
  34 #include "smbd/globals.h"
  35 #include "system/filesys.h"
  36 #include "popt_common.h"
  37 #include "dbwrap/dbwrap.h"
  38 #include "dbwrap/dbwrap_open.h"
  39 #include "../libcli/security/security.h"
  40 #include "session.h"
  41 #include "locking/proto.h"
  42 #include "messages.h"
  43 #include "librpc/gen_ndr/open_files.h"
  44 #include "smbd/smbd.h"
  45 #include "librpc/gen_ndr/notify.h"
  46 #include "lib/conn_tdb.h"
  47 #include "serverid.h"
  48 #include "status_profile.h"
  49 #include "smbd/notifyd/notifyd.h"
  50
  51 #define SMB_MAXPIDS             2048
  52 static uid_t            Ucrit_uid = 0;               /* added by OH */
  53 static struct server_id Ucrit_pid[SMB_MAXPIDS];  /* Ugly !!! */   /* added by OH */
  54 static int              Ucrit_MaxPid=0;                    /* added by OH */
  55 static unsigned int     Ucrit_IsActive = 0;                /* added by OH */
  56
  57 static bool verbose, brief;
  58 static bool shares_only;            /* Added by RJS */
  59 static bool locks_only;            /* Added by RJS */
  60 static bool processes_only;
  61 static bool show_brl;
  62 static bool numeric_only;
  63 static bool do_checks = true;
  64
  65 const char *username = NULL;
  66
  67 /* added by OH */
  68 static void Ucrit_addUid(uid_t uid)
  69 {
  70         Ucrit_uid = uid;
  71         Ucrit_IsActive = 1;
  72 }
  73
  74 static unsigned int Ucrit_checkUid(uid_t uid)
  75 {
  76         if ( !Ucrit_IsActive )
  77                 return 1;
  78
  79         if ( uid == Ucrit_uid )
  80                 return 1;
  81
  82         return 0;
  83 }
  84
  85 static unsigned int Ucrit_checkPid(struct server_id pid)
  86 {
  87         int i;
  88
  89         if ( !Ucrit_IsActive )
  90                 return 1;
  91
  92         for (i=0;i<Ucrit_MaxPid;i++) {
  93                 if (serverid_equal(&pid, &Ucrit_pid[i])) {
  94                         return 1;
  95                 }
  96         }
  97
  98         return 0;
  99 }
 100
 101 static bool Ucrit_addPid( struct server_id pid )
 102 {
 103         if ( !Ucrit_IsActive )
 104                 return True;
 105
 106         if ( Ucrit_MaxPid >= SMB_MAXPIDS ) {
 107                 d_printf("ERROR: More than %d pids for user %s!\n",
 108                          SMB_MAXPIDS, uidtoname(Ucrit_uid));
 109
 110                 return False;
 111         }
 112
 113         Ucrit_pid[Ucrit_MaxPid++] = pid;
 114
 115         return True;
 116 }
 117
 118 static int print_share_mode(const struct share_mode_entry *e,
 119                             const char *sharepath,
 120                             const char *fname,
 121                             const char *sname,
 122                             void *dummy)
 123 {
 124         static int count;
 125
 126         if (do_checks && !is_valid_share_mode_entry(e)) {
 127                 return 0;
 128         }
 129
 130         if (count==0) {
 131                 d_printf("Locked files:\n");
 132                 d_printf("Pid          Uid        DenyMode   Access      R/W        Oplock           SharePath   Name   Time\n");
 133                 d_printf("--------------------------------------------------------------------------------------------------\n");
 134         }
 135         count++;
 136
 137         if (do_checks && !serverid_exists(&e->pid)) {
 138                 /* the process for this entry does not exist any more */
 139                 return 0;
 140         }
 141
 142         if (Ucrit_checkPid(e->pid)) {
 143                 struct server_id_buf tmp;
 144                 d_printf("%-11s  ", server_id_str_buf(e->pid, &tmp));
 145                 d_printf("%-9u  ", (unsigned int)e->uid);
 146                 switch (map_share_mode_to_deny_mode(e->share_access,
 147                                                     e->private_options)) {
 148                         case DENY_NONE: d_printf("DENY_NONE  "); break;
 149                         case DENY_ALL:  d_printf("DENY_ALL   "); break;
 150                         case DENY_DOS:  d_printf("DENY_DOS   "); break;
 151                         case DENY_READ: d_printf("DENY_READ  "); break;
 152                         case DENY_WRITE:printf("DENY_WRITE "); break;
 153                         case DENY_FCB:  d_printf("DENY_FCB "); break;
 154                         default: {
 155                                 d_printf("unknown-please report ! "
 156                                          "e->share_access = 0x%x, "
 157                                          "e->private_options = 0x%x\n",
 158                                          (unsigned int)e->share_access,
 159                                          (unsigned int)e->private_options );
 160                                 break;
 161                         }
 162                 }
 163                 d_printf("0x%-8x  ",(unsigned int)e->access_mask);
 164                 if ((e->access_mask & (FILE_READ_DATA|FILE_WRITE_DATA))==
 165                                 (FILE_READ_DATA|FILE_WRITE_DATA)) {
 166                         d_printf("RDWR       ");
 167                 } else if (e->access_mask & FILE_WRITE_DATA) {
 168                         d_printf("WRONLY     ");
 169                 } else {
 170                         d_printf("RDONLY     ");
 171                 }
 172
 173                 if((e->op_type & (EXCLUSIVE_OPLOCK|BATCH_OPLOCK)) ==
 174                                         (EXCLUSIVE_OPLOCK|BATCH_OPLOCK)) {
 175                         d_printf("EXCLUSIVE+BATCH ");
 176                 } else if (e->op_type & EXCLUSIVE_OPLOCK) {
 177                         d_printf("EXCLUSIVE       ");
 178                 } else if (e->op_type & BATCH_OPLOCK) {
 179                         d_printf("BATCH           ");
 180                 } else if (e->op_type & LEVEL_II_OPLOCK) {
 181                         d_printf("LEVEL_II        ");
 182                 } else if (e->op_type == LEASE_OPLOCK) {
 183                         uint32_t lstate = e->lease->current_state;
 184                         d_printf("LEASE(%s%s%s)%s%s%s      ",
 185                                  (lstate & SMB2_LEASE_READ)?"R":"",
 186                                  (lstate & SMB2_LEASE_WRITE)?"W":"",
 187                                  (lstate & SMB2_LEASE_HANDLE)?"H":"",
 188                                  (lstate & SMB2_LEASE_READ)?"":" ",
 189                                  (lstate & SMB2_LEASE_WRITE)?"":" ",
 190                                  (lstate & SMB2_LEASE_HANDLE)?"":" ");
 191                 } else {
 192                         d_printf("NONE            ");
 193                 }
 194
 195                 d_printf(" %s   %s%s   %s",
 196                          sharepath, fname,
 197                          sname ? sname : "",
 198                          time_to_asc((time_t)e->time.tv_sec));
 199         }
 200
 201         return 0;
 202 }
 203
 204 static void print_brl(struct file_id id,
 205                         struct server_id pid,
 206                         enum brl_type lock_type,
 207                         enum brl_flavour lock_flav,
 208                         br_off start,
 209                         br_off size,
 210                         void *private_data)
 211 {
 212         static int count;
 213         unsigned int i;
 214         static const struct {
 215                 enum brl_type lock_type;
 216                 const char *desc;
 217         } lock_types[] = {
 218                 { READ_LOCK, "R" },
 219                 { WRITE_LOCK, "W" },
 220                 { PENDING_READ_LOCK, "PR" },
 221                 { PENDING_WRITE_LOCK, "PW" },
 222                 { UNLOCK_LOCK, "U" }
 223         };
 224         const char *desc="X";
 225         const char *sharepath = "";
 226         char *fname = NULL;
 227         struct share_mode_lock *share_mode;
 228         struct server_id_buf tmp;
 229
 230         if (count==0) {
 231                 d_printf("Byte range locks:\n");
 232                 d_printf("Pid        dev:inode       R/W  start     size      SharePath               Name\n");
 233                 d_printf("--------------------------------------------------------------------------------\n");
 234         }
 235         count++;
 236
 237         share_mode = fetch_share_mode_unlocked(NULL, id);
 238         if (share_mode) {
 239                 bool has_stream = share_mode->data->stream_name != NULL;
 240
 241                 fname = talloc_asprintf(NULL, "%s%s%s",
 242                                         share_mode->data->base_name,
 243                                         has_stream ? ":" : "",
 244                                         has_stream ?
 245                                         share_mode->data->stream_name :
 246                                         "");
 247         } else {
 248                 fname = talloc_strdup(NULL, "");
 249                 if (fname == NULL) {
 250                         return;
 251                 }
 252         }
 253
 254         for (i=0;i<ARRAY_SIZE(lock_types);i++) {
 255                 if (lock_type == lock_types[i].lock_type) {
 256                         desc = lock_types[i].desc;
 257                 }
 258         }
 259
 260         d_printf("%-10s %-15s %-4s %-9jd %-9jd %-24s %-24s\n",
 261                  server_id_str_buf(pid, &tmp), file_id_string_tos(&id),
 262                  desc,
 263                  (intmax_t)start, (intmax_t)size,
 264                  sharepath, fname);
 265
 266         TALLOC_FREE(fname);
 267         TALLOC_FREE(share_mode);
 268 }
 269
 270 static const char *session_dialect_str(uint16_t dialect)
 271 {
 272         static fstring unkown_dialect;
 273
 274         switch(dialect){
 275         case SMB2_DIALECT_REVISION_000:
 276                 return "NT1";
 277         case SMB2_DIALECT_REVISION_202:
 278                 return "SMB2_02";
 279         case SMB2_DIALECT_REVISION_210:
 280                 return "SMB2_10";
 281         case SMB2_DIALECT_REVISION_222:
 282                 return "SMB2_22";
 283         case SMB2_DIALECT_REVISION_224:
 284                 return "SMB2_24";
 285         case SMB3_DIALECT_REVISION_300:
 286                 return "SMB3_00";
 287         case SMB3_DIALECT_REVISION_302:
 288                 return "SMB3_02";
 289         case SMB3_DIALECT_REVISION_310:
 290                 return "SMB3_10";
 291         case SMB3_DIALECT_REVISION_311:
 292                 return "SMB3_11";
 293         }
 294
 295         fstr_sprintf(unkown_dialect, "Unknown (0x%04x)", dialect);
 296         return unkown_dialect;
 297 }
 298
 299 static int traverse_connections(const struct connections_key *key,
 300                                 const struct connections_data *crec,
 301                                 void *private_data)
 302 {
 303         TALLOC_CTX *mem_ctx = (TALLOC_CTX *)private_data;
 304         struct server_id_buf tmp;
 305         char *timestr = NULL;
 306         int result = 0;
 307         const char *encryption = "-";
 308         const char *signing = "-";
 309
 310         if (crec->cnum == TID_FIELD_INVALID)
 311                 return 0;
 312
 313         if (do_checks &&
 314             (!process_exists(crec->pid) || !Ucrit_checkUid(crec->uid))) {
 315                 return 0;
 316         }
 317
 318         timestr = timestring(mem_ctx, crec->start);
 319         if (timestr == NULL) {
 320                 return -1;
 321         }
 322
 323         if (smbXsrv_is_encrypted(crec->encryption_flags)) {
 324                 switch (crec->cipher) {
 325                 case SMB_ENCRYPTION_GSSAPI:
 326                         encryption = "GSSAPI";
 327                         break;
 328                 case SMB2_ENCRYPTION_AES128_CCM:
 329                         encryption = "AES-128-CCM";
 330                         break;
 331                 case SMB2_ENCRYPTION_AES128_GCM:
 332                         encryption = "AES-128-GCM";
 333                         break;
 334                 default:
 335                         encryption = "???";
 336                         result = -1;
 337                         break;
 338                 }
 339         }
 340
 341         if (smbXsrv_is_signed(crec->signing_flags)) {
 342                 if (crec->dialect >= SMB3_DIALECT_REVISION_302) {
 343                         signing = "AES-128-CMAC";
 344                 } else if (crec->dialect >= SMB2_DIALECT_REVISION_202) {
 345                         signing = "HMAC-SHA256";
 346                 } else {
 347                         signing = "HMAC-MD5";
 348                 }
 349         }
 350
 351         d_printf("%-12s %-7s %-13s %-32s %-12s %-12s\n",
 352                  crec->servicename, server_id_str_buf(crec->pid, &tmp),
 353                  crec->machine,
 354                  timestr,
 355                  encryption,
 356                  signing);
 357
 358         TALLOC_FREE(timestr);
 359
 360         return result;
 361 }
 362
 363 static int traverse_sessionid(const char *key, struct sessionid *session,
 364                               void *private_data)
 365 {
 366         TALLOC_CTX *mem_ctx = (TALLOC_CTX *)private_data;
 367         fstring uid_str, gid_str;
 368         struct server_id_buf tmp;
 369         char *machine_hostname = NULL;
 370         int result = 0;
 371         const char *encryption = "-";
 372         const char *signing = "-";
 373
 374         if (do_checks &&
 375             (!process_exists(session->pid) ||
 376              !Ucrit_checkUid(session->uid))) {
 377                 return 0;
 378         }
 379
 380         Ucrit_addPid(session->pid);
 381
 382         fstrcpy(uid_str, "-1");
 383
 384         if (session->uid != -1) {
 385                 if (numeric_only) {
 386                         fstr_sprintf(uid_str, "%u", (unsigned int)session->uid);
 387                 } else {
 388                         fstrcpy(uid_str, uidtoname(session->uid));
 389                 }
 390         }
 391
 392         fstrcpy(gid_str, "-1");
 393
 394         if (session->gid != -1) {
 395                 if (numeric_only) {
 396                         fstr_sprintf(gid_str, "%u", (unsigned int)session->gid);
 397                 } else {
 398                         fstrcpy(gid_str, gidtoname(session->gid));
 399                 }
 400         }
 401
 402         machine_hostname = talloc_asprintf(mem_ctx, "%s (%s)",
 403                                            session->remote_machine,
 404                                            session->hostname);
 405         if (machine_hostname == NULL) {
 406                 return -1;
 407         }
 408
 409         if (smbXsrv_is_encrypted(session->encryption_flags)) {
 410                 switch (session->cipher) {
 411                 case SMB2_ENCRYPTION_AES128_CCM:
 412                         encryption = "AES-128-CCM";
 413                         break;
 414                 case SMB2_ENCRYPTION_AES128_GCM:
 415                         encryption = "AES-128-GCM";
 416                         break;
 417                 default:
 418                         encryption = "???";
 419                         result = -1;
 420                         break;
 421                 }
 422         } else if (smbXsrv_is_partially_encrypted(session->encryption_flags)) {
 423                 switch (session->cipher) {
 424                 case SMB_ENCRYPTION_GSSAPI:
 425                         encryption = "partial(GSSAPI)";
 426                         break;
 427                 case SMB2_ENCRYPTION_AES128_CCM:
 428                         encryption = "partial(AES-128-CCM)";
 429                         break;
 430                 case SMB2_ENCRYPTION_AES128_GCM:
 431                         encryption = "partial(AES-128-GCM)";
 432                         break;
 433                 default:
 434                         encryption = "???";
 435                         result = -1;
 436                         break;
 437                 }
 438         }
 439
 440         if (smbXsrv_is_signed(session->signing_flags)) {
 441                 if (session->connection_dialect >= SMB3_DIALECT_REVISION_302) {
 442                         signing = "AES-128-CMAC";
 443                 } else if (session->connection_dialect >= SMB2_DIALECT_REVISION_202) {
 444                         signing = "HMAC-SHA256";
 445                 } else {
 446                         signing = "HMAC-MD5";
 447                 }
 448         } else if (smbXsrv_is_partially_signed(session->signing_flags)) {
 449                 if (session->connection_dialect >= SMB3_DIALECT_REVISION_302) {
 450                         signing = "partial(AES-128-CMAC)";
 451                 } else if (session->connection_dialect >= SMB2_DIALECT_REVISION_202) {
 452                         signing = "partial(HMAC-SHA256)";
 453                 } else {
 454                         signing = "partial(HMAC-MD5)";
 455                 }
 456         }
 457
 458
 459         d_printf("%-7s %-12s %-12s %-41s %-17s %-20s %-21s\n",
 460                  server_id_str_buf(session->pid, &tmp),
 461                  uid_str, gid_str,
 462                  machine_hostname,
 463                  session_dialect_str(session->connection_dialect),
 464                  encryption,
 465                  signing);
 466
 467         TALLOC_FREE(machine_hostname);
 468
 469         return result;
 470 }
 471
 472
 473 static bool print_notify_rec(const char *path, struct server_id server,
 474                              const struct notify_instance *instance,
 475                              void *private_data)
 476 {
 477         struct server_id_buf idbuf;
 478
 479         d_printf("%s\\%s\\%x\\%x\n", path, server_id_str_buf(server, &idbuf),
 480                  (unsigned)instance->filter,
 481                  (unsigned)instance->subdir_filter);
 482
 483         return true;
 484 }
 485
 486 int main(int argc, const char *argv[])
 487 {
 488         int c;
 489         int profile_only = 0;
 490         bool show_processes, show_locks, show_shares;
 491         bool show_notify = false;
 492         poptContext pc;
 493         struct poptOption long_options[] = {
 494                 POPT_AUTOHELP
 495                 {"processes",   'p', POPT_ARG_NONE,     NULL, 'p', "Show processes only" },
 496                 {"verbose",     'v', POPT_ARG_NONE,     NULL, 'v', "Be verbose" },
 497                 {"locks",       'L', POPT_ARG_NONE,     NULL, 'L', "Show locks only" },
 498                 {"shares",      'S', POPT_ARG_NONE,     NULL, 'S', "Show shares only" },
 499                 {"notify",      'N', POPT_ARG_NONE,     NULL, 'N', "Show notifies" },
 500                 {"user",        'u', POPT_ARG_STRING,   &username, 'u', "Switch to user" },
 501                 {"brief",       'b', POPT_ARG_NONE,     NULL, 'b', "Be brief" },
 502                 {"profile",     'P', POPT_ARG_NONE, NULL, 'P', "Do profiling" },
 503                 {"profile-rates", 'R', POPT_ARG_NONE, NULL, 'R', "Show call rates" },
 504                 {"byterange",   'B', POPT_ARG_NONE,     NULL, 'B', "Include byte range locks"},
 505                 {"numeric",     'n', POPT_ARG_NONE,     NULL, 'n', "Numeric uid/gid"},
 506                 {"fast",        'f', POPT_ARG_NONE,     NULL, 'f', "Skip checks if processes still exist"},
 507                 POPT_COMMON_SAMBA
 508                 POPT_TABLEEND
 509         };
 510         TALLOC_CTX *frame = talloc_stackframe();
 511         int ret = 0;
 512         struct messaging_context *msg_ctx = NULL;
 513         char *db_path;
 514         bool ok;
 515
 516         sec_init();
 517         smb_init_locale();
 518
 519         setup_logging(argv[0], DEBUG_STDERR);
 520         lp_set_cmdline("log level", "0");
 521
 522         if (getuid() != geteuid()) {
 523                 d_printf("smbstatus should not be run setuid\n");
 524                 ret = 1;
 525                 goto done;
 526         }
 527
 528         if (getuid() != 0) {
 529                 d_printf("smbstatus only works as root!\n");
 530                 ret = 1;
 531                 goto done;
 532         }
 533
 534
 535         pc = poptGetContext(NULL, argc, argv, long_options,
 536                             POPT_CONTEXT_KEEP_FIRST);
 537
 538         while ((c = poptGetNextOpt(pc)) != -1) {
 539                 switch (c) {
 540                 case 'p':
 541                         processes_only = true;
 542                         break;
 543                 case 'v':
 544                         verbose = true;
 545                         break;
 546                 case 'L':
 547                         locks_only = true;
 548                         break;
 549                 case 'S':
 550                         shares_only = true;
 551                         break;
 552                 case 'N':
 553                         show_notify = true;
 554                         break;
 555                 case 'b':
 556                         brief = true;
 557                         break;
 558                 case 'u':
 559                         Ucrit_addUid(nametouid(poptGetOptArg(pc)));
 560                         break;
 561                 case 'P':
 562                 case 'R':
 563                         profile_only = c;
 564                         break;
 565                 case 'B':
 566                         show_brl = true;
 567                         break;
 568                 case 'n':
 569                         numeric_only = true;
 570                         break;
 571                 case 'f':
 572                         do_checks = false;
 573                         break;
 574                 }
 575         }
 576
 577         /* setup the flags based on the possible combincations */
 578
 579         show_processes = !(shares_only || locks_only || profile_only) || processes_only;
 580         show_locks     = !(shares_only || processes_only || profile_only) || locks_only;
 581         show_shares    = !(processes_only || locks_only || profile_only) || shares_only;
 582
 583         if ( username )
 584                 Ucrit_addUid( nametouid(username) );
 585
 586         if (verbose) {
 587                 d_printf("using configfile = %s\n", get_dyn_CONFIGFILE());
 588         }
 589
 590         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
 591                 fprintf(stderr, "Can't load %s - run testparm to debug it\n",
 592                         get_dyn_CONFIGFILE());
 593                 ret = -1;
 594                 goto done;
 595         }
 596
 597
 598         /*
 599          * This implicitly initializes the global ctdbd connection,
 600          * usable by the db_open() calls further down.
 601          */
 602         msg_ctx = messaging_init(NULL, samba_tevent_context_init(NULL));
 603         if (msg_ctx == NULL) {
 604                 fprintf(stderr, "messaging_init failed\n");
 605                 ret = -1;
 606                 goto done;
 607         }
 608
 609         if (!lp_load_global(get_dyn_CONFIGFILE())) {
 610                 fprintf(stderr, "Can't load %s - run testparm to debug it\n",
 611                         get_dyn_CONFIGFILE());
 612                 ret = -1;
 613                 goto done;
 614         }
 615
 616         switch (profile_only) {
 617                 case 'P':
 618                         /* Dump profile data */
 619                         ok = status_profile_dump(verbose);
 620                         return ok ? 0 : 1;
 621                 case 'R':
 622                         /* Continuously display rate-converted data */
 623                         ok = status_profile_rates(verbose);
 624                         return ok ? 0 : 1;
 625                 default:
 626                         break;
 627         }
 628
 629         if ( show_processes ) {
 630                 d_printf("\nSamba version %s\n",samba_version_string());
 631                 d_printf("%-7s %-12s %-12s %-41s %-17s %-20s %-21s\n", "PID", "Username", "Group", "Machine", "Protocol Version", "Encryption", "Signing");
 632                 d_printf("----------------------------------------------------------------------------------------------------------------------------------------\n");
 633
 634                 sessionid_traverse_read(traverse_sessionid, frame);
 635
 636                 if (processes_only) {
 637                         goto done;
 638                 }
 639         }
 640
 641         if ( show_shares ) {
 642                 if (brief) {
 643                         goto done;
 644                 }
 645
 646                 d_printf("\n%-12s %-7s %-13s %-32s %-12s %-12s\n", "Service", "pid", "Machine", "Connected at", "Encryption", "Signing");
 647                 d_printf("---------------------------------------------------------------------------------------------\n");
 648
 649                 connections_forall_read(traverse_connections, frame);
 650
 651                 d_printf("\n");
 652
 653                 if ( shares_only ) {
 654                         goto done;
 655                 }
 656         }
 657
 658         if ( show_locks ) {
 659                 int result;
 660                 struct db_context *db;
 661
 662                 db_path = lock_path("locking.tdb");
 663                 if (db_path == NULL) {
 664                         d_printf("Out of memory - exiting\n");
 665                         ret = -1;
 666                         goto done;
 667                 }
 668
 669                 db = db_open(NULL, db_path, 0,
 670                              TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, O_RDONLY, 0,
 671                              DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE);
 672
 673                 if (!db) {
 674                         d_printf("%s not initialised\n", db_path);
 675                         d_printf("This is normal if an SMB client has never "
 676                                  "connected to your server.\n");
 677                         TALLOC_FREE(db_path);
 678                         exit(0);
 679                 } else {
 680                         TALLOC_FREE(db);
 681                         TALLOC_FREE(db_path);
 682                 }
 683
 684                 if (!locking_init_readonly()) {
 685                         d_printf("Can't initialise locking module - exiting\n");
 686                         ret = 1;
 687                         goto done;
 688                 }
 689
 690                 result = share_entry_forall(print_share_mode, NULL);
 691
 692                 if (result == 0) {
 693                         d_printf("No locked files\n");
 694                 } else if (result < 0) {
 695                         d_printf("locked file list truncated\n");
 696                 }
 697
 698                 d_printf("\n");
 699
 700                 if (show_brl) {
 701                         brl_forall(print_brl, NULL);
 702                 }
 703
 704                 locking_end();
 705         }
 706
 707         if (show_notify) {
 708                 struct notify_context *n;
 709
 710                 n = notify_init(talloc_tos(), msg_ctx,
 711                                 messaging_tevent_context(msg_ctx));
 712                 if (n == NULL) {
 713                         goto done;
 714                 }
 715                 notify_walk(n, print_notify_rec, NULL);
 716                 TALLOC_FREE(n);
 717         }
 718
 719 done:
 720         TALLOC_FREE(frame);
 721         return ret;
 722 }