source3/lib/netapi/serverinfo.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  NetApi Server Support
   4  *  Copyright (C) Guenther Deschner 2007
   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
  22 #include "lib/netapi/netapi.h"
  23 #include "libnet/libnet.h"
  24
  25 /****************************************************************
  26 ****************************************************************/
  27
  28 static WERROR NetServerGetInfoLocal_1005(struct libnetapi_ctx *ctx,
  29                                          uint8_t **buffer)
  30 {
  31         struct srvsvc_NetSrvInfo1005 info1005;
  32
  33         info1005.comment = lp_serverstring();
  34         *buffer = (uint8_t *)talloc_memdup(ctx, &info1005, sizeof(info1005));
  35         if (!*buffer) {
  36                 return WERR_NOMEM;
  37         }
  38
  39         return WERR_OK;
  40 }
  41
  42 /****************************************************************
  43 ****************************************************************/
  44
  45 static WERROR NetServerGetInfoLocal(struct libnetapi_ctx *ctx,
  46                                     const char *server_name,
  47                                     uint32_t level,
  48                                     uint8_t **buffer)
  49 {
  50         switch (level) {
  51                 case 1005:
  52                         return NetServerGetInfoLocal_1005(ctx, buffer);
  53                 default:
  54                         return WERR_UNKNOWN_LEVEL;
  55         }
  56
  57         return WERR_UNKNOWN_LEVEL;
  58 }
  59
  60 /****************************************************************
  61 ****************************************************************/
  62
  63 static WERROR NetServerGetInfoRemote(struct libnetapi_ctx *ctx,
  64                                      const char *server_name,
  65                                      uint32_t level,
  66                                      uint8_t **buffer)
  67 {
  68         struct cli_state *cli = NULL;
  69         struct rpc_pipe_client *pipe_cli = NULL;
  70         NTSTATUS status;
  71         WERROR werr;
  72         union srvsvc_NetSrvInfo info;
  73
  74         status = cli_full_connection(&cli, NULL, server_name,
  75                                      NULL, 0,
  76                                      "IPC$", "IPC",
  77                                      ctx->username,
  78                                      ctx->workgroup,
  79                                      ctx->password,
  80                                      0, Undefined, NULL);
  81
  82         if (!NT_STATUS_IS_OK(status)) {
  83                 werr = ntstatus_to_werror(status);
  84                 goto done;
  85         }
  86
  87         pipe_cli = cli_rpc_pipe_open_noauth(cli, PI_SRVSVC,
  88                                             &status);
  89         if (!pipe_cli) {
  90                 werr = ntstatus_to_werror(status);
  91                 goto done;
  92         };
  93
  94         status = rpccli_srvsvc_NetSrvGetInfo(pipe_cli, ctx,
  95                                              server_name,
  96                                              level,
  97                                              &info,
  98                                              &werr);
  99         if (!NT_STATUS_IS_OK(status)) {
 100                 werr = ntstatus_to_werror(status);
 101                 goto done;
 102         }
 103
 104         *buffer = (uint8_t *)&info;
 105
 106  done:
 107         if (cli) {
 108                 cli_shutdown(cli);
 109         }
 110
 111         return werr;
 112 }
 113
 114 /****************************************************************
 115 ****************************************************************/
 116
 117 static WERROR libnetapi_NetServerGetInfo(struct libnetapi_ctx *ctx,
 118                                          const char *server_name,
 119                                          uint32_t level,
 120                                          uint8_t **buffer)
 121 {
 122         if (!server_name || is_myname_or_ipaddr(server_name)) {
 123                 return NetServerGetInfoLocal(ctx,
 124                                              server_name,
 125                                              level,
 126                                              buffer);
 127         }
 128
 129         return NetServerGetInfoRemote(ctx,
 130                                       server_name,
 131                                       level,
 132                                       buffer);
 133
 134 }
 135
 136 /****************************************************************
 137  NetServerGetInfo
 138 ****************************************************************/
 139
 140 NET_API_STATUS NetServerGetInfo(const char *server_name,
 141                                 uint32_t level,
 142                                 uint8_t **buffer)
 143 {
 144         struct libnetapi_ctx *ctx = NULL;
 145         NET_API_STATUS status;
 146         WERROR werr;
 147
 148         status = libnetapi_getctx(&ctx);
 149         if (status != 0) {
 150                 return status;
 151         }
 152
 153         werr = libnetapi_NetServerGetInfo(ctx,
 154                                           server_name,
 155                                           level,
 156                                           buffer);
 157         if (!W_ERROR_IS_OK(werr)) {
 158                 return W_ERROR_V(werr);
 159         }
 160
 161         return NET_API_STATUS_SUCCESS;
 162 }
 163
 164 /****************************************************************
 165 ****************************************************************/
 166
 167 static WERROR NetServerSetInfoLocal_1005(struct libnetapi_ctx *ctx,
 168                                          uint8_t *buffer,
 169                                          uint32_t *parm_error)
 170 {
 171         WERROR werr;
 172         struct libnet_conf_ctx *conf_ctx;
 173         struct srvsvc_NetSrvInfo1005 *info1005;
 174
 175         if (!buffer) {
 176                 *parm_error = 1005; /* sure here ? */
 177                 return WERR_INVALID_PARAM;
 178         }
 179
 180         info1005 = (struct srvsvc_NetSrvInfo1005 *)buffer;
 181
 182         if (!info1005->comment) {
 183                 *parm_error = 1005;
 184                 return WERR_INVALID_PARAM;
 185         }
 186
 187         if (!lp_config_backend_is_registry()) {
 188                 libnetapi_set_error_string(ctx,
 189                         "Configuration manipulation requested but not "
 190                         "supported by backend");
 191                 return WERR_NOT_SUPPORTED;
 192         }
 193
 194         werr = libnet_conf_open(ctx, &conf_ctx);
 195         if (!W_ERROR_IS_OK(werr)) {
 196                 goto done;
 197         }
 198
 199         werr = libnet_conf_set_global_parameter(conf_ctx,
 200                                                 "server string",
 201                                                 info1005->comment);
 202
 203  done:
 204         libnet_conf_close(conf_ctx);
 205         return werr;
 206 }
 207
 208 /****************************************************************
 209 ****************************************************************/
 210
 211 static WERROR NetServerSetInfoLocal(struct libnetapi_ctx *ctx,
 212                                     const char *server_name,
 213                                     uint32_t level,
 214                                     uint8_t *buffer,
 215                                     uint32_t *parm_error)
 216 {
 217         switch (level) {
 218                 case 1005:
 219                         return NetServerSetInfoLocal_1005(ctx, buffer, parm_error);
 220                 default:
 221                         return WERR_UNKNOWN_LEVEL;
 222         }
 223
 224         return WERR_UNKNOWN_LEVEL;
 225 }
 226
 227 /****************************************************************
 228 ****************************************************************/
 229
 230 static WERROR NetServerSetInfoRemote(struct libnetapi_ctx *ctx,
 231                                      const char *server_name,
 232                                      uint32_t level,
 233                                      uint8_t *buffer,
 234                                      uint32_t *parm_error)
 235 {
 236         struct cli_state *cli = NULL;
 237         struct rpc_pipe_client *pipe_cli = NULL;
 238         NTSTATUS status;
 239         WERROR werr;
 240         union srvsvc_NetSrvInfo info;
 241
 242         status = cli_full_connection(&cli, NULL, server_name,
 243                                      NULL, 0,
 244                                      "IPC$", "IPC",
 245                                      ctx->username,
 246                                      ctx->workgroup,
 247                                      ctx->password,
 248                                      0, Undefined, NULL);
 249
 250         if (!NT_STATUS_IS_OK(status)) {
 251                 werr = ntstatus_to_werror(status);
 252                 goto done;
 253         }
 254
 255         pipe_cli = cli_rpc_pipe_open_noauth(cli, PI_SRVSVC,
 256                                             &status);
 257         if (!pipe_cli) {
 258                 werr = ntstatus_to_werror(status);
 259                 goto done;
 260         };
 261
 262         switch (level) {
 263                 case 1005:
 264                         info.info1005 = (struct srvsvc_NetSrvInfo1005 *)buffer;
 265                         break;
 266                 default:
 267                         werr = WERR_NOT_SUPPORTED;
 268                         goto done;
 269         }
 270
 271         status = rpccli_srvsvc_NetSrvSetInfo(pipe_cli, ctx,
 272                                              server_name,
 273                                              level,
 274                                              info,
 275                                              parm_error,
 276                                              &werr);
 277         if (!NT_STATUS_IS_OK(status)) {
 278                 werr = ntstatus_to_werror(status);
 279                 goto done;
 280         }
 281
 282  done:
 283         if (cli) {
 284                 cli_shutdown(cli);
 285         }
 286
 287         return werr;
 288 }
 289
 290 /****************************************************************
 291 ****************************************************************/
 292
 293 static WERROR libnetapi_NetServerSetInfo(struct libnetapi_ctx *ctx,
 294                                          const char *server_name,
 295                                          uint32_t level,
 296                                          uint8_t *buffer,
 297                                          uint32_t *parm_error)
 298 {
 299         if (!server_name || is_myname_or_ipaddr(server_name)) {
 300                 return NetServerSetInfoLocal(ctx,
 301                                              server_name,
 302                                              level,
 303                                              buffer,
 304                                              parm_error);
 305         }
 306
 307         return NetServerSetInfoRemote(ctx,
 308                                       server_name,
 309                                       level,
 310                                       buffer,
 311                                       parm_error);
 312 }
 313
 314 /****************************************************************
 315  NetServerSetInfo
 316 ****************************************************************/
 317
 318 NET_API_STATUS NetServerSetInfo(const char *server_name,
 319                                 uint32_t level,
 320                                 uint8_t *buffer,
 321                                 uint32_t *parm_error)
 322 {
 323         struct libnetapi_ctx *ctx = NULL;
 324         NET_API_STATUS status;
 325         WERROR werr;
 326
 327         status = libnetapi_getctx(&ctx);
 328         if (status != 0) {
 329                 return status;
 330         }
 331
 332         werr = libnetapi_NetServerSetInfo(ctx,
 333                                           server_name,
 334                                           level,
 335                                           buffer,
 336                                           parm_error);
 337         if (!W_ERROR_IS_OK(werr)) {
 338                 return W_ERROR_V(werr);
 339         }
 340
 341         return NET_API_STATUS_SUCCESS;
 342 }