source3/utils/net_status.c

   1 /*
   2    Samba Unix/Linux SMB client library
   3    net status command -- possible replacement for smbstatus
   4    Copyright (C) 2003 Volker Lendecke (vl@samba.org)
   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 #include "includes.h"
  20 #include "utils/net.h"
  21
  22 int net_status_usage(struct net_context *c, int argc, const char **argv)
  23 {
  24         d_printf("  net status sessions [parseable] "
  25                  "Show list of open sessions\n");
  26         d_printf("  net status shares [parseable]   "
  27                  "Show list of open shares\n");
  28         return -1;
  29 }
  30
  31 static int show_session(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
  32                         void *state)
  33 {
  34         bool *parseable = (bool *)state;
  35         struct sessionid sessionid;
  36
  37         if (dbuf.dsize != sizeof(sessionid))
  38                 return 0;
  39
  40         memcpy(&sessionid, dbuf.dptr, sizeof(sessionid));
  41
  42         if (!process_exists(sessionid.pid)) {
  43                 return 0;
  44         }
  45
  46         if (*parseable) {
  47                 d_printf("%s\\%s\\%s\\%s\\%s\n",
  48                          procid_str_static(&sessionid.pid), uidtoname(sessionid.uid),
  49                          gidtoname(sessionid.gid),
  50                          sessionid.remote_machine, sessionid.hostname);
  51         } else {
  52                 d_printf("%7s   %-12s  %-12s  %-12s (%s)\n",
  53                          procid_str_static(&sessionid.pid), uidtoname(sessionid.uid),
  54                          gidtoname(sessionid.gid),
  55                          sessionid.remote_machine, sessionid.hostname);
  56         }
  57
  58         return 0;
  59 }
  60
  61 static int net_status_sessions(struct net_context *c, int argc, const char **argv)
  62 {
  63         TDB_CONTEXT *tdb;
  64         bool parseable;
  65
  66         if (argc == 0) {
  67                 parseable = false;
  68         } else if ((argc == 1) && strequal(argv[0], "parseable")) {
  69                 parseable = true;
  70         } else {
  71                 return net_status_usage(c, argc, argv);
  72         }
  73
  74         if (!parseable) {
  75                 d_printf("PID     Username      Group         Machine"
  76                          "                        \n");
  77                 d_printf("-------------------------------------------"
  78                          "------------------------\n");
  79         }
  80
  81         tdb = tdb_open_log(lock_path("sessionid.tdb"), 0,
  82                            TDB_DEFAULT, O_RDONLY, 0);
  83
  84         if (tdb == NULL) {
  85                 d_fprintf(stderr, "%s not initialised\n", lock_path("sessionid.tdb"));
  86                 return -1;
  87         }
  88
  89         tdb_traverse(tdb, show_session, &parseable);
  90         tdb_close(tdb);
  91
  92         return 0;
  93 }
  94
  95 static int show_share(struct db_record *rec,
  96                       const struct connections_key *key,
  97                       const struct connections_data *crec,
  98                       void *state)
  99 {
 100         if (crec->cnum == -1)
 101                 return 0;
 102
 103         if (!process_exists(crec->pid)) {
 104                 return 0;
 105         }
 106
 107         d_printf("%-10.10s   %s   %-12s  %s",
 108                crec->servicename, procid_str_static(&crec->pid),
 109                crec->machine,
 110                time_to_asc(crec->start));
 111
 112         return 0;
 113 }
 114
 115 struct sessionids {
 116         int num_entries;
 117         struct sessionid *entries;
 118 };
 119
 120 static int collect_pid(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
 121                        void *state)
 122 {
 123         struct sessionids *ids = (struct sessionids *)state;
 124         struct sessionid sessionid;
 125
 126         if (dbuf.dsize != sizeof(sessionid))
 127                 return 0;
 128
 129         memcpy(&sessionid, dbuf.dptr, sizeof(sessionid));
 130
 131         if (!process_exists(sessionid.pid))
 132                 return 0;
 133
 134         ids->num_entries += 1;
 135         ids->entries = SMB_REALLOC_ARRAY(ids->entries, struct sessionid, ids->num_entries);
 136         if (!ids->entries) {
 137                 ids->num_entries = 0;
 138                 return 0;
 139         }
 140         ids->entries[ids->num_entries-1] = sessionid;
 141
 142         return 0;
 143 }
 144
 145 static int show_share_parseable(struct db_record *rec,
 146                                 const struct connections_key *key,
 147                                 const struct connections_data *crec,
 148                                 void *state)
 149 {
 150         struct sessionids *ids = (struct sessionids *)state;
 151         int i;
 152         bool guest = true;
 153
 154         if (crec->cnum == -1)
 155                 return 0;
 156
 157         if (!process_exists(crec->pid)) {
 158                 return 0;
 159         }
 160
 161         for (i=0; i<ids->num_entries; i++) {
 162                 struct server_id id = ids->entries[i].pid;
 163                 if (procid_equal(&id, &crec->pid)) {
 164                         guest = false;
 165                         break;
 166                 }
 167         }
 168
 169         d_printf("%s\\%s\\%s\\%s\\%s\\%s\\%s",
 170                  crec->servicename,procid_str_static(&crec->pid),
 171                  guest ? "" : uidtoname(ids->entries[i].uid),
 172                  guest ? "" : gidtoname(ids->entries[i].gid),
 173                  crec->machine,
 174                  guest ? "" : ids->entries[i].hostname,
 175                  time_to_asc(crec->start));
 176
 177         return 0;
 178 }
 179
 180 static int net_status_shares_parseable(struct net_context *c, int argc, const char **argv)
 181 {
 182         struct sessionids ids;
 183         TDB_CONTEXT *tdb;
 184
 185         ids.num_entries = 0;
 186         ids.entries = NULL;
 187
 188         tdb = tdb_open_log(lock_path("sessionid.tdb"), 0,
 189                            TDB_DEFAULT, O_RDONLY, 0);
 190
 191         if (tdb == NULL) {
 192                 d_fprintf(stderr, "%s not initialised\n", lock_path("sessionid.tdb"));
 193                 return -1;
 194         }
 195
 196         tdb_traverse(tdb, collect_pid, &ids);
 197         tdb_close(tdb);
 198
 199         connections_forall(show_share_parseable, &ids);
 200
 201         SAFE_FREE(ids.entries);
 202
 203         return 0;
 204 }
 205
 206 static int net_status_shares(struct net_context *c, int argc, const char **argv)
 207 {
 208         if (argc == 0) {
 209
 210                 d_printf("\nService      pid     machine       "
 211                          "Connected at\n");
 212                 d_printf("-------------------------------------"
 213                          "------------------\n");
 214
 215                 connections_forall(show_share, NULL);
 216
 217                 return 0;
 218         }
 219
 220         if ((argc != 1) || !strequal(argv[0], "parseable")) {
 221                 return net_status_usage(c, argc, argv);
 222         }
 223
 224         return net_status_shares_parseable(c, argc, argv);
 225 }
 226
 227 int net_status(struct net_context *c, int argc, const char **argv)
 228 {
 229         struct functable func[] = {
 230                 {"sessions", net_status_sessions},
 231                 {"shares", net_status_shares},
 232                 {"help", net_status_usage},
 233                 {NULL, NULL}
 234         };
 235         return net_run_function(c, argc, argv, func, net_status_usage);
 236 }