systemv/lpadmin.c

   1 /*
   2  * "lpadmin" command for CUPS.
   3  *
   4  * Copyright © 2007-2018 by Apple Inc.
   5  * Copyright © 1997-2006 by Easy Software Products.
   6  *
   7  * Licensed under Apache License v2.0.  See the file "LICENSE" for more information.
   8  */
   9
  10 /*
  11  * Include necessary headers...
  12  */
  13
  14 #define _CUPS_NO_DEPRECATED
  15 #define _PPD_DEPRECATED
  16 #include <cups/cups-private.h>
  17 #include <cups/ppd-private.h>
  18
  19
  20 /*
  21  * Local functions...
  22  */
  23
  24 static int              add_printer_to_class(http_t *http, char *printer, char *pclass);
  25 static int              default_printer(http_t *http, char *printer);
  26 static int              delete_printer(http_t *http, char *printer);
  27 static int              delete_printer_from_class(http_t *http, char *printer,
  28                                                   char *pclass);
  29 static int              delete_printer_option(http_t *http, char *printer,
  30                                               char *option);
  31 static int              enable_printer(http_t *http, char *printer);
  32 static char             *get_printer_ppd(const char *uri, char *buffer, size_t bufsize, int *num_options, cups_option_t **options);
  33 static cups_ptype_t     get_printer_type(http_t *http, char *printer, char *uri,
  34                                          size_t urisize);
  35 static int              set_printer_options(http_t *http, char *printer,
  36                                             int num_options, cups_option_t *options,
  37                                             char *file);
  38 static int              validate_name(const char *name);
  39
  40
  41 /*
  42  * 'main()' - Parse options and configure the scheduler.
  43  */
  44
  45 int                                     /* O - Exit status */
  46 main(int  argc,                         /* I - Number of command-line arguments */
  47      char *argv[])                      /* I - Command-line arguments */
  48 {
  49   int           i;                      /* Looping var */
  50   http_t        *http;                  /* Connection to server */
  51   char          *printer,               /* Destination printer */
  52                 *pclass,                /* Printer class name */
  53                 *opt,                   /* Option pointer */
  54                 *val;                   /* Pointer to allow/deny value */
  55   int           num_options;            /* Number of options */
  56   cups_option_t *options;               /* Options */
  57   char          *file,                  /* New PPD file */
  58                 evefile[1024] = "";     /* IPP Everywhere PPD */
  59   const char    *ppd_name,              /* ppd-name value */
  60                 *device_uri;            /* device-uri value */
  61
  62
  63   _cupsSetLocale(argv);
  64
  65   http        = NULL;
  66   printer     = NULL;
  67   num_options = 0;
  68   options     = NULL;
  69   file        = NULL;
  70
  71   for (i = 1; i < argc; i ++)
  72   {
  73     if (argv[i][0] == '-')
  74     {
  75       for (opt = argv[i] + 1; *opt; opt ++)
  76       {
  77         switch (*opt)
  78         {
  79           case 'c' : /* Add printer to class */
  80               if (!http)
  81               {
  82                 http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, cupsEncryption(), 1, 30000, NULL);
  83
  84                 if (http == NULL)
  85                 {
  86                   _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno));
  87                   return (1);
  88                 }
  89               }
  90
  91               if (printer == NULL)
  92               {
  93                 _cupsLangPuts(stderr,
  94                               _("lpadmin: Unable to add a printer to the class:\n"
  95                                 "         You must specify a printer name first."));
  96                 return (1);
  97               }
  98
  99               if (opt[1] != '\0')
 100               {
 101                 pclass = opt + 1;
 102                 opt += strlen(opt) - 1;
 103               }
 104               else
 105               {
 106                 i ++;
 107
 108                 if (i >= argc)
 109                 {
 110                   _cupsLangPuts(stderr, _("lpadmin: Expected class name after \"-c\" option."));
 111                   return (1);
 112                 }
 113
 114                 pclass = argv[i];
 115               }
 116
 117               if (!validate_name(pclass))
 118               {
 119                 _cupsLangPuts(stderr,
 120                               _("lpadmin: Class name can only contain printable "
 121                                 "characters."));
 122                 return (1);
 123               }
 124
 125               if (add_printer_to_class(http, printer, pclass))
 126                 return (1);
 127               break;
 128
 129           case 'd' : /* Set as default destination */
 130               if (!http)
 131               {
 132                 http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, cupsEncryption(), 1, 30000, NULL);
 133
 134                 if (http == NULL)
 135                 {
 136                   _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno));
 137                   return (1);
 138                 }
 139               }
 140
 141               if (opt[1] != '\0')
 142               {
 143                 printer = opt + 1;
 144                 opt += strlen(opt) - 1;
 145               }
 146               else
 147               {
 148                 i ++;
 149
 150                 if (i >= argc)
 151                 {
 152                   _cupsLangPuts(stderr, _("lpadmin: Expected printer name after \"-d\" option."));
 153                   return (1);
 154                 }
 155
 156                 printer = argv[i];
 157               }
 158
 159               if (!validate_name(printer))
 160               {
 161                 _cupsLangPuts(stderr, _("lpadmin: Printer name can only contain printable characters."));
 162                 return (1);
 163               }
 164
 165               if (default_printer(http, printer))
 166                 return (1);
 167
 168               i = argc;
 169               break;
 170
 171           case 'h' : /* Connect to host */
 172               if (http)
 173               {
 174                 httpClose(http);
 175                 http = NULL;
 176               }
 177
 178               if (opt[1] != '\0')
 179               {
 180                 cupsSetServer(opt + 1);
 181                 opt += strlen(opt) - 1;
 182               }
 183               else
 184               {
 185                 i ++;
 186
 187                 if (i >= argc)
 188                 {
 189                   _cupsLangPuts(stderr, _("lpadmin: Expected hostname after \"-h\" option."));
 190                   return (1);
 191                 }
 192
 193                 cupsSetServer(argv[i]);
 194               }
 195               break;
 196
 197           case 'P' : /* Use the specified PPD file */
 198           case 'i' : /* Use the specified PPD file */
 199               if (opt[1] != '\0')
 200               {
 201                 file = opt + 1;
 202                 opt += strlen(opt) - 1;
 203               }
 204               else
 205               {
 206                 i ++;
 207
 208                 if (i >= argc)
 209                 {
 210                   _cupsLangPrintf(stderr, _("lpadmin: Expected PPD after \"-%c\" option."), argv[i - 1][1]);
 211                   return (1);
 212                 }
 213
 214                 file = argv[i];
 215               }
 216
 217               if (*opt == 'i')
 218               {
 219                /*
 220                 * Check to see that the specified file is, in fact, a PPD...
 221                 */
 222
 223                 cups_file_t *fp = cupsFileOpen(file, "r");
 224                 char line[256];
 225
 226                 if (!cupsFileGets(fp, line, sizeof(line)) || strncmp(line, "*PPD-Adobe", 10))
 227                 {
 228                   _cupsLangPuts(stderr, _("lpadmin: System V interface scripts are no longer supported for security reasons."));
 229                   cupsFileClose(fp);
 230                   return (1);
 231                 }
 232
 233                 cupsFileClose(fp);
 234               }
 235               break;
 236
 237           case 'E' : /* Enable the printer/enable encryption */
 238               if (printer == NULL)
 239               {
 240 #ifdef HAVE_SSL
 241                 cupsSetEncryption(HTTP_ENCRYPTION_REQUIRED);
 242
 243                 if (http)
 244                   httpEncryption(http, HTTP_ENCRYPTION_REQUIRED);
 245 #else
 246                 _cupsLangPrintf(stderr, _("%s: Sorry, no encryption support."), argv[0]);
 247 #endif /* HAVE_SSL */
 248                 break;
 249               }
 250
 251               if (!http)
 252               {
 253                 http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, cupsEncryption(), 1, 30000, NULL);
 254
 255                 if (http == NULL)
 256                 {
 257                   _cupsLangPrintf(stderr,
 258                                   _("lpadmin: Unable to connect to server: %s"),
 259                                   strerror(errno));
 260                   return (1);
 261                 }
 262               }
 263
 264               if (enable_printer(http, printer))
 265                 return (1);
 266               break;
 267
 268           case 'm' : /* Use the specified standard script/PPD file */
 269               if (opt[1] != '\0')
 270               {
 271                 num_options = cupsAddOption("ppd-name", opt + 1, num_options, &options);
 272                 opt += strlen(opt) - 1;
 273               }
 274               else
 275               {
 276                 i ++;
 277
 278                 if (i >= argc)
 279                 {
 280                   _cupsLangPuts(stderr, _("lpadmin: Expected model after \"-m\" option."));
 281                   return (1);
 282                 }
 283
 284                 num_options = cupsAddOption("ppd-name", argv[i], num_options, &options);
 285               }
 286               break;
 287
 288           case 'o' : /* Set option */
 289               if (opt[1] != '\0')
 290               {
 291                 num_options = cupsParseOptions(opt + 1, num_options, &options);
 292                 opt += strlen(opt) - 1;
 293               }
 294               else
 295               {
 296                 i ++;
 297
 298                 if (i >= argc)
 299                 {
 300                   _cupsLangPuts(stderr, _("lpadmin: Expected name=value after \"-o\" option."));
 301                   return (1);
 302                 }
 303
 304                 num_options = cupsParseOptions(argv[i], num_options, &options);
 305               }
 306               break;
 307
 308           case 'p' : /* Add/modify a printer */
 309               if (opt[1] != '\0')
 310               {
 311                 printer = opt + 1;
 312                 opt += strlen(opt) - 1;
 313               }
 314               else
 315               {
 316                 i ++;
 317
 318                 if (i >= argc)
 319                 {
 320                   _cupsLangPuts(stderr, _("lpadmin: Expected printer after \"-p\" option."));
 321                   return (1);
 322                 }
 323
 324                 printer = argv[i];
 325               }
 326
 327               if (!validate_name(printer))
 328               {
 329                 _cupsLangPuts(stderr, _("lpadmin: Printer name can only contain printable characters."));
 330                 return (1);
 331               }
 332               break;
 333
 334           case 'r' : /* Remove printer from class */
 335               if (!http)
 336               {
 337                 http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, cupsEncryption(), 1, 30000, NULL);
 338
 339                 if (http == NULL)
 340                 {
 341                   _cupsLangPrintf(stderr,
 342                                   _("lpadmin: Unable to connect to server: %s"),
 343                                   strerror(errno));
 344                   return (1);
 345                 }
 346               }
 347
 348               if (printer == NULL)
 349               {
 350                 _cupsLangPuts(stderr,
 351                               _("lpadmin: Unable to remove a printer from the class:\n"
 352                                 "         You must specify a printer name first."));
 353                 return (1);
 354               }
 355
 356               if (opt[1] != '\0')
 357               {
 358                 pclass = opt + 1;
 359                 opt += strlen(opt) - 1;
 360               }
 361               else
 362               {
 363                 i ++;
 364
 365                 if (i >= argc)
 366                 {
 367                   _cupsLangPuts(stderr, _("lpadmin: Expected class after \"-r\" option."));
 368                   return (1);
 369                 }
 370
 371                 pclass = argv[i];
 372               }
 373
 374               if (!validate_name(pclass))
 375               {
 376                 _cupsLangPuts(stderr, _("lpadmin: Class name can only contain printable characters."));
 377                 return (1);
 378               }
 379
 380               if (delete_printer_from_class(http, printer, pclass))
 381                 return (1);
 382               break;
 383
 384           case 'R' : /* Remove option */
 385               if (!http)
 386               {
 387                 http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, cupsEncryption(), 1, 30000, NULL);
 388
 389                 if (http == NULL)
 390                 {
 391                   _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"), strerror(errno));
 392                   return (1);
 393                 }
 394               }
 395
 396               if (printer == NULL)
 397               {
 398                 _cupsLangPuts(stderr,
 399                               _("lpadmin: Unable to delete option:\n"
 400                                 "         You must specify a printer name first."));
 401                 return (1);
 402               }
 403
 404               if (opt[1] != '\0')
 405               {
 406                 val = opt + 1;
 407                 opt += strlen(opt) - 1;
 408               }
 409               else
 410               {
 411                 i ++;
 412
 413                 if (i >= argc)
 414                 {
 415                   _cupsLangPuts(stderr, _("lpadmin: Expected name after \"-R\" option."));
 416                   return (1);
 417                 }
 418
 419                 val = argv[i];
 420               }
 421
 422               if (delete_printer_option(http, printer, val))
 423                 return (1);
 424               break;
 425
 426           case 'U' : /* Username */
 427               if (opt[1] != '\0')
 428               {
 429                 cupsSetUser(opt + 1);
 430                 opt += strlen(opt) - 1;
 431               }
 432               else
 433               {
 434                 i ++;
 435                 if (i >= argc)
 436                 {
 437                   _cupsLangPrintf(stderr, _("%s: Error - expected username after \"-U\" option."), argv[0]);
 438                   return (1);
 439                 }
 440
 441                 cupsSetUser(argv[i]);
 442               }
 443               break;
 444
 445           case 'u' : /* Allow/deny users */
 446               if (opt[1] != '\0')
 447               {
 448                 val = opt + 1;
 449                 opt += strlen(opt) - 1;
 450               }
 451               else
 452               {
 453                 i ++;
 454
 455                 if (i >= argc)
 456                 {
 457                   _cupsLangPuts(stderr, _("lpadmin: Expected allow/deny:userlist after \"-u\" option."));
 458                   return (1);
 459                 }
 460
 461                 val = argv[i];
 462               }
 463
 464               if (!_cups_strncasecmp(val, "allow:", 6))
 465                 num_options = cupsAddOption("requesting-user-name-allowed", val + 6, num_options, &options);
 466               else if (!_cups_strncasecmp(val, "deny:", 5))
 467                 num_options = cupsAddOption("requesting-user-name-denied", val + 5, num_options, &options);
 468               else
 469               {
 470                 _cupsLangPrintf(stderr, _("lpadmin: Unknown allow/deny option \"%s\"."), val);
 471                 return (1);
 472               }
 473               break;
 474
 475           case 'v' : /* Set the device-uri attribute */
 476               if (opt[1] != '\0')
 477               {
 478                 num_options = cupsAddOption("device-uri", opt + 1, num_options, &options);
 479                 opt += strlen(opt) - 1;
 480               }
 481               else
 482               {
 483                 i ++;
 484
 485                 if (i >= argc)
 486                 {
 487                   _cupsLangPuts(stderr, _("lpadmin: Expected device URI after \"-v\" option."));
 488                   return (1);
 489                 }
 490
 491                 num_options = cupsAddOption("device-uri", argv[i], num_options, &options);
 492               }
 493               break;
 494
 495           case 'x' : /* Delete a printer */
 496               if (!http)
 497               {
 498                 http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC, cupsEncryption(), 1, 30000, NULL);
 499
 500                 if (http == NULL)
 501                 {
 502                   _cupsLangPrintf(stderr,
 503                                   _("lpadmin: Unable to connect to server: %s"),
 504                                   strerror(errno));
 505                   return (1);
 506                 }
 507               }
 508
 509               if (opt[1] != '\0')
 510               {
 511                 printer = opt + 1;
 512                 opt += strlen(opt) - 1;
 513               }
 514               else
 515               {
 516                 i ++;
 517
 518                 if (i >= argc)
 519                 {
 520                   _cupsLangPuts(stderr, _("lpadmin: Expected printer or class after \"-x\" option."));
 521                   return (1);
 522                 }
 523
 524                 printer = argv[i];
 525               }
 526
 527               if (!validate_name(printer))
 528               {
 529                 _cupsLangPuts(stderr, _("lpadmin: Printer name can only contain printable characters."));
 530                 return (1);
 531               }
 532
 533               if (delete_printer(http, printer))
 534                 return (1);
 535
 536               i = argc;
 537               break;
 538
 539           case 'D' : /* Set the printer-info attribute */
 540               if (opt[1] != '\0')
 541               {
 542                 num_options = cupsAddOption("printer-info", opt + 1, num_options, &options);
 543                 opt += strlen(opt) - 1;
 544               }
 545               else
 546               {
 547                 i ++;
 548
 549                 if (i >= argc)
 550                 {
 551                   _cupsLangPuts(stderr, _("lpadmin: Expected description after \"-D\" option."));
 552                   return (1);
 553                 }
 554
 555                 num_options = cupsAddOption("printer-info", argv[i], num_options, &options);
 556               }
 557               break;
 558
 559           case 'I' : /* Set the supported file types (ignored) */
 560               i ++;
 561
 562               if (i >= argc)
 563               {
 564                 _cupsLangPuts(stderr, _("lpadmin: Expected file type(s) after \"-I\" option."));
 565                 return (1);
 566               }
 567
 568               _cupsLangPuts(stderr, _("lpadmin: Warning - content type list ignored."));
 569               break;
 570
 571           case 'L' : /* Set the printer-location attribute */
 572               if (opt[1] != '\0')
 573               {
 574                 num_options = cupsAddOption("printer-location", opt + 1, num_options, &options);
 575                 opt += strlen(opt) - 1;
 576               }
 577               else
 578               {
 579                 i ++;
 580
 581                 if (i >= argc)
 582                 {
 583                   _cupsLangPuts(stderr, _("lpadmin: Expected location after \"-L\" option."));
 584                   return (1);
 585                 }
 586
 587                 num_options = cupsAddOption("printer-location", argv[i], num_options, &options);
 588               }
 589               break;
 590
 591           default :
 592               _cupsLangPrintf(stderr, _("lpadmin: Unknown option \"%c\"."), *opt);
 593               return (1);
 594         }
 595       }
 596     }
 597     else
 598     {
 599       _cupsLangPrintf(stderr, _("lpadmin: Unknown argument \"%s\"."), argv[i]);
 600       return (1);
 601     }
 602   }
 603
 604  /*
 605   * Set options as needed...
 606   */
 607
 608   ppd_name   = cupsGetOption("ppd-name", num_options, options);
 609   device_uri = cupsGetOption("device-uri", num_options, options);
 610
 611   if (ppd_name && !strcmp(ppd_name, "raw"))
 612   {
 613     _cupsLangPuts(stderr, _("lpadmin: Raw queues are deprecated and will stop working in a future version of CUPS."));
 614
 615     if (device_uri && (!strncmp(device_uri, "ipp://", 6) || !strncmp(device_uri, "ipps://", 7)) && strstr(device_uri, "/printers/"))
 616       _cupsLangPuts(stderr, _("lpadmin: Use the 'everywhere' model for shared printers."));
 617   }
 618   else if (ppd_name && !strcmp(ppd_name, "everywhere") && device_uri)
 619   {
 620     if ((file = get_printer_ppd(device_uri, evefile, sizeof(evefile), &num_options, &options)) == NULL)
 621       return (1);
 622
 623     num_options = cupsRemoveOption("ppd-name", num_options, &options);
 624   }
 625
 626   if (num_options || file)
 627   {
 628     if (printer == NULL)
 629     {
 630       _cupsLangPuts(stderr,
 631                     _("lpadmin: Unable to set the printer options:\n"
 632                       "         You must specify a printer name first."));
 633       return (1);
 634     }
 635
 636     if (!http)
 637     {
 638       http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC,
 639                           cupsEncryption(), 1, 30000, NULL);
 640
 641       if (http == NULL) {
 642         _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"),
 643                         strerror(errno));
 644         return (1);
 645       }
 646     }
 647
 648     if (set_printer_options(http, printer, num_options, options, file))
 649       return (1);
 650   }
 651
 652   if (evefile[0])
 653     unlink(evefile);
 654
 655   if (printer == NULL)
 656   {
 657     _cupsLangPuts(stdout,
 658                   _("Usage:\n"
 659                     "\n"
 660                     "    lpadmin [-h server] -d destination\n"
 661                     "    lpadmin [-h server] -x destination\n"
 662                     "    lpadmin [-h server] -p printer [-c add-class] "
 663                     "[-i interface] [-m model]\n"
 664                     "                       [-r remove-class] [-v device] "
 665                     "[-D description]\n"
 666                     "                       [-P ppd-file] [-o name=value]\n"
 667                     "                       [-u allow:user,user] "
 668                     "[-u deny:user,user]"));
 669   }
 670
 671   if (http)
 672     httpClose(http);
 673
 674   return (0);
 675 }
 676
 677
 678 /*
 679  * 'add_printer_to_class()' - Add a printer to a class.
 680  */
 681
 682 static int                              /* O - 0 on success, 1 on fail */
 683 add_printer_to_class(http_t *http,      /* I - Server connection */
 684                      char   *printer,   /* I - Printer to add */
 685                      char   *pclass)    /* I - Class to add to */
 686 {
 687   int           i;                      /* Looping var */
 688   ipp_t         *request,               /* IPP Request */
 689                 *response;              /* IPP Response */
 690   ipp_attribute_t *attr,                /* Current attribute */
 691                 *members;               /* Members in class */
 692   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
 693
 694
 695   DEBUG_printf(("add_printer_to_class(%p, \"%s\", \"%s\")\n", http,
 696                 printer, pclass));
 697
 698  /*
 699   * Build an IPP_OP_GET_PRINTER_ATTRIBUTES request, which requires the following
 700   * attributes:
 701   *
 702   *    attributes-charset
 703   *    attributes-natural-language
 704   *    printer-uri
 705   *    requesting-user-name
 706   */
 707
 708   request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
 709
 710   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 711                    "localhost", 0, "/classes/%s", pclass);
 712   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 713                "printer-uri", NULL, uri);
 714   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 715                NULL, cupsUser());
 716
 717  /*
 718   * Do the request and get back a response...
 719   */
 720
 721   response = cupsDoRequest(http, request, "/");
 722
 723  /*
 724   * Build a CUPS-Add-Modify-Class request, which requires the following
 725   * attributes:
 726   *
 727   *    attributes-charset
 728   *    attributes-natural-language
 729   *    printer-uri
 730   *    requesting-user-name
 731   *    member-uris
 732   */
 733
 734   request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
 735
 736   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 737                "printer-uri", NULL, uri);
 738   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 739                NULL, cupsUser());
 740
 741  /*
 742   * See if the printer is already in the class...
 743   */
 744
 745   if (response != NULL &&
 746       (members = ippFindAttribute(response, "member-names",
 747                                   IPP_TAG_NAME)) != NULL)
 748     for (i = 0; i < members->num_values; i ++)
 749       if (_cups_strcasecmp(printer, members->values[i].string.text) == 0)
 750       {
 751         _cupsLangPrintf(stderr,
 752                         _("lpadmin: Printer %s is already a member of class "
 753                           "%s."), printer, pclass);
 754         ippDelete(request);
 755         ippDelete(response);
 756         return (0);
 757       }
 758
 759  /*
 760   * OK, the printer isn't part of the class, so add it...
 761   */
 762
 763   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 764                    "localhost", 0, "/printers/%s", printer);
 765
 766   if (response != NULL &&
 767       (members = ippFindAttribute(response, "member-uris",
 768                                   IPP_TAG_URI)) != NULL)
 769   {
 770    /*
 771     * Add the printer to the existing list...
 772     */
 773
 774     attr = ippAddStrings(request, IPP_TAG_PRINTER, IPP_TAG_URI,
 775                          "member-uris", members->num_values + 1, NULL, NULL);
 776     for (i = 0; i < members->num_values; i ++)
 777       attr->values[i].string.text =
 778           _cupsStrAlloc(members->values[i].string.text);
 779
 780     attr->values[i].string.text = _cupsStrAlloc(uri);
 781   }
 782   else
 783     ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_URI, "member-uris", NULL,
 784                  uri);
 785
 786  /*
 787   * Then send the request...
 788   */
 789
 790   ippDelete(response);
 791
 792   ippDelete(cupsDoRequest(http, request, "/admin/"));
 793   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
 794   {
 795     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
 796
 797     return (1);
 798   }
 799   else
 800     return (0);
 801 }
 802
 803
 804 /*
 805  * 'default_printer()' - Set the default printing destination.
 806  */
 807
 808 static int                              /* O - 0 on success, 1 on fail */
 809 default_printer(http_t *http,           /* I - Server connection */
 810                 char   *printer)        /* I - Printer name */
 811 {
 812   ipp_t         *request;               /* IPP Request */
 813   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
 814
 815
 816   DEBUG_printf(("default_printer(%p, \"%s\")\n", http, printer));
 817
 818  /*
 819   * Build a CUPS-Set-Default request, which requires the following
 820   * attributes:
 821   *
 822   *    attributes-charset
 823   *    attributes-natural-language
 824   *    printer-uri
 825   *    requesting-user-name
 826   */
 827
 828   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 829                    "localhost", 0, "/printers/%s", printer);
 830
 831   request = ippNewRequest(IPP_OP_CUPS_SET_DEFAULT);
 832
 833   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 834                "printer-uri", NULL, uri);
 835   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 836                NULL, cupsUser());
 837
 838  /*
 839   * Do the request and get back a response...
 840   */
 841
 842   ippDelete(cupsDoRequest(http, request, "/admin/"));
 843
 844   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
 845   {
 846     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
 847
 848     return (1);
 849   }
 850   else
 851     return (0);
 852 }
 853
 854
 855 /*
 856  * 'delete_printer()' - Delete a printer from the system...
 857  */
 858
 859 static int                              /* O - 0 on success, 1 on fail */
 860 delete_printer(http_t *http,            /* I - Server connection */
 861                char   *printer)         /* I - Printer to delete */
 862 {
 863   ipp_t         *request;               /* IPP Request */
 864   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
 865
 866
 867   DEBUG_printf(("delete_printer(%p, \"%s\")\n", http, printer));
 868
 869  /*
 870   * Build a CUPS-Delete-Printer request, which requires the following
 871   * attributes:
 872   *
 873   *    attributes-charset
 874   *    attributes-natural-language
 875   *    printer-uri
 876   *    requesting-user-name
 877   */
 878
 879   request = ippNewRequest(IPP_OP_CUPS_DELETE_PRINTER);
 880
 881   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 882                    "localhost", 0, "/printers/%s", printer);
 883   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 884                "printer-uri", NULL, uri);
 885   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 886                NULL, cupsUser());
 887
 888  /*
 889   * Do the request and get back a response...
 890   */
 891
 892   ippDelete(cupsDoRequest(http, request, "/admin/"));
 893
 894   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
 895   {
 896     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
 897
 898     return (1);
 899   }
 900   else
 901     return (0);
 902 }
 903
 904
 905 /*
 906  * 'delete_printer_from_class()' - Delete a printer from a class.
 907  */
 908
 909 static int                              /* O - 0 on success, 1 on fail */
 910 delete_printer_from_class(
 911     http_t *http,                       /* I - Server connection */
 912     char   *printer,                    /* I - Printer to remove */
 913     char   *pclass)                     /* I - Class to remove from */
 914 {
 915   int           i, j, k;                /* Looping vars */
 916   ipp_t         *request,               /* IPP Request */
 917                 *response;              /* IPP Response */
 918   ipp_attribute_t *attr,                /* Current attribute */
 919                 *members;               /* Members in class */
 920   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
 921
 922
 923   DEBUG_printf(("delete_printer_from_class(%p, \"%s\", \"%s\")\n", http,
 924                 printer, pclass));
 925
 926  /*
 927   * Build an IPP_OP_GET_PRINTER_ATTRIBUTES request, which requires the following
 928   * attributes:
 929   *
 930   *    attributes-charset
 931   *    attributes-natural-language
 932   *    printer-uri
 933   *    requesting-user-name
 934   */
 935
 936   request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
 937
 938   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 939                    "localhost", 0, "/classes/%s", pclass);
 940   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 941                "printer-uri", NULL, uri);
 942   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 943                NULL, cupsUser());
 944
 945  /*
 946   * Do the request and get back a response...
 947   */
 948
 949   if ((response = cupsDoRequest(http, request, "/classes/")) == NULL ||
 950       response->request.status.status_code == IPP_STATUS_ERROR_NOT_FOUND)
 951   {
 952     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
 953
 954     ippDelete(response);
 955
 956     return (1);
 957   }
 958
 959  /*
 960   * See if the printer is already in the class...
 961   */
 962
 963   if ((members = ippFindAttribute(response, "member-names", IPP_TAG_NAME)) == NULL)
 964   {
 965     _cupsLangPuts(stderr, _("lpadmin: No member names were seen."));
 966
 967     ippDelete(response);
 968
 969     return (1);
 970   }
 971
 972   for (i = 0; i < members->num_values; i ++)
 973     if (!_cups_strcasecmp(printer, members->values[i].string.text))
 974       break;
 975
 976   if (i >= members->num_values)
 977   {
 978     _cupsLangPrintf(stderr,
 979                     _("lpadmin: Printer %s is not a member of class %s."),
 980                     printer, pclass);
 981
 982     ippDelete(response);
 983
 984     return (1);
 985   }
 986
 987   if (members->num_values == 1)
 988   {
 989    /*
 990     * Build a CUPS-Delete-Class request, which requires the following
 991     * attributes:
 992     *
 993     *    attributes-charset
 994     *    attributes-natural-language
 995     *    printer-uri
 996     *    requesting-user-name
 997     */
 998
 999     request = ippNewRequest(IPP_OP_CUPS_DELETE_CLASS);
1000
1001     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1002                  "printer-uri", NULL, uri);
1003     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1004                  "requesting-user-name", NULL, cupsUser());
1005   }
1006   else
1007   {
1008    /*
1009     * Build a IPP_OP_CUPS_ADD_MODIFY_CLASS request, which requires the following
1010     * attributes:
1011     *
1012     *    attributes-charset
1013     *    attributes-natural-language
1014     *    printer-uri
1015     *    requesting-user-name
1016     *    member-uris
1017     */
1018
1019     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
1020
1021     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1022                  "printer-uri", NULL, uri);
1023     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1024                  "requesting-user-name", NULL, cupsUser());
1025
1026    /*
1027     * Delete the printer from the class...
1028     */
1029
1030     members = ippFindAttribute(response, "member-uris", IPP_TAG_URI);
1031     attr = ippAddStrings(request, IPP_TAG_PRINTER, IPP_TAG_URI,
1032                          "member-uris", members->num_values - 1, NULL, NULL);
1033
1034     for (j = 0, k = 0; j < members->num_values; j ++)
1035       if (j != i)
1036         attr->values[k ++].string.text =
1037             _cupsStrAlloc(members->values[j].string.text);
1038   }
1039
1040  /*
1041   * Then send the request...
1042   */
1043
1044   ippDelete(response);
1045
1046   ippDelete(cupsDoRequest(http, request, "/admin/"));
1047
1048   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
1049   {
1050     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
1051
1052     return (1);
1053   }
1054   else
1055     return (0);
1056 }
1057
1058
1059 /*
1060  * 'delete_printer_option()' - Delete a printer option.
1061  */
1062
1063 static int                              /* O - 0 on success, 1 on fail */
1064 delete_printer_option(http_t *http,     /* I - Server connection */
1065                       char   *printer,  /* I - Printer */
1066                       char   *option)   /* I - Option to delete */
1067 {
1068   ipp_t         *request;               /* IPP request */
1069   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
1070
1071
1072  /*
1073   * Build a IPP_OP_CUPS_ADD_MODIFY_PRINTER or IPP_OP_CUPS_ADD_MODIFY_CLASS request, which
1074   * requires the following attributes:
1075   *
1076   *    attributes-charset
1077   *    attributes-natural-language
1078   *    printer-uri
1079   *    requesting-user-name
1080   *    option with deleteAttr tag
1081   */
1082
1083   if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS)
1084     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
1085   else
1086     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_PRINTER);
1087
1088   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1089                "printer-uri", NULL, uri);
1090   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1091                "requesting-user-name", NULL, cupsUser());
1092   ippAddInteger(request, IPP_TAG_PRINTER, IPP_TAG_DELETEATTR, option, 0);
1093
1094  /*
1095   * Do the request and get back a response...
1096   */
1097
1098   ippDelete(cupsDoRequest(http, request, "/admin/"));
1099
1100   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
1101   {
1102     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
1103
1104     return (1);
1105   }
1106   else
1107     return (0);
1108 }
1109
1110
1111 /*
1112  * 'enable_printer()' - Enable a printer...
1113  */
1114
1115 static int                              /* O - 0 on success, 1 on fail */
1116 enable_printer(http_t *http,            /* I - Server connection */
1117                char   *printer)         /* I - Printer to enable */
1118 {
1119   ipp_t         *request;               /* IPP Request */
1120   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
1121
1122
1123   DEBUG_printf(("enable_printer(%p, \"%s\")\n", http, printer));
1124
1125  /*
1126   * Build a IPP_OP_CUPS_ADD_MODIFY_PRINTER or IPP_OP_CUPS_ADD_MODIFY_CLASS request, which
1127   * require the following attributes:
1128   *
1129   *    attributes-charset
1130   *    attributes-natural-language
1131   *    printer-uri
1132   *    requesting-user-name
1133   *    printer-state
1134   *    printer-is-accepting-jobs
1135   */
1136
1137   if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS)
1138     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
1139   else
1140     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_PRINTER);
1141
1142   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1143                "printer-uri", NULL, uri);
1144   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1145                "requesting-user-name", NULL, cupsUser());
1146   ippAddInteger(request, IPP_TAG_PRINTER, IPP_TAG_ENUM, "printer-state",
1147                 IPP_PSTATE_IDLE);
1148   ippAddBoolean(request, IPP_TAG_PRINTER, "printer-is-accepting-jobs", 1);
1149
1150  /*
1151   * Do the request and get back a response...
1152   */
1153
1154   ippDelete(cupsDoRequest(http, request, "/admin/"));
1155
1156   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
1157   {
1158     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
1159
1160     return (1);
1161   }
1162   else
1163     return (0);
1164 }
1165
1166
1167 /*
1168  * 'get_printer_ppd()' - Get an IPP Everywhere PPD file for the given URI.
1169  */
1170
1171 static char *                           /* O  - Filename or NULL */
1172 get_printer_ppd(
1173     const char    *uri,                 /* I  - Printer URI */
1174     char          *buffer,              /* I  - Filename buffer */
1175     size_t        bufsize,              /* I  - Size of filename buffer */
1176     int           *num_options,         /* IO - Number of options */
1177     cups_option_t **options)            /* IO - Options */
1178 {
1179   http_t        *http;                  /* Connection to printer */
1180   ipp_t         *request,               /* Get-Printer-Attributes request */
1181                 *response;              /* Get-Printer-Attributes response */
1182   ipp_attribute_t *attr;                /* Attribute from response */
1183   char          resolved[1024],         /* Resolved URI */
1184                 scheme[32],             /* URI scheme */
1185                 userpass[256],          /* Username:password */
1186                 host[256],              /* Hostname */
1187                 resource[256];          /* Resource path */
1188   int           port;                   /* Port number */
1189   static const char * const pattrs[] =  /* Attributes to use */
1190   {
1191     "job-template",
1192     "printer-defaults",
1193     "printer-description",
1194     "media-col-database"
1195   };
1196
1197
1198  /*
1199   * Connect to the printer...
1200   */
1201
1202   if (strstr(uri, "._tcp"))
1203   {
1204    /*
1205     * Resolve URI...
1206     */
1207
1208     if (!_httpResolveURI(uri, resolved, sizeof(resolved), _HTTP_RESOLVE_DEFAULT, NULL, NULL))
1209     {
1210       _cupsLangPrintf(stderr, _("%s: Unable to resolve \"%s\"."), "lpadmin", uri);
1211       return (NULL);
1212     }
1213
1214     uri = resolved;
1215   }
1216
1217   if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme), userpass, sizeof(userpass), host, sizeof(host), &port, resource, sizeof(resource)) < HTTP_URI_STATUS_OK)
1218   {
1219     _cupsLangPrintf(stderr, _("%s: Bad printer URI \"%s\"."), "lpadmin", uri);
1220     return (NULL);
1221   }
1222
1223   http = httpConnect2(host, port, NULL, AF_UNSPEC, !strcmp(scheme, "ipps") ? HTTP_ENCRYPTION_ALWAYS : HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL);
1224   if (!http)
1225   {
1226     _cupsLangPrintf(stderr, _("%s: Unable to connect to \"%s:%d\": %s"), "lpadmin", host, port, cupsLastErrorString());
1227     return (NULL);
1228   }
1229
1230  /*
1231   * Send a Get-Printer-Attributes request...
1232   */
1233
1234   request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
1235   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1236   ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]), NULL, pattrs);
1237   response = cupsDoRequest(http, request, resource);
1238
1239   if (_ppdCreateFromIPP(buffer, bufsize, response))
1240   {
1241     if (!cupsGetOption("printer-geo-location", *num_options, *options) && (attr = ippFindAttribute(response, "printer-geo-location", IPP_TAG_URI)) != NULL)
1242       *num_options = cupsAddOption("printer-geo-location", ippGetString(attr, 0, NULL), *num_options, options);
1243
1244     if (!cupsGetOption("printer-info", *num_options, *options) && (attr = ippFindAttribute(response, "printer-info", IPP_TAG_TEXT)) != NULL)
1245       *num_options = cupsAddOption("printer-info", ippGetString(attr, 0, NULL), *num_options, options);
1246
1247     if (!cupsGetOption("printer-location", *num_options, *options) && (attr = ippFindAttribute(response, "printer-location", IPP_TAG_TEXT)) != NULL)
1248       *num_options = cupsAddOption("printer-location", ippGetString(attr, 0, NULL), *num_options, options);
1249   }
1250   else
1251     _cupsLangPrintf(stderr, _("%s: Unable to create PPD file: %s"), "lpadmin", strerror(errno));
1252
1253   ippDelete(response);
1254   httpClose(http);
1255
1256   if (buffer[0])
1257     return (buffer);
1258   else
1259     return (NULL);
1260 }
1261
1262
1263 /*
1264  * 'get_printer_type()' - Determine the printer type and URI.
1265  */
1266
1267 static cups_ptype_t                     /* O - printer-type value */
1268 get_printer_type(http_t *http,          /* I - Server connection */
1269                  char   *printer,       /* I - Printer name */
1270                  char   *uri,           /* I - URI buffer */
1271                  size_t urisize)        /* I - Size of URI buffer */
1272 {
1273   ipp_t                 *request,       /* IPP request */
1274                         *response;      /* IPP response */
1275   ipp_attribute_t       *attr;          /* printer-type attribute */
1276   cups_ptype_t          type;           /* printer-type value */
1277
1278
1279  /*
1280   * Build a GET_PRINTER_ATTRIBUTES request, which requires the following
1281   * attributes:
1282   *
1283   *    attributes-charset
1284   *    attributes-natural-language
1285   *    printer-uri
1286   *    requested-attributes
1287   *    requesting-user-name
1288   */
1289
1290   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, (int)urisize, "ipp", NULL, "localhost", ippPort(), "/printers/%s", printer);
1291
1292   request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
1293   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1294                "printer-uri", NULL, uri);
1295   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1296                "requested-attributes", NULL, "printer-type");
1297   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1298                "requesting-user-name", NULL, cupsUser());
1299
1300  /*
1301   * Do the request...
1302   */
1303
1304   response = cupsDoRequest(http, request, "/");
1305   if ((attr = ippFindAttribute(response, "printer-type",
1306                                IPP_TAG_ENUM)) != NULL)
1307   {
1308     type = (cups_ptype_t)attr->values[0].integer;
1309
1310     if (type & CUPS_PRINTER_CLASS)
1311       httpAssembleURIf(HTTP_URI_CODING_ALL, uri, (int)urisize, "ipp", NULL, "localhost", ippPort(), "/classes/%s", printer);
1312   }
1313   else
1314     type = CUPS_PRINTER_LOCAL;
1315
1316   ippDelete(response);
1317
1318   return (type);
1319 }
1320
1321
1322 /*
1323  * 'set_printer_options()' - Set the printer options.
1324  */
1325
1326 static int                              /* O - 0 on success, 1 on fail */
1327 set_printer_options(
1328     http_t        *http,                /* I - Server connection */
1329     char          *printer,             /* I - Printer */
1330     int           num_options,          /* I - Number of options */
1331     cups_option_t *options,             /* I - Options */
1332     char          *file)                /* I - PPD file/interface script */
1333 {
1334   ipp_t         *request;               /* IPP Request */
1335   const char    *ppdfile;               /* PPD filename */
1336   int           ppdchanged = 0;         /* PPD changed? */
1337   ppd_file_t    *ppd;                   /* PPD file */
1338   ppd_choice_t  *choice;                /* Marked choice */
1339   char          uri[HTTP_MAX_URI],      /* URI for printer/class */
1340                 line[1024],             /* Line from PPD file */
1341                 keyword[1024],          /* Keyword from Default line */
1342                 *keyptr,                /* Pointer into keyword... */
1343                 tempfile[1024];         /* Temporary filename */
1344   cups_file_t   *in,                    /* PPD file */
1345                 *out;                   /* Temporary file */
1346   const char    *ppdname,               /* ppd-name value */
1347                 *protocol,              /* Old protocol option */
1348                 *customval,             /* Custom option value */
1349                 *boolval;               /* Boolean value */
1350   int           wrote_ipp_supplies = 0, /* Wrote cupsIPPSupplies keyword? */
1351                 wrote_snmp_supplies = 0,/* Wrote cupsSNMPSupplies keyword? */
1352                 copied_options = 0;     /* Copied options? */
1353
1354
1355   DEBUG_printf(("set_printer_options(http=%p, printer=\"%s\", num_options=%d, "
1356                 "options=%p, file=\"%s\")\n", http, printer, num_options,
1357                 options, file));
1358
1359  /*
1360   * Build a CUPS-Add-Modify-Printer or CUPS-Add-Modify-Class request,
1361   * which requires the following attributes:
1362   *
1363   *    attributes-charset
1364   *    attributes-natural-language
1365   *    printer-uri
1366   *    requesting-user-name
1367   *    other options
1368   */
1369
1370   if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS)
1371     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
1372   else
1373     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_PRINTER);
1374
1375   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1376   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser());
1377
1378  /*
1379   * Add the options...
1380   */
1381
1382   if (file)
1383     ppdfile = file;
1384   else if ((ppdname = cupsGetOption("ppd-name", num_options, options)) != NULL && strcmp(ppdname, "raw") && num_options > 1)
1385   {
1386     if ((ppdfile = cupsGetServerPPD(http, ppdname)) != NULL)
1387     {
1388      /*
1389       * Copy options array and remove ppd-name from it...
1390       */
1391
1392       cups_option_t *temp = NULL, *optr;
1393       int i, num_temp = 0;
1394       for (i = num_options, optr = options; i > 0; i --, optr ++)
1395         if (strcmp(optr->name, "ppd-name"))
1396           num_temp = cupsAddOption(optr->name, optr->value, num_temp, &temp);
1397
1398       copied_options = 1;
1399       ppdchanged     = 1;
1400       num_options    = num_temp;
1401       options        = temp;
1402     }
1403   }
1404   else if (request->request.op.operation_id == IPP_OP_CUPS_ADD_MODIFY_PRINTER)
1405     ppdfile = cupsGetPPD(printer);
1406   else
1407     ppdfile = NULL;
1408
1409   cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
1410   cupsEncodeOptions2(request, num_options, options, IPP_TAG_PRINTER);
1411
1412   if ((protocol = cupsGetOption("protocol", num_options, options)) != NULL)
1413   {
1414     if (!_cups_strcasecmp(protocol, "bcp"))
1415       ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor",
1416                    NULL, "bcp");
1417     else if (!_cups_strcasecmp(protocol, "tbcp"))
1418       ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor",
1419                    NULL, "tbcp");
1420   }
1421
1422   if (ppdfile)
1423   {
1424    /*
1425     * Set default options in the PPD file...
1426     */
1427
1428     if ((ppd = ppdOpenFile(ppdfile)) == NULL)
1429     {
1430       int               linenum;        /* Line number of error */
1431       ppd_status_t      status = ppdLastError(&linenum);
1432                                         /* Status code */
1433
1434       _cupsLangPrintf(stderr, _("lpadmin: Unable to open PPD \"%s\": %s on line %d."), ppdfile, ppdErrorString(status), linenum);
1435     }
1436
1437     ppdMarkDefaults(ppd);
1438     cupsMarkOptions(ppd, num_options, options);
1439
1440     if ((out = cupsTempFile2(tempfile, sizeof(tempfile))) == NULL)
1441     {
1442       _cupsLangPrintError(NULL, _("lpadmin: Unable to create temporary file"));
1443       ippDelete(request);
1444       if (ppdfile != file)
1445         unlink(ppdfile);
1446       if (copied_options)
1447         cupsFreeOptions(num_options, options);
1448       return (1);
1449     }
1450
1451     if ((in = cupsFileOpen(ppdfile, "r")) == NULL)
1452     {
1453       _cupsLangPrintf(stderr,
1454                       _("lpadmin: Unable to open PPD file \"%s\" - %s"),
1455                       ppdfile, strerror(errno));
1456       ippDelete(request);
1457       if (ppdfile != file)
1458         unlink(ppdfile);
1459       if (copied_options)
1460         cupsFreeOptions(num_options, options);
1461       cupsFileClose(out);
1462       unlink(tempfile);
1463       return (1);
1464     }
1465
1466     while (cupsFileGets(in, line, sizeof(line)))
1467     {
1468       if (!strncmp(line, "*cupsIPPSupplies:", 17) &&
1469           (boolval = cupsGetOption("cupsIPPSupplies", num_options,
1470                                    options)) != NULL)
1471       {
1472         wrote_ipp_supplies = 1;
1473         cupsFilePrintf(out, "*cupsIPPSupplies: %s\n",
1474                        (!_cups_strcasecmp(boolval, "true") ||
1475                         !_cups_strcasecmp(boolval, "yes") ||
1476                         !_cups_strcasecmp(boolval, "on")) ? "True" : "False");
1477       }
1478       else if (!strncmp(line, "*cupsSNMPSupplies:", 18) &&
1479                (boolval = cupsGetOption("cupsSNMPSupplies", num_options,
1480                                         options)) != NULL)
1481       {
1482         wrote_snmp_supplies = 1;
1483         cupsFilePrintf(out, "*cupsSNMPSupplies: %s\n",
1484                        (!_cups_strcasecmp(boolval, "true") ||
1485                         !_cups_strcasecmp(boolval, "yes") ||
1486                         !_cups_strcasecmp(boolval, "on")) ? "True" : "False");
1487       }
1488       else if (strncmp(line, "*Default", 8))
1489         cupsFilePrintf(out, "%s\n", line);
1490       else
1491       {
1492        /*
1493         * Get default option name...
1494         */
1495
1496         strlcpy(keyword, line + 8, sizeof(keyword));
1497
1498         for (keyptr = keyword; *keyptr; keyptr ++)
1499           if (*keyptr == ':' || isspace(*keyptr & 255))
1500             break;
1501
1502         *keyptr++ = '\0';
1503         while (isspace(*keyptr & 255))
1504           keyptr ++;
1505
1506         if (!strcmp(keyword, "PageRegion") ||
1507             !strcmp(keyword, "PageSize") ||
1508             !strcmp(keyword, "PaperDimension") ||
1509             !strcmp(keyword, "ImageableArea"))
1510         {
1511           if ((choice = ppdFindMarkedChoice(ppd, "PageSize")) == NULL)
1512             choice = ppdFindMarkedChoice(ppd, "PageRegion");
1513         }
1514         else
1515           choice = ppdFindMarkedChoice(ppd, keyword);
1516
1517         if (choice && strcmp(choice->choice, keyptr))
1518         {
1519           if (strcmp(choice->choice, "Custom"))
1520           {
1521             cupsFilePrintf(out, "*Default%s: %s\n", keyword, choice->choice);
1522             ppdchanged = 1;
1523           }
1524           else if ((customval = cupsGetOption(keyword, num_options,
1525                                               options)) != NULL)
1526           {
1527             cupsFilePrintf(out, "*Default%s: %s\n", keyword, customval);
1528             ppdchanged = 1;
1529           }
1530           else
1531             cupsFilePrintf(out, "%s\n", line);
1532         }
1533         else
1534           cupsFilePrintf(out, "%s\n", line);
1535       }
1536     }
1537
1538     if (!wrote_ipp_supplies &&
1539         (boolval = cupsGetOption("cupsIPPSupplies", num_options,
1540                                  options)) != NULL)
1541     {
1542       cupsFilePrintf(out, "*cupsIPPSupplies: %s\n",
1543                      (!_cups_strcasecmp(boolval, "true") ||
1544                       !_cups_strcasecmp(boolval, "yes") ||
1545                       !_cups_strcasecmp(boolval, "on")) ? "True" : "False");
1546     }
1547
1548     if (!wrote_snmp_supplies &&
1549         (boolval = cupsGetOption("cupsSNMPSupplies", num_options,
1550                                  options)) != NULL)
1551     {
1552       cupsFilePrintf(out, "*cupsSNMPSupplies: %s\n",
1553                      (!_cups_strcasecmp(boolval, "true") ||
1554                       !_cups_strcasecmp(boolval, "yes") ||
1555                       !_cups_strcasecmp(boolval, "on")) ? "True" : "False");
1556     }
1557
1558     cupsFileClose(in);
1559     cupsFileClose(out);
1560     ppdClose(ppd);
1561
1562    /*
1563     * Do the request...
1564     */
1565
1566     ippDelete(cupsDoFileRequest(http, request, "/admin/",
1567                                 ppdchanged ? tempfile : file));
1568
1569    /*
1570     * Clean up temp files... (TODO: catch signals in case we CTRL-C during
1571     * lpadmin)
1572     */
1573
1574     if (ppdfile != file)
1575       unlink(ppdfile);
1576     unlink(tempfile);
1577   }
1578   else
1579   {
1580    /*
1581     * No PPD file - just set the options...
1582     */
1583
1584     ippDelete(cupsDoRequest(http, request, "/admin/"));
1585   }
1586
1587   if (copied_options)
1588     cupsFreeOptions(num_options, options);
1589
1590  /*
1591   * Check the response...
1592   */
1593
1594   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
1595   {
1596     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
1597
1598     return (1);
1599   }
1600   else
1601     return (0);
1602 }
1603
1604
1605 /*
1606  * 'validate_name()' - Make sure the printer name only contains valid chars.
1607  */
1608
1609 static int                              /* O - 0 if name is no good, 1 if name is good */
1610 validate_name(const char *name)         /* I - Name to check */
1611 {
1612   const char    *ptr;                   /* Pointer into name */
1613
1614
1615  /*
1616   * Scan the whole name...
1617   */
1618
1619   for (ptr = name; *ptr; ptr ++)
1620     if (*ptr == '@')
1621       break;
1622     else if ((*ptr >= 0 && *ptr <= ' ') || *ptr == 127 || *ptr == '/' || *ptr == '\\' || *ptr == '?' || *ptr == '\'' || *ptr == '\"' || *ptr == '#')
1623       return (0);
1624
1625  /*
1626   * All the characters are good; validate the length, too...
1627   */
1628
1629   return ((ptr - name) < 128);
1630 }