Line data Source code
1 : /*
2 : * Samba Unix/Linux SMB client library
3 : * Interface to the g_lock facility
4 : * Copyright (C) Volker Lendecke 2009
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 :
20 : #include "includes.h"
21 : #include "net.h"
22 : #include "lib/util/server_id.h"
23 : #include "g_lock.h"
24 : #include "messages.h"
25 : #include "lib/util/util_tdb.h"
26 :
27 0 : static bool net_g_lock_init(TALLOC_CTX *mem_ctx,
28 : struct tevent_context **pev,
29 : struct messaging_context **pmsg,
30 : struct g_lock_ctx **pg_ctx)
31 : {
32 0 : struct tevent_context *ev = NULL;
33 0 : struct messaging_context *msg = NULL;
34 0 : struct g_lock_ctx *g_ctx = NULL;
35 :
36 0 : ev = samba_tevent_context_init(mem_ctx);
37 0 : if (ev == NULL) {
38 0 : d_fprintf(stderr, "ERROR: could not init event context\n");
39 0 : goto fail;
40 : }
41 0 : msg = messaging_init(mem_ctx, ev);
42 0 : if (msg == NULL) {
43 0 : d_fprintf(stderr, "ERROR: could not init messaging context\n");
44 0 : goto fail;
45 : }
46 0 : g_ctx = g_lock_ctx_init(mem_ctx, msg);
47 0 : if (g_ctx == NULL) {
48 0 : d_fprintf(stderr, "ERROR: could not init g_lock context\n");
49 0 : goto fail;
50 : }
51 :
52 0 : *pev = ev;
53 0 : *pmsg = msg;
54 0 : *pg_ctx = g_ctx;
55 0 : return true;
56 0 : fail:
57 0 : TALLOC_FREE(g_ctx);
58 0 : TALLOC_FREE(msg);
59 0 : TALLOC_FREE(ev);
60 0 : return false;
61 : }
62 :
63 0 : static int net_g_lock_do(struct net_context *c, int argc, const char **argv)
64 : {
65 0 : struct g_lock_ctx *ctx = NULL;
66 0 : TDB_DATA key = {0};
67 0 : const char *cmd = NULL;
68 : int timeout;
69 : NTSTATUS status;
70 0 : int result = -1;
71 :
72 0 : if (argc != 3) {
73 0 : d_printf("Usage: net g_lock do <lockname> <timeout> "
74 : "<command>\n");
75 0 : return -1;
76 : }
77 0 : key = string_term_tdb_data(argv[0]);
78 0 : timeout = atoi(argv[1]);
79 0 : cmd = argv[2];
80 :
81 0 : ctx = g_lock_ctx_init(c, c->msg_ctx);
82 0 : if (ctx == NULL) {
83 0 : d_fprintf(stderr, _("g_lock_ctx_init failed\n"));
84 0 : return -1;
85 : }
86 0 : status = g_lock_lock(
87 : ctx,
88 : key,
89 : G_LOCK_WRITE,
90 0 : timeval_set(timeout / 1000, timeout % 1000));
91 0 : if (!NT_STATUS_IS_OK(status)) {
92 0 : d_fprintf(stderr,
93 0 : _("g_lock_lock failed: %s\n"),
94 : nt_errstr(status));
95 0 : goto done;
96 : }
97 :
98 0 : result = system(cmd);
99 :
100 0 : g_lock_unlock(ctx, key);
101 :
102 0 : if (result == -1) {
103 0 : d_fprintf(stderr, "ERROR: system() returned %s\n",
104 0 : strerror(errno));
105 0 : goto done;
106 : }
107 0 : d_fprintf(stderr, "command returned %d\n", result);
108 :
109 0 : done:
110 0 : TALLOC_FREE(ctx);
111 0 : return result;
112 : }
113 :
114 0 : static void net_g_lock_dump_fn(struct server_id exclusive,
115 : size_t num_shared,
116 : const struct server_id *shared,
117 : const uint8_t *data,
118 : size_t datalen,
119 : void *private_data)
120 : {
121 : struct server_id_buf idbuf;
122 :
123 0 : if (exclusive.pid != 0) {
124 0 : d_printf("%s: WRITE\n",
125 : server_id_str_buf(exclusive, &idbuf));
126 : } else {
127 : size_t i;
128 0 : for (i=0; i<num_shared; i++) {
129 0 : d_printf("%s: READ\n",
130 0 : server_id_str_buf(shared[i], &idbuf));
131 : }
132 : }
133 0 : dump_data_file(data, datalen, true, stdout);
134 0 : }
135 :
136 0 : static int net_g_lock_dump(struct net_context *c, int argc, const char **argv)
137 : {
138 0 : struct tevent_context *ev = NULL;
139 0 : struct messaging_context *msg = NULL;
140 0 : struct g_lock_ctx *g_ctx = NULL;
141 0 : int ret = -1;
142 :
143 0 : if (argc != 1) {
144 0 : d_printf("Usage: net g_lock dump <lockname>\n");
145 0 : return -1;
146 : }
147 :
148 0 : if (!net_g_lock_init(talloc_tos(), &ev, &msg, &g_ctx)) {
149 0 : goto done;
150 : }
151 :
152 0 : (void)g_lock_dump(g_ctx, string_term_tdb_data(argv[0]),
153 : net_g_lock_dump_fn, NULL);
154 :
155 0 : ret = 0;
156 0 : done:
157 0 : TALLOC_FREE(g_ctx);
158 0 : TALLOC_FREE(msg);
159 0 : TALLOC_FREE(ev);
160 0 : return ret;
161 : }
162 :
163 0 : static int net_g_lock_dumpall_fn(TDB_DATA key, void *private_data)
164 : {
165 0 : struct g_lock_ctx *g_ctx = talloc_get_type_abort(
166 : private_data, struct g_lock_ctx);
167 :
168 0 : dump_data_file(key.dptr, key.dsize, true, stdout);
169 0 : g_lock_dump(g_ctx, key, net_g_lock_dump_fn, NULL);
170 0 : printf("\n");
171 :
172 0 : return 0;
173 : }
174 :
175 0 : static int net_g_lock_dumpall(
176 : struct net_context *c, int argc, const char **argv)
177 : {
178 0 : struct tevent_context *ev = NULL;
179 0 : struct messaging_context *msg = NULL;
180 0 : struct g_lock_ctx *g_ctx = NULL;
181 0 : int ret = -1;
182 :
183 0 : if (argc != 0) {
184 0 : d_printf("Usage: net g_lock locks\n");
185 0 : return -1;
186 : }
187 :
188 0 : if (!net_g_lock_init(talloc_tos(), &ev, &msg, &g_ctx)) {
189 0 : goto done;
190 : }
191 :
192 0 : ret = g_lock_locks(g_ctx, net_g_lock_dumpall_fn, g_ctx);
193 0 : done:
194 0 : TALLOC_FREE(g_ctx);
195 0 : TALLOC_FREE(msg);
196 0 : TALLOC_FREE(ev);
197 0 : return ret < 0 ? -1 : ret;
198 : }
199 :
200 0 : static int net_g_lock_locks_fn(TDB_DATA key, void *private_data)
201 : {
202 0 : dump_data_file(key.dptr, key.dsize, true, stdout);
203 0 : return 0;
204 : }
205 :
206 0 : static int net_g_lock_locks(struct net_context *c, int argc, const char **argv)
207 : {
208 0 : struct tevent_context *ev = NULL;
209 0 : struct messaging_context *msg = NULL;
210 0 : struct g_lock_ctx *g_ctx = NULL;
211 0 : int ret = -1;
212 :
213 0 : if (argc != 0) {
214 0 : d_printf("Usage: net g_lock locks\n");
215 0 : return -1;
216 : }
217 :
218 0 : if (!net_g_lock_init(talloc_tos(), &ev, &msg, &g_ctx)) {
219 0 : goto done;
220 : }
221 :
222 0 : ret = g_lock_locks(g_ctx, net_g_lock_locks_fn, NULL);
223 0 : done:
224 0 : TALLOC_FREE(g_ctx);
225 0 : TALLOC_FREE(msg);
226 0 : TALLOC_FREE(ev);
227 0 : return ret < 0 ? -1 : ret;
228 : }
229 :
230 0 : int net_g_lock(struct net_context *c, int argc, const char **argv)
231 : {
232 0 : struct functable func[] = {
233 : {
234 : "do",
235 : net_g_lock_do,
236 : NET_TRANSPORT_LOCAL,
237 : N_("Execute a shell command under a lock"),
238 : N_("net g_lock do <lock name> <timeout> <command>\n")
239 : },
240 : {
241 : "locks",
242 : net_g_lock_locks,
243 : NET_TRANSPORT_LOCAL,
244 : N_("List all locknames"),
245 : N_("net g_lock locks\n")
246 : },
247 : {
248 : "dump",
249 : net_g_lock_dump,
250 : NET_TRANSPORT_LOCAL,
251 : N_("Dump a g_lock locking table"),
252 : N_("net g_lock dump <lock name>\n")
253 : },
254 : {
255 : "dumpall",
256 : net_g_lock_dumpall,
257 : NET_TRANSPORT_LOCAL,
258 : N_("Dump all g_lock locking tables"),
259 : N_("net g_lock dumpall\n")
260 : },
261 : {NULL, NULL, 0, NULL, NULL}
262 : };
263 :
264 0 : return net_run_function(c, argc, argv, "net g_lock", func);
265 : }
|
