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         TALLOC_CTX *tmp_ctx;
 102
 103         tmp_ctx = talloc_stackframe();
 104         if (tmp_ctx == NULL) {
 105                 return WERR_NOMEM;
 106         }
 107
 108         result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
 109         if (!W_ERROR_IS_OK(result)) {
 110                 talloc_free(tmp_ctx);
 111                 return result;
 112         }
 113
 114         result = winreg_printer_update_changeid(mem_ctx,
 115                                                 b,
 116                                                 printer);
 117
 118         talloc_free(tmp_ctx);
 119         return result;
 120 }
 121
 122 WERROR winreg_printer_get_changeid_internal(TALLOC_CTX *mem_ctx,
 123                                             const struct auth_session_info *session_info,
 124                                             struct messaging_context *msg_ctx,
 125                                             const char *printer,
 126                                             uint32_t *pchangeid)
 127 {
 128         WERROR result;
 129         struct dcerpc_binding_handle *b;
 130         TALLOC_CTX *tmp_ctx;
 131
 132         tmp_ctx = talloc_stackframe();
 133         if (tmp_ctx == NULL) {
 134                 return WERR_NOMEM;
 135         }
 136
 137         result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
 138         if (!W_ERROR_IS_OK(result)) {
 139                 talloc_free(tmp_ctx);
 140                 return result;
 141         }
 142
 143         result = winreg_printer_get_changeid(mem_ctx,
 144                                              b,
 145                                              printer,
 146                                              pchangeid);
 147
 148         talloc_free(tmp_ctx);
 149         return result;
 150 }
 151
 152 WERROR winreg_get_printer_internal(TALLOC_CTX *mem_ctx,
 153                                    const struct auth_session_info *session_info,
 154                                    struct messaging_context *msg_ctx,
 155                                    const char *printer,
 156                                    struct spoolss_PrinterInfo2 **pinfo2)
 157 {
 158         WERROR result;
 159         struct dcerpc_binding_handle *b;
 160         TALLOC_CTX *tmp_ctx;
 161
 162         tmp_ctx = talloc_stackframe();
 163         if (tmp_ctx == NULL) {
 164                 return WERR_NOMEM;
 165         }
 166
 167         result = winreg_printer_binding_handle(tmp_ctx, session_info, msg_ctx, &b);
 168         if (!W_ERROR_IS_OK(result)) {
 169                 talloc_free(tmp_ctx);
 170                 return result;
 171         }
 172
 173         result = winreg_get_printer(mem_ctx,
 174                                     b,
 175                                     printer,
 176                                     pinfo2);
 177
 178         talloc_free(tmp_ctx);
 179         return result;
 180 }
 181
 182 WERROR winreg_create_printer_internal(TALLOC_CTX *mem_ctx,
 183                                       const struct auth_session_info *session_info,
 184                                       struct messaging_context *msg_ctx,
 185                                       const char *sharename)
 186 {
 187         WERROR result;
 188         struct dcerpc_binding_handle *b;
 189
 190         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 191         W_ERROR_NOT_OK_RETURN(result);
 192
 193         return winreg_create_printer(mem_ctx, b,
 194                                      sharename);
 195 }
 196
 197 WERROR winreg_update_printer_internal(TALLOC_CTX *mem_ctx,
 198                                       const struct auth_session_info *session_info,
 199                                       struct messaging_context *msg_ctx,
 200                                       const char *sharename,
 201                                       uint32_t info2_mask,
 202                                       struct spoolss_SetPrinterInfo2 *info2,
 203                                       struct spoolss_DeviceMode *devmode,
 204                                       struct security_descriptor *secdesc)
 205 {
 206         WERROR result;
 207         struct dcerpc_binding_handle *b;
 208
 209         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 210         W_ERROR_NOT_OK_RETURN(result);
 211
 212         return winreg_update_printer(mem_ctx, b,
 213                                      sharename,
 214                                      info2_mask,
 215                                      info2,
 216                                      devmode,
 217                                      secdesc);
 218 }
 219
 220 WERROR winreg_set_printer_dataex_internal(TALLOC_CTX *mem_ctx,
 221                                           const struct auth_session_info *session_info,
 222                                           struct messaging_context *msg_ctx,
 223                                           const char *printer,
 224                                           const char *key,
 225                                           const char *value,
 226                                           enum winreg_Type type,
 227                                           uint8_t *data,
 228                                           uint32_t data_size)
 229 {
 230         WERROR result;
 231         struct dcerpc_binding_handle *b;
 232
 233         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 234         W_ERROR_NOT_OK_RETURN(result);
 235
 236         return winreg_set_printer_dataex(mem_ctx, b,
 237                                          printer,
 238                                          key,
 239                                          value,
 240                                          type,
 241                                          data,
 242                                          data_size);
 243 }
 244
 245 WERROR winreg_enum_printer_dataex_internal(TALLOC_CTX *mem_ctx,
 246                                            const struct auth_session_info *session_info,
 247                                            struct messaging_context *msg_ctx,
 248                                            const char *printer,
 249                                            const char *key,
 250                                            uint32_t *pnum_values,
 251                                            struct spoolss_PrinterEnumValues **penum_values)
 252 {
 253         WERROR result;
 254         struct dcerpc_binding_handle *b;
 255
 256         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 257         W_ERROR_NOT_OK_RETURN(result);
 258
 259         return winreg_enum_printer_dataex(mem_ctx, b,
 260                                           printer,
 261                                           key,
 262                                           pnum_values,
 263                                           penum_values);
 264 }
 265
 266 WERROR winreg_get_printer_dataex_internal(TALLOC_CTX *mem_ctx,
 267                                           const struct auth_session_info *session_info,
 268                                           struct messaging_context *msg_ctx,
 269                                           const char *printer,
 270                                           const char *key,
 271                                           const char *value,
 272                                           enum winreg_Type *type,
 273                                           uint8_t **data,
 274                                           uint32_t *data_size)
 275 {
 276         WERROR result;
 277         struct dcerpc_binding_handle *b;
 278
 279         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 280         W_ERROR_NOT_OK_RETURN(result);
 281
 282         return winreg_get_printer_dataex(mem_ctx, b,
 283                                          printer,
 284                                          key,
 285                                          value,
 286                                          type,
 287                                          data,
 288                                          data_size);
 289 }
 290
 291 WERROR winreg_delete_printer_dataex_internal(TALLOC_CTX *mem_ctx,
 292                                              const struct auth_session_info *session_info,
 293                                              struct messaging_context *msg_ctx,
 294                                              const char *printer,
 295                                              const char *key,
 296                                              const char *value)
 297 {
 298         WERROR result;
 299         struct dcerpc_binding_handle *b;
 300
 301         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 302         W_ERROR_NOT_OK_RETURN(result);
 303
 304         return winreg_delete_printer_dataex(mem_ctx, b,
 305                                             printer,
 306                                             key,
 307                                             value);
 308 }
 309
 310 WERROR winreg_get_driver_internal(TALLOC_CTX *mem_ctx,
 311                                   const struct auth_session_info *session_info,
 312                                   struct messaging_context *msg_ctx,
 313                                   const char *architecture,
 314                                   const char *driver_name,
 315                                   uint32_t driver_version,
 316                                   struct spoolss_DriverInfo8 **_info8)
 317 {
 318         WERROR result;
 319         struct dcerpc_binding_handle *b;
 320
 321         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 322         W_ERROR_NOT_OK_RETURN(result);
 323
 324         return winreg_get_driver(mem_ctx, b,
 325                                  architecture,
 326                                  driver_name,
 327                                  driver_version,
 328                                  _info8);
 329 }
 330
 331 WERROR winreg_get_driver_list_internal(TALLOC_CTX *mem_ctx,
 332                                        const struct auth_session_info *session_info,
 333                                        struct messaging_context *msg_ctx,
 334                                        const char *architecture,
 335                                        uint32_t version,
 336                                        uint32_t *num_drivers,
 337                                        const char ***drivers_p)
 338 {
 339         WERROR result;
 340         struct dcerpc_binding_handle *b;
 341
 342         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 343         W_ERROR_NOT_OK_RETURN(result);
 344
 345         return winreg_get_driver_list(mem_ctx, b,
 346                                       architecture,
 347                                       version,
 348                                       num_drivers,
 349                                       drivers_p);
 350 }
 351
 352 WERROR winreg_del_driver_internal(TALLOC_CTX *mem_ctx,
 353                                   const struct auth_session_info *session_info,
 354                                   struct messaging_context *msg_ctx,
 355                                   struct spoolss_DriverInfo8 *info8,
 356                                   uint32_t version)
 357 {
 358         WERROR result;
 359         struct dcerpc_binding_handle *b;
 360
 361         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 362         W_ERROR_NOT_OK_RETURN(result);
 363
 364         return winreg_del_driver(mem_ctx, b,
 365                                  info8,
 366                                  version);
 367 }
 368
 369 WERROR winreg_add_driver_internal(TALLOC_CTX *mem_ctx,
 370                                   const struct auth_session_info *session_info,
 371                                   struct messaging_context *msg_ctx,
 372                                   struct spoolss_AddDriverInfoCtr *r,
 373                                   const char **driver_name,
 374                                   uint32_t *driver_version)
 375 {
 376         WERROR result;
 377         struct dcerpc_binding_handle *b;
 378
 379         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 380         W_ERROR_NOT_OK_RETURN(result);
 381
 382         return winreg_add_driver(mem_ctx, b,
 383                                  r,
 384                                  driver_name,
 385                                  driver_version);
 386 }
 387
 388 WERROR winreg_get_printer_secdesc_internal(TALLOC_CTX *mem_ctx,
 389                                            const struct auth_session_info *session_info,
 390                                            struct messaging_context *msg_ctx,
 391                                            const char *sharename,
 392                                            struct spoolss_security_descriptor **psecdesc)
 393 {
 394         WERROR result;
 395         struct dcerpc_binding_handle *b;
 396
 397         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 398         W_ERROR_NOT_OK_RETURN(result);
 399
 400         return winreg_get_printer_secdesc(mem_ctx, b,
 401                                           sharename,
 402                                           psecdesc);
 403 }
 404
 405 WERROR winreg_set_printer_secdesc_internal(TALLOC_CTX *mem_ctx,
 406                                            const struct auth_session_info *session_info,
 407                                            struct messaging_context *msg_ctx,
 408                                            const char *sharename,
 409                                            const struct spoolss_security_descriptor *secdesc)
 410 {
 411         WERROR result;
 412         struct dcerpc_binding_handle *b;
 413
 414         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 415         W_ERROR_NOT_OK_RETURN(result);
 416
 417         return winreg_set_printer_secdesc(mem_ctx, b,
 418                                           sharename,
 419                                           secdesc);
 420 }
 421
 422 WERROR winreg_printer_enumforms1_internal(TALLOC_CTX *mem_ctx,
 423                                           const struct auth_session_info *session_info,
 424                                           struct messaging_context *msg_ctx,
 425                                           uint32_t *pnum_info,
 426                                           union spoolss_FormInfo **pinfo)
 427 {
 428         WERROR result;
 429         struct dcerpc_binding_handle *b;
 430
 431         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 432         W_ERROR_NOT_OK_RETURN(result);
 433
 434         return winreg_printer_enumforms1(mem_ctx, b,
 435                                          pnum_info,
 436                                          pinfo);
 437 }
 438
 439 WERROR winreg_printer_getform1_internal(TALLOC_CTX *mem_ctx,
 440                                         const struct auth_session_info *session_info,
 441                                         struct messaging_context *msg_ctx,
 442                                         const char *form_name,
 443                                         struct spoolss_FormInfo1 *r)
 444 {
 445         WERROR result;
 446         struct dcerpc_binding_handle *b;
 447
 448         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 449         W_ERROR_NOT_OK_RETURN(result);
 450
 451         return winreg_printer_getform1(mem_ctx, b,
 452                                        form_name,
 453                                        r);
 454 }
 455
 456 WERROR winreg_printer_addform1_internal(TALLOC_CTX *mem_ctx,
 457                                         const struct auth_session_info *session_info,
 458                                         struct messaging_context *msg_ctx,
 459                                         struct spoolss_AddFormInfo1 *form)
 460 {
 461         WERROR result;
 462         struct dcerpc_binding_handle *b;
 463
 464         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 465         W_ERROR_NOT_OK_RETURN(result);
 466
 467         return winreg_printer_addform1(mem_ctx, b,
 468                                        form);
 469 }
 470
 471 WERROR winreg_printer_setform1_internal(TALLOC_CTX *mem_ctx,
 472                                         const struct auth_session_info *session_info,
 473                                         struct messaging_context *msg_ctx,
 474                                         const char *form_name,
 475                                         struct spoolss_AddFormInfo1 *form)
 476 {
 477         WERROR result;
 478         struct dcerpc_binding_handle *b;
 479
 480         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 481         W_ERROR_NOT_OK_RETURN(result);
 482
 483         return winreg_printer_setform1(mem_ctx, b,
 484                                        form_name,
 485                                        form);
 486 }
 487
 488 WERROR winreg_printer_deleteform1_internal(TALLOC_CTX *mem_ctx,
 489                                            const struct auth_session_info *session_info,
 490                                            struct messaging_context *msg_ctx,
 491                                            const char *form_name)
 492 {
 493         WERROR result;
 494         struct dcerpc_binding_handle *b;
 495
 496         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 497         W_ERROR_NOT_OK_RETURN(result);
 498
 499         return winreg_printer_deleteform1(mem_ctx, b,
 500                                           form_name);
 501 }
 502
 503 WERROR winreg_enum_printer_key_internal(TALLOC_CTX *mem_ctx,
 504                                         const struct auth_session_info *session_info,
 505                                         struct messaging_context *msg_ctx,
 506                                         const char *printer,
 507                                         const char *key,
 508                                         uint32_t *pnum_subkeys,
 509                                         const char ***psubkeys)
 510 {
 511         WERROR result;
 512         struct dcerpc_binding_handle *b;
 513
 514         result = winreg_printer_binding_handle(mem_ctx, session_info, msg_ctx, &b);
 515         W_ERROR_NOT_OK_RETURN(result);
 516
 517         return winreg_enum_printer_key(mem_ctx, b,
 518                                        printer,
 519                                        key,
 520                                        pnum_subkeys,
 521                                        psubkeys);
 522 }