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(
  87                 ctx,
  88                 key,
  89                 G_LOCK_WRITE,
  90                 timeval_set(timeout / 1000, timeout % 1000));
  91         if (!NT_STATUS_IS_OK(status)) {
  92                 d_fprintf(stderr,
  93                           _("g_lock_lock failed: %s\n"),
  94                           nt_errstr(status));
  95                 goto done;
  96         }
  97
  98         result = system(cmd);
  99
 100         g_lock_unlock(ctx, key);
 101
 102         if (result == -1) {
 103                 d_fprintf(stderr, "ERROR: system() returned %s\n",
 104                           strerror(errno));
 105                 goto done;
 106         }
 107         d_fprintf(stderr, "command returned %d\n", result);
 108
 109 done:
 110         TALLOC_FREE(ctx);
 111         return result;
 112 }
 113
 114 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         if (exclusive.pid != 0) {
 124                 d_printf("%s: WRITE\n",
 125                          server_id_str_buf(exclusive, &idbuf));
 126         } else {
 127                 size_t i;
 128                 for (i=0; i<num_shared; i++) {
 129                         d_printf("%s: READ\n",
 130                                  server_id_str_buf(shared[i], &idbuf));
 131                 }
 132         }
 133         dump_data_file(data, datalen, true, stdout);
 134 }
 135
 136 static int net_g_lock_dump(struct net_context *c, int argc, const char **argv)
 137 {
 138         struct tevent_context *ev = NULL;
 139         struct messaging_context *msg = NULL;
 140         struct g_lock_ctx *g_ctx = NULL;
 141         int ret = -1;
 142
 143         if (argc != 1) {
 144                 d_printf("Usage: net g_lock dump <lockname>\n");
 145                 return -1;
 146         }
 147
 148         if (!net_g_lock_init(talloc_tos(), &ev, &msg, &g_ctx)) {
 149                 goto done;
 150         }
 151
 152         (void)g_lock_dump(g_ctx, string_term_tdb_data(argv[0]),
 153                           net_g_lock_dump_fn, NULL);
 154
 155         ret = 0;
 156 done:
 157         TALLOC_FREE(g_ctx);
 158         TALLOC_FREE(msg);
 159         TALLOC_FREE(ev);
 160         return ret;
 161 }
 162
 163 static int net_g_lock_dumpall_fn(TDB_DATA key, void *private_data)
 164 {
 165         struct g_lock_ctx *g_ctx = talloc_get_type_abort(
 166                 private_data, struct g_lock_ctx);
 167
 168         dump_data_file(key.dptr, key.dsize, true, stdout);
 169         g_lock_dump(g_ctx, key, net_g_lock_dump_fn, NULL);
 170         printf("\n");
 171
 172         return 0;
 173 }
 174
 175 static int net_g_lock_dumpall(
 176         struct net_context *c, int argc, const char **argv)
 177 {
 178         struct tevent_context *ev = NULL;
 179         struct messaging_context *msg = NULL;
 180         struct g_lock_ctx *g_ctx = NULL;
 181         int ret = -1;
 182
 183         if (argc != 0) {
 184                 d_printf("Usage: net g_lock locks\n");
 185                 return -1;
 186         }
 187
 188         if (!net_g_lock_init(talloc_tos(), &ev, &msg, &g_ctx)) {
 189                 goto done;
 190         }
 191
 192         ret = g_lock_locks(g_ctx, net_g_lock_dumpall_fn, g_ctx);
 193 done:
 194         TALLOC_FREE(g_ctx);
 195         TALLOC_FREE(msg);
 196         TALLOC_FREE(ev);
 197         return ret < 0 ? -1 : ret;
 198 }
 199
 200 static int net_g_lock_locks_fn(TDB_DATA key, void *private_data)
 201 {
 202         dump_data_file(key.dptr, key.dsize, true, stdout);
 203         return 0;
 204 }
 205
 206 static int net_g_lock_locks(struct net_context *c, int argc, const char **argv)
 207 {
 208         struct tevent_context *ev = NULL;
 209         struct messaging_context *msg = NULL;
 210         struct g_lock_ctx *g_ctx = NULL;
 211         int ret = -1;
 212
 213         if (argc != 0) {
 214                 d_printf("Usage: net g_lock locks\n");
 215                 return -1;
 216         }
 217
 218         if (!net_g_lock_init(talloc_tos(), &ev, &msg, &g_ctx)) {
 219                 goto done;
 220         }
 221
 222         ret = g_lock_locks(g_ctx, net_g_lock_locks_fn, NULL);
 223 done:
 224         TALLOC_FREE(g_ctx);
 225         TALLOC_FREE(msg);
 226         TALLOC_FREE(ev);
 227         return ret < 0 ? -1 : ret;
 228 }
 229
 230 int net_g_lock(struct net_context *c, int argc, const char **argv)
 231 {
 232         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         return net_run_function(c, argc, argv, "net g_lock", func);
 265 }