source3/rpc_server/spoolss/srv_spoolss_util.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *
   4  *  SPOOLSS RPC Pipe server / winreg client routines
   5  *
   6  *  Copyright (c) 2010      Andreas Schneider <asn@samba.org>
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 3 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "includes.h"
  23 #include "rpc_server/rpc_ncacn_np.h"
  24 #include "../lib/tsocket/tsocket.h"
  25 #include "../librpc/gen_ndr/ndr_spoolss.h"
  26 #include "../librpc/gen_ndr/ndr_winreg.h"
  27 #include "srv_spoolss_util.h"
  28 #include "rpc_client/cli_winreg_spoolss.h"
  29
  30 WERROR winreg_printer_binding_handle(TALLOC_CTX *mem_ctx,
  31                                      const struct auth_session_info *session_info,
  32                                      struct messaging_context *msg_ctx,
  33                                      struct dcerpc_binding_handle **winreg_binding_handle)
  34 {
  35         struct tsocket_address *local;
  36         NTSTATUS status;
  37         int rc;
  38
  39         rc = tsocket_address_inet_from_strings(mem_ctx,
  40                                                "ip",
  41                                                "127.0.0.1",
  42                                                0,
  43                                                &local);
  44         if (rc < 0) {
  45                 return WERR_NOMEM;
  46         }
  47
  48         status = rpcint_binding_handle(mem_ctx,
  49                                        &ndr_table_winreg,
  50                                        local,
  51                                        session_info,
  52                                        msg_ctx,
  53                                        winreg_binding_handle);
  54         talloc_free(local);
  55         if (!NT_STATUS_IS_OK(status)) {
  56                 DEBUG(0, ("winreg_printer_binding_handle: Could not connect to winreg pipe: %s\n",
  57                           nt_errstr(status)));
  58                 return ntstatus_to_werror(status);
  59         }
  60
  61         return WERR_OK;
  62 }
  63
  64 WERROR winreg_delete_printer_key_internal(TALLOC_CTX *mem_ctx,
  65                                           const struct auth_session_info *session_info,
  66                                           struct messaging_context *msg_ctx,
  67                                           const char *printer,
  68                                           const char *key)
  69 {
  70         WERROR result;
  71         struct dcerpc_binding_handle *b;
  72         TALLOC_CTX *tmp_ctx;
  73
  74         tmp_ctx = talloc_stackframe();
  75         if (tmp_ctx == NULL) {
  76                 return WERR_NOMEM;
  77         }
  78
  79         result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
  80         if (!W_ERROR_IS_OK(result)) {
  81                 talloc_free(tmp_ctx);
  82                 return result;
  83         }
  84
  85         result = winreg_delete_printer_key(tmp_ctx,
  86                                            b,
  87                                            printer,
  88                                            key);
  89
  90         talloc_free(tmp_ctx);
  91         return result;
  92 }
  93
  94 WERROR winreg_printer_update_changeid_internal(TALLOC_CTX *mem_ctx,
  95                                                const struct auth_session_info *session_info,
  96                                                struct messaging_context *msg_ctx,
  97                                                const char *printer)
  98 {
  99         WERROR result;
 100         struct dcerpc_binding_handle *b;
 101
 102         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 103         W_ERROR_NOT_OK_RETURN(result);
 104
 105         return winreg_printer_update_changeid(mem_ctx, b,
 106                                               printer);
 107 }
 108
 109 WERROR winreg_printer_get_changeid_internal(TALLOC_CTX *mem_ctx,
 110                                             const struct auth_session_info *session_info,
 111                                             struct messaging_context *msg_ctx,
 112                                             const char *printer,
 113                                             uint32_t *pchangeid)
 114 {
 115         WERROR result;
 116         struct dcerpc_binding_handle *b;
 117
 118         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 119         W_ERROR_NOT_OK_RETURN(result);
 120
 121         return winreg_printer_get_changeid(mem_ctx, b,
 122                                            printer,
 123                                            pchangeid);
 124 }
 125
 126 WERROR winreg_get_printer_internal(TALLOC_CTX *mem_ctx,
 127                                    const struct auth_session_info *session_info,
 128                                    struct messaging_context *msg_ctx,
 129                                    const char *printer,
 130                                    struct spoolss_PrinterInfo2 **pinfo2)
 131 {
 132         WERROR result;
 133         struct dcerpc_binding_handle *b;
 134
 135         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 136         W_ERROR_NOT_OK_RETURN(result);
 137
 138         return winreg_get_printer(mem_ctx, b,
 139                                   printer,
 140                                   pinfo2);
 141
 142 }
 143
 144 WERROR winreg_create_printer_internal(TALLOC_CTX *mem_ctx,
 145                                       const struct auth_session_info *session_info,
 146                                       struct messaging_context *msg_ctx,
 147                                       const char *sharename)
 148 {
 149         WERROR result;
 150         struct dcerpc_binding_handle *b;
 151
 152         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 153         W_ERROR_NOT_OK_RETURN(result);
 154
 155         return winreg_create_printer(mem_ctx, b,
 156                                      sharename);
 157 }
 158
 159 WERROR winreg_update_printer_internal(TALLOC_CTX *mem_ctx,
 160                                       const struct auth_session_info *session_info,
 161                                       struct messaging_context *msg_ctx,
 162                                       const char *sharename,
 163                                       uint32_t info2_mask,
 164                                       struct spoolss_SetPrinterInfo2 *info2,
 165                                       struct spoolss_DeviceMode *devmode,
 166                                       struct security_descriptor *secdesc)
 167 {
 168         WERROR result;
 169         struct dcerpc_binding_handle *b;
 170
 171         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 172         W_ERROR_NOT_OK_RETURN(result);
 173
 174         return winreg_update_printer(mem_ctx, b,
 175                                      sharename,
 176                                      info2_mask,
 177                                      info2,
 178                                      devmode,
 179                                      secdesc);
 180 }
 181
 182 WERROR winreg_set_printer_dataex_internal(TALLOC_CTX *mem_ctx,
 183                                           const struct auth_session_info *session_info,
 184                                           struct messaging_context *msg_ctx,
 185                                           const char *printer,
 186                                           const char *key,
 187                                           const char *value,
 188                                           enum winreg_Type type,
 189                                           uint8_t *data,
 190                                           uint32_t data_size)
 191 {
 192         WERROR result;
 193         struct dcerpc_binding_handle *b;
 194
 195         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 196         W_ERROR_NOT_OK_RETURN(result);
 197
 198         return winreg_set_printer_dataex(mem_ctx, b,
 199                                          printer,
 200                                          key,
 201                                          value,
 202                                          type,
 203                                          data,
 204                                          data_size);
 205 }
 206
 207 WERROR winreg_enum_printer_dataex_internal(TALLOC_CTX *mem_ctx,
 208                                            const struct auth_session_info *session_info,
 209                                            struct messaging_context *msg_ctx,
 210                                            const char *printer,
 211                                            const char *key,
 212                                            uint32_t *pnum_values,
 213                                            struct spoolss_PrinterEnumValues **penum_values)
 214 {
 215         WERROR result;
 216         struct dcerpc_binding_handle *b;
 217
 218         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 219         W_ERROR_NOT_OK_RETURN(result);
 220
 221         return winreg_enum_printer_dataex(mem_ctx, b,
 222                                           printer,
 223                                           key,
 224                                           pnum_values,
 225                                           penum_values);
 226 }
 227
 228 WERROR winreg_get_printer_dataex_internal(TALLOC_CTX *mem_ctx,
 229                                           const struct auth_session_info *session_info,
 230                                           struct messaging_context *msg_ctx,
 231                                           const char *printer,
 232                                           const char *key,
 233                                           const char *value,
 234                                           enum winreg_Type *type,
 235                                           uint8_t **data,
 236                                           uint32_t *data_size)
 237 {
 238         WERROR result;
 239         struct dcerpc_binding_handle *b;
 240
 241         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 242         W_ERROR_NOT_OK_RETURN(result);
 243
 244         return winreg_get_printer_dataex(mem_ctx, b,
 245                                          printer,
 246                                          key,
 247                                          value,
 248                                          type,
 249                                          data,
 250                                          data_size);
 251 }
 252
 253 WERROR winreg_delete_printer_dataex_internal(TALLOC_CTX *mem_ctx,
 254                                              const struct auth_session_info *session_info,
 255                                              struct messaging_context *msg_ctx,
 256                                              const char *printer,
 257                                              const char *key,
 258                                              const char *value)
 259 {
 260         WERROR result;
 261         struct dcerpc_binding_handle *b;
 262
 263         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 264         W_ERROR_NOT_OK_RETURN(result);
 265
 266         return winreg_delete_printer_dataex(mem_ctx, b,
 267                                             printer,
 268                                             key,
 269                                             value);
 270 }
 271
 272 WERROR winreg_get_driver_internal(TALLOC_CTX *mem_ctx,
 273                                   const struct auth_session_info *session_info,
 274                                   struct messaging_context *msg_ctx,
 275                                   const char *architecture,
 276                                   const char *driver_name,
 277                                   uint32_t driver_version,
 278                                   struct spoolss_DriverInfo8 **_info8)
 279 {
 280         WERROR result;
 281         struct dcerpc_binding_handle *b;
 282
 283         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 284         W_ERROR_NOT_OK_RETURN(result);
 285
 286         return winreg_get_driver(mem_ctx, b,
 287                                  architecture,
 288                                  driver_name,
 289                                  driver_version,
 290                                  _info8);
 291 }
 292
 293 WERROR winreg_get_driver_list_internal(TALLOC_CTX *mem_ctx,
 294                                        const struct auth_session_info *session_info,
 295                                        struct messaging_context *msg_ctx,
 296                                        const char *architecture,
 297                                        uint32_t version,
 298                                        uint32_t *num_drivers,
 299                                        const char ***drivers_p)
 300 {
 301         WERROR result;
 302         struct dcerpc_binding_handle *b;
 303
 304         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 305         W_ERROR_NOT_OK_RETURN(result);
 306
 307         return winreg_get_driver_list(mem_ctx, b,
 308                                       architecture,
 309                                       version,
 310                                       num_drivers,
 311                                       drivers_p);
 312 }
 313
 314 WERROR winreg_del_driver_internal(TALLOC_CTX *mem_ctx,
 315                                   const struct auth_session_info *session_info,
 316                                   struct messaging_context *msg_ctx,
 317                                   struct spoolss_DriverInfo8 *info8,
 318                                   uint32_t version)
 319 {
 320         WERROR result;
 321         struct dcerpc_binding_handle *b;
 322
 323         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 324         W_ERROR_NOT_OK_RETURN(result);
 325
 326         return winreg_del_driver(mem_ctx, b,
 327                                  info8,
 328                                  version);
 329 }
 330
 331 WERROR winreg_add_driver_internal(TALLOC_CTX *mem_ctx,
 332                                   const struct auth_session_info *session_info,
 333                                   struct messaging_context *msg_ctx,
 334                                   struct spoolss_AddDriverInfoCtr *r,
 335                                   const char **driver_name,
 336                                   uint32_t *driver_version)
 337 {
 338         WERROR result;
 339         struct dcerpc_binding_handle *b;
 340
 341         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 342         W_ERROR_NOT_OK_RETURN(result);
 343
 344         return winreg_add_driver(mem_ctx, b,
 345                                  r,
 346                                  driver_name,
 347                                  driver_version);
 348 }
 349
 350 WERROR winreg_get_printer_secdesc_internal(TALLOC_CTX *mem_ctx,
 351                                            const struct auth_session_info *session_info,
 352                                            struct messaging_context *msg_ctx,
 353                                            const char *sharename,
 354                                            struct spoolss_security_descriptor **psecdesc)
 355 {
 356         WERROR result;
 357         struct dcerpc_binding_handle *b;
 358
 359         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 360         W_ERROR_NOT_OK_RETURN(result);
 361
 362         return winreg_get_printer_secdesc(mem_ctx, b,
 363                                           sharename,
 364                                           psecdesc);
 365 }
 366
 367 WERROR winreg_set_printer_secdesc_internal(TALLOC_CTX *mem_ctx,
 368                                            const struct auth_session_info *session_info,
 369                                            struct messaging_context *msg_ctx,
 370                                            const char *sharename,
 371                                            const struct spoolss_security_descriptor *secdesc)
 372 {
 373         WERROR result;
 374         struct dcerpc_binding_handle *b;
 375
 376         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 377         W_ERROR_NOT_OK_RETURN(result);
 378
 379         return winreg_set_printer_secdesc(mem_ctx, b,
 380                                           sharename,
 381                                           secdesc);
 382 }
 383
 384 WERROR winreg_printer_enumforms1_internal(TALLOC_CTX *mem_ctx,
 385                                           const struct auth_session_info *session_info,
 386                                           struct messaging_context *msg_ctx,
 387                                           uint32_t *pnum_info,
 388                                           union spoolss_FormInfo **pinfo)
 389 {
 390         WERROR result;
 391         struct dcerpc_binding_handle *b;
 392
 393         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 394         W_ERROR_NOT_OK_RETURN(result);
 395
 396         return winreg_printer_enumforms1(mem_ctx, b,
 397                                          pnum_info,
 398                                          pinfo);
 399 }
 400
 401 WERROR winreg_printer_getform1_internal(TALLOC_CTX *mem_ctx,
 402                                         const struct auth_session_info *session_info,
 403                                         struct messaging_context *msg_ctx,
 404                                         const char *form_name,
 405                                         struct spoolss_FormInfo1 *r)
 406 {
 407         WERROR result;
 408         struct dcerpc_binding_handle *b;
 409
 410         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 411         W_ERROR_NOT_OK_RETURN(result);
 412
 413         return winreg_printer_getform1(mem_ctx, b,
 414                                        form_name,
 415                                        r);
 416 }
 417
 418 WERROR winreg_printer_addform1_internal(TALLOC_CTX *mem_ctx,
 419                                         const struct auth_session_info *session_info,
 420                                         struct messaging_context *msg_ctx,
 421                                         struct spoolss_AddFormInfo1 *form)
 422 {
 423         WERROR result;
 424         struct dcerpc_binding_handle *b;
 425
 426         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 427         W_ERROR_NOT_OK_RETURN(result);
 428
 429         return winreg_printer_addform1(mem_ctx, b,
 430                                        form);
 431 }
 432
 433 WERROR winreg_printer_setform1_internal(TALLOC_CTX *mem_ctx,
 434                                         const struct auth_session_info *session_info,
 435                                         struct messaging_context *msg_ctx,
 436                                         const char *form_name,
 437                                         struct spoolss_AddFormInfo1 *form)
 438 {
 439         WERROR result;
 440         struct dcerpc_binding_handle *b;
 441
 442         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 443         W_ERROR_NOT_OK_RETURN(result);
 444
 445         return winreg_printer_setform1(mem_ctx, b,
 446                                        form_name,
 447                                        form);
 448 }
 449
 450 WERROR winreg_printer_deleteform1_internal(TALLOC_CTX *mem_ctx,
 451                                            const struct auth_session_info *session_info,
 452                                            struct messaging_context *msg_ctx,
 453                                            const char *form_name)
 454 {
 455         WERROR result;
 456         struct dcerpc_binding_handle *b;
 457
 458         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 459         W_ERROR_NOT_OK_RETURN(result);
 460
 461         return winreg_printer_deleteform1(mem_ctx, b,
 462                                           form_name);
 463 }
 464
 465 WERROR winreg_enum_printer_key_internal(TALLOC_CTX *mem_ctx,
 466                                         const struct auth_session_info *session_info,
 467                                         struct messaging_context *msg_ctx,
 468                                         const char *printer,
 469                                         const char *key,
 470                                         uint32_t *pnum_subkeys,
 471                                         const char ***psubkeys)
 472 {
 473         WERROR result;
 474         struct dcerpc_binding_handle *b;
 475
 476         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 477         W_ERROR_NOT_OK_RETURN(result);
 478
 479         return winreg_enum_printer_key(mem_ctx, b,
 480                                        printer,
 481                                        key,
 482                                        pnum_subkeys,
 483                                        psubkeys);
 484 }