source4/ntptr/ntptr_interface.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    NTPTR interface functions
   5
   6    Copyright (C) Stefan (metze) Metzmacher 2005
   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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "ntptr/ntptr.h"
  25
  26
  27 /* PrintServer functions */
  28 WERROR ntptr_OpenPrintServer(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
  29                              struct spoolss_OpenPrinterEx *r,
  30                              const char *printer_name,
  31                              struct ntptr_GenericHandle **server)
  32 {
  33         if (!ntptr->ops->OpenPrintServer) {
  34                 return WERR_NOT_SUPPORTED;
  35         }
  36         return ntptr->ops->OpenPrintServer(ntptr, mem_ctx, r, printer_name, server);
  37 }
  38
  39
  40 /* PrintServer PrinterData functions */
  41 WERROR ntptr_EnumPrintServerData(struct ntptr_GenericHandle *server, TALLOC_CTX *mem_ctx,
  42                                  struct spoolss_EnumPrinterData *r)
  43 {
  44         if (server->type != NTPTR_HANDLE_SERVER) {
  45                 return WERR_FOOBAR;
  46         }
  47         if (!server->ntptr->ops->EnumPrintServerData) {
  48                 return WERR_NOT_SUPPORTED;
  49         }
  50         return server->ntptr->ops->EnumPrintServerData(server, mem_ctx, r);
  51 }
  52
  53 WERROR ntptr_GetPrintServerData(struct ntptr_GenericHandle *server, TALLOC_CTX *mem_ctx,
  54                                 struct spoolss_GetPrinterData *r)
  55 {
  56         if (server->type != NTPTR_HANDLE_SERVER) {
  57                 return WERR_FOOBAR;
  58         }
  59         if (!server->ntptr->ops->GetPrintServerData) {
  60                 return WERR_NOT_SUPPORTED;
  61         }
  62         return server->ntptr->ops->GetPrintServerData(server, mem_ctx, r);
  63 }
  64
  65 WERROR ntptr_SetPrintServerData(struct ntptr_GenericHandle *server, TALLOC_CTX *mem_ctx,
  66                                 struct spoolss_SetPrinterData *r)
  67 {
  68         if (server->type != NTPTR_HANDLE_SERVER) {
  69                 return WERR_FOOBAR;
  70         }
  71         if (!server->ntptr->ops->SetPrintServerData) {
  72                 return WERR_NOT_SUPPORTED;
  73         }
  74         return server->ntptr->ops->SetPrintServerData(server, mem_ctx, r);
  75 }
  76
  77 WERROR ntptr_DeletePrintServerData(struct ntptr_GenericHandle *server, TALLOC_CTX *mem_ctx,
  78                                    struct spoolss_DeletePrinterData *r)
  79 {
  80         if (server->type != NTPTR_HANDLE_SERVER) {
  81                 return WERR_FOOBAR;
  82         }
  83         if (!server->ntptr->ops->DeletePrintServerData) {
  84                 return WERR_NOT_SUPPORTED;
  85         }
  86         return server->ntptr->ops->DeletePrintServerData(server, mem_ctx, r);
  87 }
  88
  89
  90 /* PrintServer Form functions */
  91 WERROR ntptr_EnumPrintServerForms(struct ntptr_GenericHandle *server, TALLOC_CTX *mem_ctx,
  92                                   struct spoolss_EnumForms *r)
  93 {
  94         if (server->type != NTPTR_HANDLE_SERVER) {
  95                 return WERR_FOOBAR;
  96         }
  97         if (!server->ntptr->ops->EnumPrintServerForms) {
  98                 return WERR_NOT_SUPPORTED;
  99         }
 100         return server->ntptr->ops->EnumPrintServerForms(server, mem_ctx, r);
 101 }
 102
 103 WERROR ntptr_AddPrintServerForm(struct ntptr_GenericHandle *server, TALLOC_CTX *mem_ctx,
 104                                 struct spoolss_AddForm *r)
 105 {
 106         if (server->type != NTPTR_HANDLE_SERVER) {
 107                 return WERR_FOOBAR;
 108         }
 109         if (!server->ntptr->ops->AddPrintServerForm) {
 110                 return WERR_NOT_SUPPORTED;
 111         }
 112         return server->ntptr->ops->AddPrintServerForm(server, mem_ctx, r);
 113 }
 114
 115 WERROR ntptr_SetPrintServerForm(struct ntptr_GenericHandle *server, TALLOC_CTX *mem_ctx,
 116                                 struct spoolss_SetForm *r)
 117 {
 118         if (server->type != NTPTR_HANDLE_SERVER) {
 119                 return WERR_FOOBAR;
 120         }
 121         if (!server->ntptr->ops->SetPrintServerForm) {
 122                 return WERR_NOT_SUPPORTED;
 123         }
 124         return server->ntptr->ops->SetPrintServerForm(server, mem_ctx, r);
 125 }
 126
 127 WERROR ntptr_DeletePrintServerForm(struct ntptr_GenericHandle *server, TALLOC_CTX *mem_ctx,
 128                                    struct spoolss_DeleteForm *r)
 129 {
 130         if (server->type != NTPTR_HANDLE_SERVER) {
 131                 return WERR_FOOBAR;
 132         }
 133         if (!server->ntptr->ops->DeletePrintServerForm) {
 134                 return WERR_NOT_SUPPORTED;
 135         }
 136         return server->ntptr->ops->DeletePrintServerForm(server, mem_ctx, r);
 137 }
 138
 139
 140 /* PrintServer Driver functions */
 141 WERROR ntptr_EnumPrinterDrivers(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 142                                 struct spoolss_EnumPrinterDrivers *r)
 143 {
 144         if (!ntptr->ops->EnumPrinterDrivers) {
 145                 return WERR_NOT_SUPPORTED;
 146         }
 147         return ntptr->ops->EnumPrinterDrivers(ntptr, mem_ctx, r);
 148 }
 149
 150 WERROR ntptr_AddPrinterDriver(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 151                               struct spoolss_AddPrinterDriver *r)
 152 {
 153         if (!ntptr->ops->AddPrinterDriver) {
 154                 return WERR_NOT_SUPPORTED;
 155         }
 156         return ntptr->ops->AddPrinterDriver(ntptr, mem_ctx, r);
 157 }
 158
 159 WERROR ntptr_DeletePrinterDriver(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 160                                  struct spoolss_DeletePrinterDriver *r)
 161 {
 162         if (!ntptr->ops->DeletePrinterDriver) {
 163                 return WERR_NOT_SUPPORTED;
 164         }
 165         return ntptr->ops->DeletePrinterDriver(ntptr, mem_ctx, r);
 166 }
 167
 168 WERROR ntptr_GetPrinterDriverDirectory(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 169                                  struct spoolss_GetPrinterDriverDirectory *r)
 170 {
 171         if (!ntptr->ops->GetPrinterDriverDirectory) {
 172                 return WERR_NOT_SUPPORTED;
 173         }
 174         return ntptr->ops->GetPrinterDriverDirectory(ntptr, mem_ctx, r);
 175 }
 176
 177
 178 /* Port functions */
 179 WERROR ntptr_EnumPorts(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 180                        struct spoolss_EnumPorts *r)
 181 {
 182         if (!ntptr->ops->EnumPorts) {
 183                 return WERR_NOT_SUPPORTED;
 184         }
 185         return ntptr->ops->EnumPorts(ntptr, mem_ctx, r);
 186 }
 187
 188 WERROR ntptr_OpenPort(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 189                       struct spoolss_OpenPrinterEx *r,
 190                       const char *port_name,
 191                       struct ntptr_GenericHandle **prt)
 192 {
 193         if (!ntptr->ops->OpenPort) {
 194                 return WERR_NOT_SUPPORTED;
 195         }
 196         return ntptr->ops->OpenPort(ntptr, mem_ctx, r, port_name, prt);
 197 }
 198
 199
 200 /* Monitor functions */
 201 WERROR ntptr_EnumMonitors(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 202                           struct spoolss_EnumMonitors *r)
 203 {
 204         if (!ntptr->ops->EnumMonitors) {
 205                 return WERR_NOT_SUPPORTED;
 206         }
 207         return ntptr->ops->EnumMonitors(ntptr, mem_ctx, r);
 208 }
 209
 210 WERROR ntptr_OpenMonitor(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 211                          struct spoolss_OpenPrinterEx *r,
 212                          const char *monitor_name,
 213                          struct ntptr_GenericHandle **monitor)
 214 {
 215         if (!ntptr->ops->OpenMonitor) {
 216                 return WERR_NOT_SUPPORTED;
 217         }
 218         return ntptr->ops->OpenMonitor(ntptr, mem_ctx, r, monitor_name, monitor);
 219 }
 220
 221
 222 /* PrintProcessor functions */
 223 WERROR ntptr_EnumPrintProcessors(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 224                                  struct spoolss_EnumPrintProcessors *r)
 225 {
 226         if (!ntptr->ops->EnumPrintProcessors) {
 227                 return WERR_NOT_SUPPORTED;
 228         }
 229         return ntptr->ops->EnumPrintProcessors(ntptr, mem_ctx, r);
 230 }
 231
 232
 233 /* Printer functions */
 234 WERROR ntptr_EnumPrinters(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 235                           struct spoolss_EnumPrinters *r)
 236 {
 237         if (!ntptr->ops->EnumPrinters) {
 238                 return WERR_NOT_SUPPORTED;
 239         }
 240         return ntptr->ops->EnumPrinters(ntptr, mem_ctx, r);
 241 }
 242
 243 WERROR ntptr_OpenPrinter(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 244                          struct spoolss_OpenPrinterEx *r,
 245                          const char *printer_name,
 246                          struct ntptr_GenericHandle **printer)
 247 {
 248         if (!ntptr->ops->OpenPrinter) {
 249                 return WERR_NOT_SUPPORTED;
 250         }
 251         return ntptr->ops->OpenPrinter(ntptr, mem_ctx, r, printer_name, printer);
 252 }
 253
 254 WERROR ntptr_AddPrinter(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 255                         struct spoolss_AddPrinter *r,
 256                         struct ntptr_GenericHandle **printer)
 257 {
 258         if (!ntptr->ops->AddPrinter) {
 259                 return WERR_NOT_SUPPORTED;
 260         }
 261         return ntptr->ops->AddPrinter(ntptr, mem_ctx, r, printer);
 262 }
 263
 264 WERROR ntptr_GetPrinter(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 265                         struct spoolss_GetPrinter *r)
 266 {
 267         if (!ntptr->ops->GetPrinter) {
 268                 return WERR_NOT_SUPPORTED;
 269         }
 270         return ntptr->ops->GetPrinter(ntptr, mem_ctx, r);
 271 }
 272
 273 WERROR ntptr_SetPrinter(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 274                         struct spoolss_SetPrinter *r)
 275 {
 276         if (!ntptr->ops->SetPrinter) {
 277                 return WERR_NOT_SUPPORTED;
 278         }
 279         return ntptr->ops->SetPrinter(ntptr, mem_ctx, r);
 280 }
 281
 282 WERROR ntptr_DeletePrinter(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 283                            struct spoolss_DeletePrinter *r)
 284 {
 285         if (!ntptr->ops->DeletePrinter) {
 286                 return WERR_NOT_SUPPORTED;
 287         }
 288         return ntptr->ops->DeletePrinter(ntptr, mem_ctx, r);
 289 }
 290
 291
 292 /* Printer Driver functions */
 293 WERROR ntptr_GetPrinterDriver(struct ntptr_context *ntptr, TALLOC_CTX *mem_ctx,
 294                               struct spoolss_GetPrinterDriver *r)
 295 {
 296         if (!ntptr->ops->GetPrinterDriver) {
 297                 return WERR_NOT_SUPPORTED;
 298         }
 299         return ntptr->ops->GetPrinterDriver(ntptr, mem_ctx, r);
 300 }
 301
 302
 303 /* Printer PrinterData functions */
 304 WERROR ntptr_EnumPrinterData(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 305                              struct spoolss_EnumPrinterData *r)
 306 {
 307         if (printer->type != NTPTR_HANDLE_PRINTER) {
 308                 return WERR_FOOBAR;
 309         }
 310         if (!printer->ntptr->ops->EnumPrinterData) {
 311                 return WERR_NOT_SUPPORTED;
 312         }
 313         return printer->ntptr->ops->EnumPrinterData(printer, mem_ctx, r);
 314 }
 315
 316 WERROR ntptr_GetPrinterData(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 317                             struct spoolss_GetPrinterData *r)
 318 {
 319         if (printer->type != NTPTR_HANDLE_PRINTER) {
 320                 return WERR_FOOBAR;
 321         }
 322         if (!printer->ntptr->ops->GetPrinterData) {
 323                 return WERR_NOT_SUPPORTED;
 324         }
 325         return printer->ntptr->ops->GetPrinterData(printer, mem_ctx, r);
 326 }
 327
 328 WERROR ntptr_SetPrinterData(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 329                             struct spoolss_SetPrinterData *r)
 330 {
 331         if (printer->type != NTPTR_HANDLE_PRINTER) {
 332                 return WERR_FOOBAR;
 333         }
 334         if (!printer->ntptr->ops->SetPrinterData) {
 335                 return WERR_NOT_SUPPORTED;
 336         }
 337         return printer->ntptr->ops->SetPrinterData(printer, mem_ctx, r);
 338 }
 339
 340 WERROR ntptr_DeletePrinterData(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 341                                struct spoolss_DeletePrinterData *r)
 342 {
 343         if (printer->type != NTPTR_HANDLE_PRINTER) {
 344                 return WERR_FOOBAR;
 345         }
 346         if (!printer->ntptr->ops->DeletePrinterData) {
 347                 return WERR_NOT_SUPPORTED;
 348         }
 349         return printer->ntptr->ops->DeletePrinterData(printer, mem_ctx, r);
 350 }
 351
 352
 353 /* Printer Form functions */
 354 WERROR ntptr_EnumPrinterForms(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 355                               struct spoolss_EnumForms *r)
 356 {
 357         if (printer->type != NTPTR_HANDLE_PRINTER) {
 358                 return WERR_FOOBAR;
 359         }
 360         if (!printer->ntptr->ops->EnumPrinterForms) {
 361                 return WERR_NOT_SUPPORTED;
 362         }
 363         return printer->ntptr->ops->EnumPrinterForms(printer, mem_ctx, r);
 364 }
 365
 366 WERROR ntptr_AddPrinterForm(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 367                             struct spoolss_AddForm *r)
 368 {
 369         if (printer->type != NTPTR_HANDLE_PRINTER) {
 370                 return WERR_FOOBAR;
 371         }
 372         if (!printer->ntptr->ops->AddPrinterForm) {
 373                 return WERR_NOT_SUPPORTED;
 374         }
 375         return printer->ntptr->ops->AddPrinterForm(printer, mem_ctx, r);
 376 }
 377
 378 WERROR ntptr_GetPrinterForm(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 379                             struct spoolss_GetForm *r)
 380 {
 381         if (printer->type != NTPTR_HANDLE_PRINTER) {
 382                 return WERR_FOOBAR;
 383         }
 384         if (!printer->ntptr->ops->GetPrinterForm) {
 385                 return WERR_NOT_SUPPORTED;
 386         }
 387         return printer->ntptr->ops->GetPrinterForm(printer, mem_ctx, r);
 388 }
 389
 390 WERROR ntptr_SetPrinterForm(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 391                             struct spoolss_SetForm *r)
 392 {
 393         if (printer->type != NTPTR_HANDLE_PRINTER) {
 394                 return WERR_FOOBAR;
 395         }
 396         if (!printer->ntptr->ops->SetPrinterForm) {
 397                 return WERR_NOT_SUPPORTED;
 398         }
 399         return printer->ntptr->ops->SetPrinterForm(printer, mem_ctx, r);
 400 }
 401
 402 WERROR ntptr_DeletePrinterForm(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 403                                struct spoolss_DeleteForm *r)
 404 {
 405         if (printer->type != NTPTR_HANDLE_PRINTER) {
 406                 return WERR_FOOBAR;
 407         }
 408         if (!printer->ntptr->ops->DeletePrinterForm) {
 409                 return WERR_NOT_SUPPORTED;
 410         }
 411         return printer->ntptr->ops->DeletePrinterForm(printer, mem_ctx, r);
 412 }
 413
 414
 415 /* Printer Job functions */
 416 WERROR ntptr_EnumJobs(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 417                       struct spoolss_EnumJobs *r)
 418 {
 419         if (printer->type != NTPTR_HANDLE_PRINTER) {
 420                 return WERR_FOOBAR;
 421         }
 422         if (!printer->ntptr->ops->EnumJobs) {
 423                 return WERR_NOT_SUPPORTED;
 424         }
 425         return printer->ntptr->ops->EnumJobs(printer, mem_ctx, r);
 426 }
 427
 428 WERROR ntptr_AddJob(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 429                     struct spoolss_AddJob *r)
 430 {
 431         if (printer->type != NTPTR_HANDLE_PRINTER) {
 432                 return WERR_FOOBAR;
 433         }
 434         if (!printer->ntptr->ops->AddJob) {
 435                 return WERR_NOT_SUPPORTED;
 436         }
 437         return printer->ntptr->ops->AddJob(printer, mem_ctx, r);
 438 }
 439
 440 WERROR ntptr_ScheduleJob(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 441                          struct spoolss_ScheduleJob *r)
 442 {
 443         if (printer->type != NTPTR_HANDLE_PRINTER) {
 444                 return WERR_FOOBAR;
 445         }
 446         if (!printer->ntptr->ops->ScheduleJob) {
 447                 return WERR_NOT_SUPPORTED;
 448         }
 449         return printer->ntptr->ops->ScheduleJob(printer, mem_ctx, r);
 450 }
 451
 452 WERROR ntptr_GetJob(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 453                     struct spoolss_GetJob *r)
 454 {
 455         if (printer->type != NTPTR_HANDLE_PRINTER) {
 456                 return WERR_FOOBAR;
 457         }
 458         if (!printer->ntptr->ops->GetJob) {
 459                 return WERR_NOT_SUPPORTED;
 460         }
 461         return printer->ntptr->ops->GetJob(printer, mem_ctx, r);
 462 }
 463
 464 WERROR ntptr_SetJob(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 465                     struct spoolss_SetJob *r)
 466 {
 467         if (printer->type != NTPTR_HANDLE_PRINTER) {
 468                 return WERR_FOOBAR;
 469         }
 470         if (!printer->ntptr->ops->SetJob) {
 471                 return WERR_NOT_SUPPORTED;
 472         }
 473         return printer->ntptr->ops->SetJob(printer, mem_ctx, r);
 474 }
 475
 476
 477 /* Printer Printing functions */
 478 WERROR ntptr_StartDocPrinter(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 479                              struct spoolss_StartDocPrinter *r)
 480 {
 481         if (printer->type != NTPTR_HANDLE_PRINTER) {
 482                 return WERR_FOOBAR;
 483         }
 484         if (!printer->ntptr->ops->StartDocPrinter) {
 485                 return WERR_NOT_SUPPORTED;
 486         }
 487         return printer->ntptr->ops->StartDocPrinter(printer, mem_ctx, r);
 488 }
 489
 490 WERROR ntptr_EndDocPrinter(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 491                            struct spoolss_EndDocPrinter *r)
 492 {
 493         if (printer->type != NTPTR_HANDLE_PRINTER) {
 494                 return WERR_FOOBAR;
 495         }
 496         if (!printer->ntptr->ops->EndDocPrinter) {
 497                 return WERR_NOT_SUPPORTED;
 498         }
 499         return printer->ntptr->ops->EndDocPrinter(printer, mem_ctx, r);
 500 }
 501
 502 WERROR ntptr_StartPagePrinter(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 503                               struct spoolss_StartPagePrinter *r)
 504 {
 505         if (printer->type != NTPTR_HANDLE_PRINTER) {
 506                 return WERR_FOOBAR;
 507         }
 508         if (!printer->ntptr->ops->StartPagePrinter) {
 509                 return WERR_NOT_SUPPORTED;
 510         }
 511         return printer->ntptr->ops->StartPagePrinter(printer, mem_ctx, r);
 512 }
 513
 514 WERROR ntptr_EndPagePrinter(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 515                             struct spoolss_EndPagePrinter *r)
 516 {
 517         if (printer->type != NTPTR_HANDLE_PRINTER) {
 518                 return WERR_FOOBAR;
 519         }
 520         if (!printer->ntptr->ops->EndPagePrinter) {
 521                 return WERR_NOT_SUPPORTED;
 522         }
 523         return printer->ntptr->ops->EndPagePrinter(printer, mem_ctx, r);
 524 }
 525
 526 WERROR ntptr_WritePrinter(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 527                           struct spoolss_WritePrinter *r)
 528 {
 529         if (printer->type != NTPTR_HANDLE_PRINTER) {
 530                 return WERR_FOOBAR;
 531         }
 532         if (!printer->ntptr->ops->WritePrinter) {
 533                 return WERR_NOT_SUPPORTED;
 534         }
 535         return printer->ntptr->ops->WritePrinter(printer, mem_ctx, r);
 536 }
 537
 538 WERROR ntptr_ReadPrinter(struct ntptr_GenericHandle *printer, TALLOC_CTX *mem_ctx,
 539                          struct spoolss_ReadPrinter *r)
 540 {
 541         if (printer->type != NTPTR_HANDLE_PRINTER) {
 542                 return WERR_FOOBAR;
 543         }
 544         if (!printer->ntptr->ops->ReadPrinter) {
 545                 return WERR_NOT_SUPPORTED;
 546         }
 547         return printer->ntptr->ops->ReadPrinter(printer, mem_ctx, r);
 548 }
 549