r4088: Get medieval on our ass about malloc.... :-). Take control of all our allocation
[tprouty/samba.git] / source / 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 2 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, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
19
20 #include "includes.h"
21 #include "utils/net.h"
22
23 static int show_session(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
24                         void *state)
25 {
26         BOOL *parseable = (BOOL *)state;
27         struct sessionid sessionid;
28
29         if (dbuf.dsize != sizeof(sessionid))
30                 return 0;
31
32         memcpy(&sessionid, dbuf.dptr, sizeof(sessionid));
33
34         if (!process_exists(sessionid.pid)) {
35                 return 0;
36         }
37
38         if (*parseable) {
39                 d_printf("%d\\%s\\%s\\%s\\%s\n",
40                          (int)sessionid.pid, uidtoname(sessionid.uid),
41                          gidtoname(sessionid.gid), 
42                          sessionid.remote_machine, sessionid.hostname);
43         } else {
44                 d_printf("%5d   %-12s  %-12s  %-12s (%s)\n",
45                          (int)sessionid.pid, uidtoname(sessionid.uid),
46                          gidtoname(sessionid.gid), 
47                          sessionid.remote_machine, sessionid.hostname);
48         }
49
50         return 0;
51 }
52
53 static int net_status_sessions(int argc, const char **argv)
54 {
55         TDB_CONTEXT *tdb;
56         BOOL parseable;
57
58         if (argc == 0) {
59                 parseable = False;
60         } else if ((argc == 1) && strequal(argv[0], "parseable")) {
61                 parseable = True;
62         } else {
63                 return net_help_status(argc, argv);
64         }
65
66         if (!parseable) {
67                 d_printf("PID     Username      Group         Machine"
68                          "                        \n");
69                 d_printf("-------------------------------------------"
70                          "------------------------\n");
71         }
72
73         tdb = tdb_open_log(lock_path("sessionid.tdb"), 0,
74                            TDB_DEFAULT, O_RDONLY, 0);
75
76         if (tdb == NULL) {
77                 d_printf("%s not initialised\n", lock_path("sessionid.tdb"));
78                 return -1;
79         }
80
81         tdb_traverse(tdb, show_session, &parseable);
82         tdb_close(tdb);
83
84         return 0;
85 }
86
87 static int show_share(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
88                       void *state)
89 {
90         struct connections_data crec;
91
92         if (dbuf.dsize != sizeof(crec))
93                 return 0;
94
95         memcpy(&crec, dbuf.dptr, sizeof(crec));
96
97         if (crec.cnum == -1)
98                 return 0;
99
100         if (!process_exists(crec.pid)) {
101                 return 0;
102         }
103
104         d_printf("%-10.10s   %5d   %-12s  %s",
105                crec.name,(int)crec.pid,
106                crec.machine,
107                asctime(LocalTime(&crec.start)));
108
109         return 0;
110 }
111
112 struct sessionids {
113         int num_entries;
114         struct sessionid *entries;
115 };
116
117 static int collect_pid(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
118                        void *state)
119 {
120         struct sessionids *ids = (struct sessionids *)state;
121         struct sessionid sessionid;
122
123         if (dbuf.dsize != sizeof(sessionid))
124                 return 0;
125
126         memcpy(&sessionid, dbuf.dptr, sizeof(sessionid));
127
128         if (!process_exists(sessionid.pid))
129                 return 0;
130
131         ids->num_entries += 1;
132         ids->entries = SMB_REALLOC_ARRAY(ids->entries, struct sessionid, ids->num_entries);
133         ids->entries[ids->num_entries-1] = sessionid;
134
135         return 0;
136 }
137
138 static int show_share_parseable(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
139                                 void *state)
140 {
141         struct sessionids *ids = (struct sessionids *)state;
142         struct connections_data crec;
143         int i;
144         BOOL guest = True;
145
146         if (dbuf.dsize != sizeof(crec))
147                 return 0;
148
149         memcpy(&crec, dbuf.dptr, sizeof(crec));
150
151         if (crec.cnum == -1)
152                 return 0;
153
154         if (!process_exists(crec.pid)) {
155                 return 0;
156         }
157
158         for (i=0; i<ids->num_entries; i++) {
159                 if (ids->entries[i].pid == crec.pid) {
160                         guest = False;
161                         break;
162                 }
163         }
164
165         d_printf("%s\\%d\\%s\\%s\\%s\\%s\\%s",
166                  crec.name,(int)crec.pid,
167                  guest ? "" : uidtoname(ids->entries[i].uid),
168                  guest ? "" : gidtoname(ids->entries[i].gid),
169                  crec.machine, 
170                  guest ? "" : ids->entries[i].hostname,
171                  asctime(LocalTime(&crec.start)));
172
173         return 0;
174 }
175
176 static int net_status_shares_parseable(int argc, const char **argv)
177 {
178         struct sessionids ids;
179         TDB_CONTEXT *tdb;
180
181         ids.num_entries = 0;
182         ids.entries = NULL;
183
184         tdb = tdb_open_log(lock_path("sessionid.tdb"), 0,
185                            TDB_DEFAULT, O_RDONLY, 0);
186
187         if (tdb == NULL) {
188                 d_printf("%s not initialised\n", lock_path("sessionid.tdb"));
189                 return -1;
190         }
191
192         tdb_traverse(tdb, collect_pid, &ids);
193         tdb_close(tdb);
194
195         tdb = tdb_open_log(lock_path("connections.tdb"), 0,
196                            TDB_DEFAULT, O_RDONLY, 0);
197
198         if (tdb == NULL) {
199                 d_printf("%s not initialised\n", lock_path("connections.tdb"));
200                 d_printf("This is normal if no SMB client has ever connected "
201                          "to your server.\n");
202                 return -1;
203         }
204
205         tdb_traverse(tdb, show_share_parseable, &ids);
206         tdb_close(tdb);
207
208         SAFE_FREE(ids.entries);
209
210         return 0;
211 }
212
213 static int net_status_shares(int argc, const char **argv)
214 {
215         TDB_CONTEXT *tdb;
216
217         if (argc == 0) {
218
219                 d_printf("\nService      pid     machine       "
220                          "Connected at\n");
221                 d_printf("-------------------------------------"
222                          "------------------\n");
223
224                 tdb = tdb_open_log(lock_path("connections.tdb"), 0,
225                                    TDB_DEFAULT, O_RDONLY, 0);
226
227                 if (tdb == NULL) {
228                         d_printf("%s not initialised\n",
229                                  lock_path("connections.tdb"));
230                         d_printf("This is normal if no SMB client has ever "
231                                  "connected to your server.\n");
232                         return -1;
233                 }
234
235                 tdb_traverse(tdb, show_share, NULL);
236                 tdb_close(tdb);
237
238                 return 0;
239         }
240
241         if ((argc != 1) || !strequal(argv[0], "parseable")) {
242                 return net_help_status(argc, argv);
243         }
244
245         return net_status_shares_parseable(argc, argv);
246 }
247
248 int net_status(int argc, const char **argv)
249 {
250         struct functable func[] = {
251                 {"sessions", net_status_sessions},
252                 {"shares", net_status_shares},
253                 {NULL, NULL}
254         };
255         return net_run_function(argc, argv, func, net_help_status);
256 }