import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.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 = Realloc(ids->entries,
133                                sizeof(struct sessionid) * ids->num_entries);
134         ids->entries[ids->num_entries-1] = sessionid;
135
136         return 0;
137 }
138
139 static int show_share_parseable(TDB_CONTEXT *tdb, TDB_DATA kbuf, TDB_DATA dbuf,
140                                 void *state)
141 {
142         struct sessionids *ids = (struct sessionids *)state;
143         struct connections_data crec;
144         int i;
145         BOOL guest = True;
146
147         if (dbuf.dsize != sizeof(crec))
148                 return 0;
149
150         memcpy(&crec, dbuf.dptr, sizeof(crec));
151
152         if (crec.cnum == -1)
153                 return 0;
154
155         if (!process_exists(crec.pid)) {
156                 return 0;
157         }
158
159         for (i=0; i<ids->num_entries; i++) {
160                 if (ids->entries[i].pid == crec.pid) {
161                         guest = False;
162                         break;
163                 }
164         }
165
166         d_printf("%s\\%d\\%s\\%s\\%s\\%s\\%s",
167                  crec.name,(int)crec.pid,
168                  guest ? "" : uidtoname(ids->entries[i].uid),
169                  guest ? "" : gidtoname(ids->entries[i].gid),
170                  crec.machine, 
171                  guest ? "" : ids->entries[i].hostname,
172                  asctime(LocalTime(&crec.start)));
173
174         return 0;
175 }
176
177 static int net_status_shares_parseable(int argc, const char **argv)
178 {
179         struct sessionids ids;
180         TDB_CONTEXT *tdb;
181
182         ids.num_entries = 0;
183         ids.entries = NULL;
184
185         tdb = tdb_open_log(lock_path("sessionid.tdb"), 0,
186                            TDB_DEFAULT, O_RDONLY, 0);
187
188         if (tdb == NULL) {
189                 d_printf("%s not initialised\n", lock_path("sessionid.tdb"));
190                 return -1;
191         }
192
193         tdb_traverse(tdb, collect_pid, &ids);
194         tdb_close(tdb);
195
196         tdb = tdb_open_log(lock_path("connections.tdb"), 0,
197                            TDB_DEFAULT, O_RDONLY, 0);
198
199         if (tdb == NULL) {
200                 d_printf("%s not initialised\n", lock_path("connections.tdb"));
201                 d_printf("This is normal if no SMB client has ever connected "
202                          "to your server.\n");
203                 return -1;
204         }
205
206         tdb_traverse(tdb, show_share_parseable, &ids);
207         tdb_close(tdb);
208
209         SAFE_FREE(ids.entries);
210
211         return 0;
212 }
213
214 static int net_status_shares(int argc, const char **argv)
215 {
216         TDB_CONTEXT *tdb;
217
218         if (argc == 0) {
219
220                 d_printf("\nService      pid     machine       "
221                          "Connected at\n");
222                 d_printf("-------------------------------------"
223                          "------------------\n");
224
225                 tdb = tdb_open_log(lock_path("connections.tdb"), 0,
226                                    TDB_DEFAULT, O_RDONLY, 0);
227
228                 if (tdb == NULL) {
229                         d_printf("%s not initialised\n",
230                                  lock_path("connections.tdb"));
231                         d_printf("This is normal if no SMB client has ever "
232                                  "connected to your server.\n");
233                         return -1;
234                 }
235
236                 tdb_traverse(tdb, show_share, NULL);
237                 tdb_close(tdb);
238
239                 return 0;
240         }
241
242         if ((argc != 1) || !strequal(argv[0], "parseable")) {
243                 return net_help_status(argc, argv);
244         }
245
246         return net_status_shares_parseable(argc, argv);
247 }
248
249 int net_status(int argc, const char **argv)
250 {
251         struct functable func[] = {
252                 {"sessions", net_status_sessions},
253                 {"shares", net_status_shares},
254                 {NULL, NULL}
255         };
256         return net_run_function(argc, argv, func, net_help_status);
257 }