2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1994-1998
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.
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.
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/>.
21 12 aug 96: Erik.Devriendt@te6.siemens.be
22 added support for shared memory implementation of share mode locking
24 21-Jul-1998: rsharpe@ns.aus.com (Richard Sharpe)
25 Added -L (locks only) -S (shares only) flags and code
30 * This program reports current SMB connections
34 #include "lib/util/server_id.h"
35 #include "smbd/globals.h"
36 #include "system/filesys.h"
37 #include "lib/cmdline/cmdline.h"
38 #include "dbwrap/dbwrap.h"
39 #include "dbwrap/dbwrap_open.h"
40 #include "../libcli/security/security.h"
42 #include "locking/share_mode_lock.h"
43 #include "locking/proto.h"
45 #include "librpc/gen_ndr/open_files.h"
46 #include "smbd/smbd.h"
47 #include "librpc/gen_ndr/notify.h"
50 #include "status_profile.h"
52 #include "status_json.h"
53 #include "smbd/notifyd/notifyd_db.h"
54 #include "cmdline_contexts.h"
55 #include "locking/leases_db.h"
56 #include "lib/util/string_wrappers.h"
60 #include "audit_logging.h" /* various JSON helpers */
61 #include "auth/common_auth.h"
62 #endif /* HAVE_JANSSON */
64 #define SMB_MAXPIDS 2048
65 static uid_t Ucrit_uid = 0; /* added by OH */
66 static struct server_id Ucrit_pid[SMB_MAXPIDS]; /* Ugly !!! */ /* added by OH */
67 static int Ucrit_MaxPid=0; /* added by OH */
68 static unsigned int Ucrit_IsActive = 0; /* added by OH */
70 static bool verbose, brief;
71 static bool shares_only; /* Added by RJS */
72 static bool locks_only; /* Added by RJS */
73 static bool processes_only;
75 static bool numeric_only;
76 static bool do_checks = true;
78 const char *username = NULL;
81 static void Ucrit_addUid(uid_t uid)
87 static unsigned int Ucrit_checkUid(uid_t uid)
89 if ( !Ucrit_IsActive )
92 if ( uid == Ucrit_uid )
98 static unsigned int Ucrit_checkPid(struct server_id pid)
102 if ( !Ucrit_IsActive )
105 for (i=0;i<Ucrit_MaxPid;i++) {
106 if (server_id_equal(&pid, &Ucrit_pid[i])) {
114 static bool Ucrit_addPid( struct server_id pid )
116 if ( !Ucrit_IsActive )
119 if ( Ucrit_MaxPid >= SMB_MAXPIDS ) {
120 fprintf(stderr, "ERROR: More than %d pids for user %s!\n",
121 SMB_MAXPIDS, uidtoname(Ucrit_uid));
126 Ucrit_pid[Ucrit_MaxPid++] = pid;
131 static int print_share_mode_stdout(struct traverse_state *state,
133 const char *user_name,
134 const char *denymode,
138 const char *servicepath,
139 const char *filename,
143 d_printf("\nLocked files:\n");
144 d_printf("Pid User(ID) DenyMode Access R/W Oplock SharePath Name Time\n");
145 d_printf("--------------------------------------------------------------------------------------------------\n");
147 state->first = false;
150 d_printf("%-11s %-9s %-10s 0x%-8x %-10s %-14s %s %s %s",
151 pid, user_name, denymode, access_mask, rw, oplock,
152 servicepath, filename, timestr);
156 static int prepare_share_mode(struct traverse_state *state)
158 if (!state->json_output) {
159 /* only print header line if there are open files */
162 add_section_to_json(state, "open_files");
167 static int print_share_mode(struct file_id fid,
168 const struct share_mode_data *d,
169 const struct share_mode_entry *e,
172 const char *denymode = NULL;
174 const char *oplock = NULL;
175 const char *pid = NULL;
176 const char *rw = NULL;
177 const char *filename = NULL;
178 const char *timestr = NULL;
179 const char *user_str = NULL;
181 struct traverse_state *state = (struct traverse_state *)private_data;
183 TALLOC_CTX *tmp_ctx = talloc_stackframe();
184 if (tmp_ctx == NULL) {
188 if (do_checks && !is_valid_share_mode_entry(e)) {
189 TALLOC_FREE(tmp_ctx);
193 if (do_checks && !serverid_exists(&e->pid)) {
194 /* the process for this entry does not exist any more */
195 TALLOC_FREE(tmp_ctx);
199 if (Ucrit_checkPid(e->pid)) {
200 struct server_id_buf tmp;
201 pid = server_id_str_buf(e->pid, &tmp);
202 if (state->resolve_uids) {
203 user_str = talloc_asprintf(tmp_ctx, "%s", uidtoname(e->uid));
205 user_str = talloc_asprintf(tmp_ctx, "%u", (unsigned int)e->uid);
207 if (user_str == NULL) {
208 TALLOC_FREE(tmp_ctx);
212 denymode_int = map_share_mode_to_deny_mode(e->share_access,
214 switch (denymode_int) {
216 denymode = "DENY_NONE";
219 denymode = "DENY_ALL";
222 denymode = "DENY_DOS";
225 denymode = "DENY_READ";
228 denymode = "DENY_WRITE";
231 denymode = "DENY_FCB";
234 denymode = talloc_asprintf(tmp_ctx,
237 if (denymode == NULL) {
238 TALLOC_FREE(tmp_ctx);
242 "unknown-please report ! "
243 "e->share_access = 0x%x, "
244 "e->private_options = 0x%x\n",
245 (unsigned int)e->share_access,
246 (unsigned int)e->private_options);
250 filename = talloc_asprintf(tmp_ctx,
253 (d->stream_name != NULL) ? d->stream_name : "");
254 if (filename == NULL) {
255 TALLOC_FREE(tmp_ctx);
258 if ((e->access_mask & (FILE_READ_DATA|FILE_WRITE_DATA))==
259 (FILE_READ_DATA|FILE_WRITE_DATA)) {
261 } else if (e->access_mask & FILE_WRITE_DATA) {
267 if (e->op_type & BATCH_OPLOCK) {
269 } else if (e->op_type & EXCLUSIVE_OPLOCK) {
270 oplock = "EXCLUSIVE";
271 } else if (e->op_type & LEVEL_II_OPLOCK) {
273 } else if (e->op_type == LEASE_OPLOCK) {
276 status = leases_db_get(
280 &lstate, /* current_state */
282 NULL, /* breaking_to_requested */
283 NULL, /* breaking_to_required */
284 NULL, /* lease_version */
287 if (NT_STATUS_IS_OK(status)) {
288 oplock = talloc_asprintf(tmp_ctx, "LEASE(%s%s%s)%s%s%s",
289 (lstate & SMB2_LEASE_READ)?"R":"",
290 (lstate & SMB2_LEASE_WRITE)?"W":"",
291 (lstate & SMB2_LEASE_HANDLE)?"H":"",
292 (lstate & SMB2_LEASE_READ)?"":" ",
293 (lstate & SMB2_LEASE_WRITE)?"":" ",
294 (lstate & SMB2_LEASE_HANDLE)?"":" ");
296 oplock = "LEASE STATE UNKNOWN";
302 timestr = time_to_asc((time_t)e->time.tv_sec);
304 if (!state->json_output) {
305 print_share_mode_stdout(state,
309 (unsigned int)e->access_mask,
316 print_share_mode_json(state,
326 TALLOC_FREE(tmp_ctx);
330 static void print_brl_stdout(struct traverse_state *state,
336 const char *sharepath,
340 d_printf("Byte range locks:\n");
341 d_printf("Pid dev:inode R/W start size SharePath Name\n");
342 d_printf("--------------------------------------------------------------------------------\n");
344 state->first = false;
346 d_printf("%-10s %-15s %-4s %-9jd %-9jd %-24s %-24s\n",
347 pid, id, desc, start, size, sharepath, fname);
350 static int prepare_brl(struct traverse_state *state)
352 /* only print header line if there are locked files */
358 static void print_brl(struct file_id id,
359 struct server_id pid,
360 enum brl_type lock_type,
361 enum brl_flavour lock_flav,
367 static const struct {
368 enum brl_type lock_type;
375 const char *desc="X";
376 const char *sharepath = "";
378 struct share_mode_lock *share_mode;
379 struct server_id_buf tmp;
380 struct file_id_buf ftmp;
381 struct traverse_state *state = (struct traverse_state *)private_data;
383 share_mode = fetch_share_mode_unlocked(NULL, id);
385 fname = share_mode_filename(NULL, share_mode);
386 sharepath = share_mode_servicepath(share_mode);
388 fname = talloc_strdup(NULL, "");
394 for (i=0;i<ARRAY_SIZE(lock_types);i++) {
395 if (lock_type == lock_types[i].lock_type) {
396 desc = lock_types[i].desc;
400 print_brl_stdout(state,
401 server_id_str_buf(pid, &tmp),
402 file_id_str_buf(id, &ftmp),
410 TALLOC_FREE(share_mode);
413 static const char *session_dialect_str(uint16_t dialect)
415 static fstring unknown_dialect;
418 case SMB2_DIALECT_REVISION_000:
420 case SMB2_DIALECT_REVISION_202:
422 case SMB2_DIALECT_REVISION_210:
424 case SMB2_DIALECT_REVISION_222:
426 case SMB2_DIALECT_REVISION_224:
428 case SMB3_DIALECT_REVISION_300:
430 case SMB3_DIALECT_REVISION_302:
432 case SMB3_DIALECT_REVISION_310:
434 case SMB3_DIALECT_REVISION_311:
438 fstr_sprintf(unknown_dialect, "Unknown (0x%04x)", dialect);
439 return unknown_dialect;
442 static int traverse_connections_stdout(struct traverse_state *state,
443 const char *servicename,
447 const char *encryption,
450 d_printf("%-12s %-7s %-13s %-32s %-12s %-12s\n",
451 servicename, server_id, machine, timestr, encryption, signing);
456 static int prepare_connections(struct traverse_state *state)
458 if (!state->json_output) {
459 /* always print header line */
460 d_printf("\n%-12s %-7s %-13s %-32s %-12s %-12s\n", "Service", "pid", "Machine", "Connected at", "Encryption", "Signing");
461 d_printf("---------------------------------------------------------------------------------------------\n");
463 add_section_to_json(state, "tcons");
468 static int traverse_connections(const struct connections_data *crec,
471 struct server_id_buf tmp;
472 char *timestr = NULL;
474 const char *encryption = "-";
475 enum crypto_degree encryption_degree = CRYPTO_DEGREE_NONE;
476 const char *signing = "-";
477 enum crypto_degree signing_degree = CRYPTO_DEGREE_NONE;
478 struct traverse_state *state = (struct traverse_state *)private_data;
480 TALLOC_CTX *tmp_ctx = talloc_stackframe();
481 if (tmp_ctx == NULL) {
485 if (crec->cnum == TID_FIELD_INVALID) {
486 TALLOC_FREE(tmp_ctx);
491 (!process_exists(crec->pid) || !Ucrit_checkUid(crec->uid))) {
492 TALLOC_FREE(tmp_ctx);
496 timestr = timestring(tmp_ctx, nt_time_to_unix(crec->start));
497 if (timestr == NULL) {
498 TALLOC_FREE(tmp_ctx);
502 if (smbXsrv_is_encrypted(crec->encryption_flags)) {
503 switch (crec->cipher) {
504 case SMB_ENCRYPTION_GSSAPI:
505 encryption = "GSSAPI";
507 case SMB2_ENCRYPTION_AES128_CCM:
508 encryption = "AES-128-CCM";
510 case SMB2_ENCRYPTION_AES128_GCM:
511 encryption = "AES-128-GCM";
518 encryption_degree = CRYPTO_DEGREE_FULL;
521 if (smbXsrv_is_signed(crec->signing_flags)) {
522 switch (crec->signing) {
523 case SMB2_SIGNING_MD5_SMB1:
524 signing = "HMAC-MD5";
526 case SMB2_SIGNING_HMAC_SHA256:
527 signing = "HMAC-SHA256";
529 case SMB2_SIGNING_AES128_CMAC:
530 signing = "AES-128-CMAC";
532 case SMB2_SIGNING_AES128_GMAC:
533 signing = "AES-128-GMAC";
540 signing_degree = CRYPTO_DEGREE_FULL;
543 if (!state->json_output) {
544 result = traverse_connections_stdout(state,
546 server_id_str_buf(crec->pid, &tmp),
552 result = traverse_connections_json(state,
560 TALLOC_FREE(timestr);
561 TALLOC_FREE(tmp_ctx);
566 static int traverse_sessionid_stdout(struct traverse_state *state,
569 char *machine_hostname,
571 const char *encryption_cipher,
572 enum crypto_degree encryption_degree,
573 const char *signing_cipher,
574 enum crypto_degree signing_degree)
579 if (encryption_degree == CRYPTO_DEGREE_FULL) {
580 fstr_sprintf(encryption, "%s", encryption_cipher);
581 } else if (encryption_degree == CRYPTO_DEGREE_PARTIAL) {
582 fstr_sprintf(encryption, "partial(%s)", encryption_cipher);
584 fstr_sprintf(encryption, "-");
586 if (signing_degree == CRYPTO_DEGREE_FULL) {
587 fstr_sprintf(signing, "%s", signing_cipher);
588 } else if (signing_degree == CRYPTO_DEGREE_PARTIAL) {
589 fstr_sprintf(signing, "partial(%s)", signing_cipher);
591 fstr_sprintf(signing, "-");
594 d_printf("%-7s %-25s %-41s %-17s %-20s %-21s\n",
595 server_id, uid_gid_str, machine_hostname, dialect, encryption,
601 static int prepare_sessionid(struct traverse_state *state)
603 if (!state->json_output) {
604 /* always print header line */
605 d_printf("\nSamba version %s\n",samba_version_string());
606 d_printf("%-7s %-12s %-12s %-41s %-17s %-20s %-21s\n", "PID", "Username", "Group", "Machine", "Protocol Version", "Encryption", "Signing");
607 d_printf("----------------------------------------------------------------------------------------------------------------------------------------\n");
609 add_section_to_json(state, "sessions");
615 static int traverse_sessionid(const char *key, struct sessionid *session,
621 struct server_id_buf tmp;
622 char *machine_hostname = NULL;
624 const char *encryption = "-";
625 enum crypto_degree encryption_degree = CRYPTO_DEGREE_NONE;
626 const char *signing = "-";
627 enum crypto_degree signing_degree = CRYPTO_DEGREE_NONE;
628 struct traverse_state *state = (struct traverse_state *)private_data;
630 TALLOC_CTX *tmp_ctx = talloc_stackframe();
631 if (tmp_ctx == NULL) {
636 (!process_exists(session->pid) ||
637 !Ucrit_checkUid(session->uid))) {
638 TALLOC_FREE(tmp_ctx);
642 Ucrit_addPid(session->pid);
645 fstr_sprintf(gid_str, "%u", (unsigned int)session->gid);
646 fstr_sprintf(uid_str, "%u", (unsigned int)session->uid);
647 fstr_sprintf(uid_gid_str, "%-12u %-12u",
648 (unsigned int)session->uid,
649 (unsigned int)session->gid);
651 if (session->uid == -1 && session->gid == -1) {
653 * The session is not fully authenticated yet.
655 fstrcpy(uid_gid_str, "(auth in progress)");
656 fstrcpy(gid_str, "(auth in progress)");
657 fstrcpy(uid_str, "(auth in progress)");
660 * In theory it should not happen that one of
661 * session->uid and session->gid is valid (ie != -1)
662 * while the other is not (ie = -1), so we a check for
663 * that case that bails out would be reasonable.
665 const char *uid_name = "-1";
666 const char *gid_name = "-1";
668 if (session->uid != -1) {
669 uid_name = uidtoname(session->uid);
670 if (uid_name == NULL) {
671 TALLOC_FREE(tmp_ctx);
675 if (session->gid != -1) {
676 gid_name = gidtoname(session->gid);
677 if (gid_name == NULL) {
678 TALLOC_FREE(tmp_ctx);
682 fstr_sprintf(gid_str, "%s", gid_name);
683 fstr_sprintf(uid_str, "%s", uid_name);
684 fstr_sprintf(uid_gid_str, "%-12s %-12s",
689 machine_hostname = talloc_asprintf(tmp_ctx, "%s (%s)",
690 session->remote_machine,
692 if (machine_hostname == NULL) {
693 TALLOC_FREE(tmp_ctx);
697 if (smbXsrv_is_encrypted(session->encryption_flags) ||
698 smbXsrv_is_partially_encrypted(session->encryption_flags)) {
699 switch (session->cipher) {
700 case SMB2_ENCRYPTION_AES128_CCM:
701 encryption = "AES-128-CCM";
703 case SMB2_ENCRYPTION_AES128_GCM:
704 encryption = "AES-128-GCM";
706 case SMB2_ENCRYPTION_AES256_CCM:
707 encryption = "AES-256-CCM";
709 case SMB2_ENCRYPTION_AES256_GCM:
710 encryption = "AES-256-GCM";
717 if (smbXsrv_is_encrypted(session->encryption_flags)) {
718 encryption_degree = CRYPTO_DEGREE_FULL;
719 } else if (smbXsrv_is_partially_encrypted(session->encryption_flags)) {
720 encryption_degree = CRYPTO_DEGREE_PARTIAL;
724 if (smbXsrv_is_signed(session->signing_flags) ||
725 smbXsrv_is_partially_signed(session->signing_flags)) {
726 switch (session->signing) {
727 case SMB2_SIGNING_MD5_SMB1:
728 signing = "HMAC-MD5";
730 case SMB2_SIGNING_HMAC_SHA256:
731 signing = "HMAC-SHA256";
733 case SMB2_SIGNING_AES128_CMAC:
734 signing = "AES-128-CMAC";
736 case SMB2_SIGNING_AES128_GMAC:
737 signing = "AES-128-GMAC";
744 if (smbXsrv_is_signed(session->signing_flags)) {
745 signing_degree = CRYPTO_DEGREE_FULL;
746 } else if (smbXsrv_is_partially_signed(session->signing_flags)) {
747 signing_degree = CRYPTO_DEGREE_PARTIAL;
752 if (!state->json_output) {
753 traverse_sessionid_stdout(state,
754 server_id_str_buf(session->pid, &tmp),
757 session_dialect_str(session->connection_dialect),
763 result = traverse_sessionid_json(state,
771 session_dialect_str(session->connection_dialect));
774 TALLOC_FREE(machine_hostname);
775 TALLOC_FREE(tmp_ctx);
781 static bool print_notify_rec_stdout(struct traverse_state *state,
785 unsigned subdir_filter)
787 d_printf("%s\\%s\\%x\\%x\n", path, server_id_str,
788 filter, subdir_filter);
793 static int prepare_notify(struct traverse_state *state)
795 /* don't print header line */
800 static bool print_notify_rec(const char *path, struct server_id server,
801 const struct notify_instance *instance,
804 struct server_id_buf idbuf;
805 struct traverse_state *state = (struct traverse_state *)private_data;
808 result = print_notify_rec_stdout(state,
810 server_id_str_buf(server, &idbuf),
811 (unsigned)instance->filter,
812 (unsigned)instance->subdir_filter);
818 OPT_RESOLVE_UIDS = 1000,
821 int main(int argc, const char *argv[])
824 int profile_only = 0;
825 bool show_processes, show_locks, show_shares;
826 bool show_notify = false;
827 poptContext pc = NULL;
828 struct traverse_state state = {0};
829 struct poptOption long_options[] = {
832 .longName = "processes",
834 .argInfo = POPT_ARG_NONE,
837 .descrip = "Show processes only",
840 .longName = "verbose",
842 .argInfo = POPT_ARG_NONE,
845 .descrip = "Be verbose",
850 .argInfo = POPT_ARG_NONE,
853 .descrip = "Show locks only",
856 .longName = "shares",
858 .argInfo = POPT_ARG_NONE,
861 .descrip = "Show shares only",
864 .longName = "notify",
866 .argInfo = POPT_ARG_NONE,
869 .descrip = "Show notifies",
874 .argInfo = POPT_ARG_STRING,
877 .descrip = "Switch to user",
882 .argInfo = POPT_ARG_NONE,
885 .descrip = "Be brief",
888 .longName = "profile",
890 .argInfo = POPT_ARG_NONE,
893 .descrip = "Do profiling",
896 .longName = "profile-rates",
898 .argInfo = POPT_ARG_NONE,
901 .descrip = "Show call rates",
904 .longName = "byterange",
906 .argInfo = POPT_ARG_NONE,
909 .descrip = "Include byte range locks"
912 .longName = "numeric",
914 .argInfo = POPT_ARG_NONE,
917 .descrip = "Numeric uid/gid"
922 .argInfo = POPT_ARG_NONE,
925 .descrip = "Skip checks if processes still exist"
928 .longName = "resolve-uids",
930 .argInfo = POPT_ARG_NONE,
932 .val = OPT_RESOLVE_UIDS,
933 .descrip = "Try to resolve UIDs to usernames"
939 TALLOC_CTX *frame = talloc_stackframe();
941 struct messaging_context *msg_ctx = NULL;
946 state.json_output = false;
947 state.resolve_uids = false;
951 ok = samba_cmdline_init(frame,
952 SAMBA_CMDLINE_CONFIG_CLIENT,
953 false /* require_smbconf */);
955 DBG_ERR("Failed to init cmdline parser!\n");
959 lp_set_cmdline("log level", "0");
961 pc = samba_popt_get_context(getprogname(),
965 POPT_CONTEXT_KEEP_FIRST);
967 DBG_ERR("Failed to setup popt context!\n");
972 while ((c = poptGetNextOpt(pc)) != -1) {
975 processes_only = true;
993 Ucrit_addUid(nametouid(poptGetOptArg(pc)));
1003 numeric_only = true;
1008 case OPT_RESOLVE_UIDS:
1009 state.resolve_uids = true;
1011 case POPT_ERROR_BADOPT:
1012 fprintf(stderr, "\nInvalid option %s: %s\n\n",
1013 poptBadOption(pc, 0), poptStrerror(c));
1014 poptPrintUsage(pc, stderr, 0);
1022 state.root_json = json_new_object();
1023 add_general_information_to_json(&state);
1024 #endif /* HAVE_JANSSON */
1026 if (getuid() != geteuid()) {
1027 fprintf(stderr, "smbstatus should not be run setuid\n");
1032 if (getuid() != 0) {
1033 fprintf(stderr, "smbstatus only works as root!\n");
1038 /* setup the flags based on the possible combincations */
1040 show_processes = !(shares_only || locks_only || profile_only) || processes_only;
1041 show_locks = !(shares_only || processes_only || profile_only) || locks_only;
1042 show_shares = !(processes_only || locks_only || profile_only) || shares_only;
1045 Ucrit_addUid( nametouid(username) );
1048 d_printf("using configfile = %s\n", get_dyn_CONFIGFILE());
1051 msg_ctx = cmdline_messaging_context(get_dyn_CONFIGFILE());
1052 if (msg_ctx == NULL) {
1053 fprintf(stderr, "Could not initialize messaging, not root?\n");
1058 switch (profile_only) {
1060 /* Dump profile data */
1061 ok = status_profile_dump(verbose);
1065 /* Continuously display rate-converted data */
1066 ok = status_profile_rates(verbose);
1073 if ( show_processes ) {
1074 prepare_sessionid(&state);
1075 sessionid_traverse_read(traverse_sessionid, &state);
1077 if (processes_only) {
1082 if ( show_shares ) {
1086 prepare_connections(&state);
1087 connections_forall_read(traverse_connections, &state);
1091 if ( shares_only ) {
1098 struct db_context *db;
1100 db_path = lock_path(talloc_tos(), "locking.tdb");
1101 if (db_path == NULL) {
1102 fprintf(stderr, "Out of memory - exiting\n");
1107 db = db_open(NULL, db_path, 0,
1108 TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, O_RDONLY, 0,
1109 DBWRAP_LOCK_ORDER_1, DBWRAP_FLAG_NONE);
1112 fprintf(stderr, "%s not initialised\n", db_path);
1113 fprintf(stderr, "This is normal if an SMB client has never "
1114 "connected to your server.\n");
1115 TALLOC_FREE(db_path);
1119 TALLOC_FREE(db_path);
1122 if (!locking_init_readonly()) {
1123 fprintf(stderr, "Can't initialise locking module - exiting\n");
1128 prepare_share_mode(&state);
1129 result = share_entry_forall(print_share_mode, &state);
1132 fprintf(stderr, "No locked files\n");
1133 } else if (result < 0) {
1134 fprintf(stderr, "locked file list truncated\n");
1140 prepare_brl(&state);
1141 brl_forall(print_brl, &state);
1148 prepare_notify(&state);
1149 notify_walk(msg_ctx, print_notify_rec, &state);
1153 cmdline_messaging_context_free();
1154 poptFreeContext(pc);