source3/utils/net_g_lock.c

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