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   else if (ppd_name || file)
 626   {
 627     _cupsLangPuts(stderr, _("lpadmin: Printer drivers are deprecated and will stop working in a future version of CUPS."));
 628   }
 629
 630   if (num_options || file)
 631   {
 632     if (printer == NULL)
 633     {
 634       _cupsLangPuts(stderr,
 635                     _("lpadmin: Unable to set the printer options:\n"
 636                       "         You must specify a printer name first."));
 637       return (1);
 638     }
 639
 640     if (!http)
 641     {
 642       http = httpConnect2(cupsServer(), ippPort(), NULL, AF_UNSPEC,
 643                           cupsEncryption(), 1, 30000, NULL);
 644
 645       if (http == NULL) {
 646         _cupsLangPrintf(stderr, _("lpadmin: Unable to connect to server: %s"),
 647                         strerror(errno));
 648         return (1);
 649       }
 650     }
 651
 652     if (set_printer_options(http, printer, num_options, options, file))
 653       return (1);
 654   }
 655
 656   if (evefile[0])
 657     unlink(evefile);
 658
 659   if (printer == NULL)
 660   {
 661     _cupsLangPuts(stdout,
 662                   _("Usage:\n"
 663                     "\n"
 664                     "    lpadmin [-h server] -d destination\n"
 665                     "    lpadmin [-h server] -x destination\n"
 666                     "    lpadmin [-h server] -p printer [-c add-class] "
 667                     "[-i interface] [-m model]\n"
 668                     "                       [-r remove-class] [-v device] "
 669                     "[-D description]\n"
 670                     "                       [-P ppd-file] [-o name=value]\n"
 671                     "                       [-u allow:user,user] "
 672                     "[-u deny:user,user]"));
 673   }
 674
 675   if (http)
 676     httpClose(http);
 677
 678   return (0);
 679 }
 680
 681
 682 /*
 683  * 'add_printer_to_class()' - Add a printer to a class.
 684  */
 685
 686 static int                              /* O - 0 on success, 1 on fail */
 687 add_printer_to_class(http_t *http,      /* I - Server connection */
 688                      char   *printer,   /* I - Printer to add */
 689                      char   *pclass)    /* I - Class to add to */
 690 {
 691   int           i;                      /* Looping var */
 692   ipp_t         *request,               /* IPP Request */
 693                 *response;              /* IPP Response */
 694   ipp_attribute_t *attr,                /* Current attribute */
 695                 *members;               /* Members in class */
 696   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
 697
 698
 699   DEBUG_printf(("add_printer_to_class(%p, \"%s\", \"%s\")\n", http,
 700                 printer, pclass));
 701
 702  /*
 703   * Build an IPP_OP_GET_PRINTER_ATTRIBUTES request, which requires the following
 704   * attributes:
 705   *
 706   *    attributes-charset
 707   *    attributes-natural-language
 708   *    printer-uri
 709   *    requesting-user-name
 710   */
 711
 712   request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
 713
 714   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 715                    "localhost", 0, "/classes/%s", pclass);
 716   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 717                "printer-uri", NULL, uri);
 718   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 719                NULL, cupsUser());
 720
 721  /*
 722   * Do the request and get back a response...
 723   */
 724
 725   response = cupsDoRequest(http, request, "/");
 726
 727  /*
 728   * Build a CUPS-Add-Modify-Class request, which requires the following
 729   * attributes:
 730   *
 731   *    attributes-charset
 732   *    attributes-natural-language
 733   *    printer-uri
 734   *    requesting-user-name
 735   *    member-uris
 736   */
 737
 738   request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
 739
 740   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 741                "printer-uri", NULL, uri);
 742   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 743                NULL, cupsUser());
 744
 745  /*
 746   * See if the printer is already in the class...
 747   */
 748
 749   if (response != NULL &&
 750       (members = ippFindAttribute(response, "member-names",
 751                                   IPP_TAG_NAME)) != NULL)
 752     for (i = 0; i < members->num_values; i ++)
 753       if (_cups_strcasecmp(printer, members->values[i].string.text) == 0)
 754       {
 755         _cupsLangPrintf(stderr,
 756                         _("lpadmin: Printer %s is already a member of class "
 757                           "%s."), printer, pclass);
 758         ippDelete(request);
 759         ippDelete(response);
 760         return (0);
 761       }
 762
 763  /*
 764   * OK, the printer isn't part of the class, so add it...
 765   */
 766
 767   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 768                    "localhost", 0, "/printers/%s", printer);
 769
 770   if (response != NULL &&
 771       (members = ippFindAttribute(response, "member-uris",
 772                                   IPP_TAG_URI)) != NULL)
 773   {
 774    /*
 775     * Add the printer to the existing list...
 776     */
 777
 778     attr = ippAddStrings(request, IPP_TAG_PRINTER, IPP_TAG_URI,
 779                          "member-uris", members->num_values + 1, NULL, NULL);
 780     for (i = 0; i < members->num_values; i ++)
 781       attr->values[i].string.text =
 782           _cupsStrAlloc(members->values[i].string.text);
 783
 784     attr->values[i].string.text = _cupsStrAlloc(uri);
 785   }
 786   else
 787     ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_URI, "member-uris", NULL,
 788                  uri);
 789
 790  /*
 791   * Then send the request...
 792   */
 793
 794   ippDelete(response);
 795
 796   ippDelete(cupsDoRequest(http, request, "/admin/"));
 797   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
 798   {
 799     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
 800
 801     return (1);
 802   }
 803   else
 804     return (0);
 805 }
 806
 807
 808 /*
 809  * 'default_printer()' - Set the default printing destination.
 810  */
 811
 812 static int                              /* O - 0 on success, 1 on fail */
 813 default_printer(http_t *http,           /* I - Server connection */
 814                 char   *printer)        /* I - Printer name */
 815 {
 816   ipp_t         *request;               /* IPP Request */
 817   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
 818
 819
 820   DEBUG_printf(("default_printer(%p, \"%s\")\n", http, printer));
 821
 822  /*
 823   * Build a CUPS-Set-Default request, which requires the following
 824   * attributes:
 825   *
 826   *    attributes-charset
 827   *    attributes-natural-language
 828   *    printer-uri
 829   *    requesting-user-name
 830   */
 831
 832   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 833                    "localhost", 0, "/printers/%s", printer);
 834
 835   request = ippNewRequest(IPP_OP_CUPS_SET_DEFAULT);
 836
 837   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 838                "printer-uri", NULL, uri);
 839   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 840                NULL, cupsUser());
 841
 842  /*
 843   * Do the request and get back a response...
 844   */
 845
 846   ippDelete(cupsDoRequest(http, request, "/admin/"));
 847
 848   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
 849   {
 850     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
 851
 852     return (1);
 853   }
 854   else
 855     return (0);
 856 }
 857
 858
 859 /*
 860  * 'delete_printer()' - Delete a printer from the system...
 861  */
 862
 863 static int                              /* O - 0 on success, 1 on fail */
 864 delete_printer(http_t *http,            /* I - Server connection */
 865                char   *printer)         /* I - Printer to delete */
 866 {
 867   ipp_t         *request;               /* IPP Request */
 868   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
 869
 870
 871   DEBUG_printf(("delete_printer(%p, \"%s\")\n", http, printer));
 872
 873  /*
 874   * Build a CUPS-Delete-Printer request, which requires the following
 875   * attributes:
 876   *
 877   *    attributes-charset
 878   *    attributes-natural-language
 879   *    printer-uri
 880   *    requesting-user-name
 881   */
 882
 883   request = ippNewRequest(IPP_OP_CUPS_DELETE_PRINTER);
 884
 885   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 886                    "localhost", 0, "/printers/%s", printer);
 887   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 888                "printer-uri", NULL, uri);
 889   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 890                NULL, cupsUser());
 891
 892  /*
 893   * Do the request and get back a response...
 894   */
 895
 896   ippDelete(cupsDoRequest(http, request, "/admin/"));
 897
 898   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
 899   {
 900     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
 901
 902     return (1);
 903   }
 904   else
 905     return (0);
 906 }
 907
 908
 909 /*
 910  * 'delete_printer_from_class()' - Delete a printer from a class.
 911  */
 912
 913 static int                              /* O - 0 on success, 1 on fail */
 914 delete_printer_from_class(
 915     http_t *http,                       /* I - Server connection */
 916     char   *printer,                    /* I - Printer to remove */
 917     char   *pclass)                     /* I - Class to remove from */
 918 {
 919   int           i, j, k;                /* Looping vars */
 920   ipp_t         *request,               /* IPP Request */
 921                 *response;              /* IPP Response */
 922   ipp_attribute_t *attr,                /* Current attribute */
 923                 *members;               /* Members in class */
 924   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
 925
 926
 927   DEBUG_printf(("delete_printer_from_class(%p, \"%s\", \"%s\")\n", http,
 928                 printer, pclass));
 929
 930  /*
 931   * Build an IPP_OP_GET_PRINTER_ATTRIBUTES request, which requires the following
 932   * attributes:
 933   *
 934   *    attributes-charset
 935   *    attributes-natural-language
 936   *    printer-uri
 937   *    requesting-user-name
 938   */
 939
 940   request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
 941
 942   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 943                    "localhost", 0, "/classes/%s", pclass);
 944   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 945                "printer-uri", NULL, uri);
 946   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 947                NULL, cupsUser());
 948
 949  /*
 950   * Do the request and get back a response...
 951   */
 952
 953   if ((response = cupsDoRequest(http, request, "/classes/")) == NULL ||
 954       response->request.status.status_code == IPP_STATUS_ERROR_NOT_FOUND)
 955   {
 956     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
 957
 958     ippDelete(response);
 959
 960     return (1);
 961   }
 962
 963  /*
 964   * See if the printer is already in the class...
 965   */
 966
 967   if ((members = ippFindAttribute(response, "member-names", IPP_TAG_NAME)) == NULL)
 968   {
 969     _cupsLangPuts(stderr, _("lpadmin: No member names were seen."));
 970
 971     ippDelete(response);
 972
 973     return (1);
 974   }
 975
 976   for (i = 0; i < members->num_values; i ++)
 977     if (!_cups_strcasecmp(printer, members->values[i].string.text))
 978       break;
 979
 980   if (i >= members->num_values)
 981   {
 982     _cupsLangPrintf(stderr,
 983                     _("lpadmin: Printer %s is not a member of class %s."),
 984                     printer, pclass);
 985
 986     ippDelete(response);
 987
 988     return (1);
 989   }
 990
 991   if (members->num_values == 1)
 992   {
 993    /*
 994     * Build a CUPS-Delete-Class request, which requires the following
 995     * attributes:
 996     *
 997     *    attributes-charset
 998     *    attributes-natural-language
 999     *    printer-uri
1000     *    requesting-user-name
1001     */
1002
1003     request = ippNewRequest(IPP_OP_CUPS_DELETE_CLASS);
1004
1005     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1006                  "printer-uri", NULL, uri);
1007     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1008                  "requesting-user-name", NULL, cupsUser());
1009   }
1010   else
1011   {
1012    /*
1013     * Build a IPP_OP_CUPS_ADD_MODIFY_CLASS request, which requires the following
1014     * attributes:
1015     *
1016     *    attributes-charset
1017     *    attributes-natural-language
1018     *    printer-uri
1019     *    requesting-user-name
1020     *    member-uris
1021     */
1022
1023     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
1024
1025     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1026                  "printer-uri", NULL, uri);
1027     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1028                  "requesting-user-name", NULL, cupsUser());
1029
1030    /*
1031     * Delete the printer from the class...
1032     */
1033
1034     members = ippFindAttribute(response, "member-uris", IPP_TAG_URI);
1035     attr = ippAddStrings(request, IPP_TAG_PRINTER, IPP_TAG_URI,
1036                          "member-uris", members->num_values - 1, NULL, NULL);
1037
1038     for (j = 0, k = 0; j < members->num_values; j ++)
1039       if (j != i)
1040         attr->values[k ++].string.text =
1041             _cupsStrAlloc(members->values[j].string.text);
1042   }
1043
1044  /*
1045   * Then send the request...
1046   */
1047
1048   ippDelete(response);
1049
1050   ippDelete(cupsDoRequest(http, request, "/admin/"));
1051
1052   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
1053   {
1054     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
1055
1056     return (1);
1057   }
1058   else
1059     return (0);
1060 }
1061
1062
1063 /*
1064  * 'delete_printer_option()' - Delete a printer option.
1065  */
1066
1067 static int                              /* O - 0 on success, 1 on fail */
1068 delete_printer_option(http_t *http,     /* I - Server connection */
1069                       char   *printer,  /* I - Printer */
1070                       char   *option)   /* I - Option to delete */
1071 {
1072   ipp_t         *request;               /* IPP request */
1073   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
1074
1075
1076  /*
1077   * Build a IPP_OP_CUPS_ADD_MODIFY_PRINTER or IPP_OP_CUPS_ADD_MODIFY_CLASS request, which
1078   * requires the following attributes:
1079   *
1080   *    attributes-charset
1081   *    attributes-natural-language
1082   *    printer-uri
1083   *    requesting-user-name
1084   *    option with deleteAttr tag
1085   */
1086
1087   if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS)
1088     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
1089   else
1090     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_PRINTER);
1091
1092   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1093                "printer-uri", NULL, uri);
1094   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1095                "requesting-user-name", NULL, cupsUser());
1096   ippAddInteger(request, IPP_TAG_PRINTER, IPP_TAG_DELETEATTR, option, 0);
1097
1098  /*
1099   * Do the request and get back a response...
1100   */
1101
1102   ippDelete(cupsDoRequest(http, request, "/admin/"));
1103
1104   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
1105   {
1106     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
1107
1108     return (1);
1109   }
1110   else
1111     return (0);
1112 }
1113
1114
1115 /*
1116  * 'enable_printer()' - Enable a printer...
1117  */
1118
1119 static int                              /* O - 0 on success, 1 on fail */
1120 enable_printer(http_t *http,            /* I - Server connection */
1121                char   *printer)         /* I - Printer to enable */
1122 {
1123   ipp_t         *request;               /* IPP Request */
1124   char          uri[HTTP_MAX_URI];      /* URI for printer/class */
1125
1126
1127   DEBUG_printf(("enable_printer(%p, \"%s\")\n", http, printer));
1128
1129  /*
1130   * Build a IPP_OP_CUPS_ADD_MODIFY_PRINTER or IPP_OP_CUPS_ADD_MODIFY_CLASS request, which
1131   * require the following attributes:
1132   *
1133   *    attributes-charset
1134   *    attributes-natural-language
1135   *    printer-uri
1136   *    requesting-user-name
1137   *    printer-state
1138   *    printer-is-accepting-jobs
1139   */
1140
1141   if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS)
1142     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
1143   else
1144     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_PRINTER);
1145
1146   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1147                "printer-uri", NULL, uri);
1148   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1149                "requesting-user-name", NULL, cupsUser());
1150   ippAddInteger(request, IPP_TAG_PRINTER, IPP_TAG_ENUM, "printer-state",
1151                 IPP_PSTATE_IDLE);
1152   ippAddBoolean(request, IPP_TAG_PRINTER, "printer-is-accepting-jobs", 1);
1153
1154  /*
1155   * Do the request and get back a response...
1156   */
1157
1158   ippDelete(cupsDoRequest(http, request, "/admin/"));
1159
1160   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
1161   {
1162     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
1163
1164     return (1);
1165   }
1166   else
1167     return (0);
1168 }
1169
1170
1171 /*
1172  * 'get_printer_ppd()' - Get an IPP Everywhere PPD file for the given URI.
1173  */
1174
1175 static char *                           /* O  - Filename or NULL */
1176 get_printer_ppd(
1177     const char    *uri,                 /* I  - Printer URI */
1178     char          *buffer,              /* I  - Filename buffer */
1179     size_t        bufsize,              /* I  - Size of filename buffer */
1180     int           *num_options,         /* IO - Number of options */
1181     cups_option_t **options)            /* IO - Options */
1182 {
1183   http_t        *http;                  /* Connection to printer */
1184   ipp_t         *request,               /* Get-Printer-Attributes request */
1185                 *response;              /* Get-Printer-Attributes response */
1186   ipp_attribute_t *attr;                /* Attribute from response */
1187   char          resolved[1024],         /* Resolved URI */
1188                 scheme[32],             /* URI scheme */
1189                 userpass[256],          /* Username:password */
1190                 host[256],              /* Hostname */
1191                 resource[256];          /* Resource path */
1192   int           port;                   /* Port number */
1193   static const char * const pattrs[] =  /* Attributes to use */
1194   {
1195     "job-template",
1196     "printer-defaults",
1197     "printer-description",
1198     "media-col-database"
1199   };
1200
1201
1202  /*
1203   * Connect to the printer...
1204   */
1205
1206   if (strstr(uri, "._tcp"))
1207   {
1208    /*
1209     * Resolve URI...
1210     */
1211
1212     if (!_httpResolveURI(uri, resolved, sizeof(resolved), _HTTP_RESOLVE_DEFAULT, NULL, NULL))
1213     {
1214       _cupsLangPrintf(stderr, _("%s: Unable to resolve \"%s\"."), "lpadmin", uri);
1215       return (NULL);
1216     }
1217
1218     uri = resolved;
1219   }
1220
1221   if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme), userpass, sizeof(userpass), host, sizeof(host), &port, resource, sizeof(resource)) < HTTP_URI_STATUS_OK)
1222   {
1223     _cupsLangPrintf(stderr, _("%s: Bad printer URI \"%s\"."), "lpadmin", uri);
1224     return (NULL);
1225   }
1226
1227   http = httpConnect2(host, port, NULL, AF_UNSPEC, !strcmp(scheme, "ipps") ? HTTP_ENCRYPTION_ALWAYS : HTTP_ENCRYPTION_IF_REQUESTED, 1, 30000, NULL);
1228   if (!http)
1229   {
1230     _cupsLangPrintf(stderr, _("%s: Unable to connect to \"%s:%d\": %s"), "lpadmin", host, port, cupsLastErrorString());
1231     return (NULL);
1232   }
1233
1234  /*
1235   * Send a Get-Printer-Attributes request...
1236   */
1237
1238   request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
1239   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1240   ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]), NULL, pattrs);
1241   response = cupsDoRequest(http, request, resource);
1242
1243   if (_ppdCreateFromIPP(buffer, bufsize, response))
1244   {
1245     if (!cupsGetOption("printer-geo-location", *num_options, *options) && (attr = ippFindAttribute(response, "printer-geo-location", IPP_TAG_URI)) != NULL)
1246       *num_options = cupsAddOption("printer-geo-location", ippGetString(attr, 0, NULL), *num_options, options);
1247
1248     if (!cupsGetOption("printer-info", *num_options, *options) && (attr = ippFindAttribute(response, "printer-info", IPP_TAG_TEXT)) != NULL)
1249       *num_options = cupsAddOption("printer-info", ippGetString(attr, 0, NULL), *num_options, options);
1250
1251     if (!cupsGetOption("printer-location", *num_options, *options) && (attr = ippFindAttribute(response, "printer-location", IPP_TAG_TEXT)) != NULL)
1252       *num_options = cupsAddOption("printer-location", ippGetString(attr, 0, NULL), *num_options, options);
1253   }
1254   else
1255     _cupsLangPrintf(stderr, _("%s: Unable to create PPD file: %s"), "lpadmin", strerror(errno));
1256
1257   ippDelete(response);
1258   httpClose(http);
1259
1260   if (buffer[0])
1261     return (buffer);
1262   else
1263     return (NULL);
1264 }
1265
1266
1267 /*
1268  * 'get_printer_type()' - Determine the printer type and URI.
1269  */
1270
1271 static cups_ptype_t                     /* O - printer-type value */
1272 get_printer_type(http_t *http,          /* I - Server connection */
1273                  char   *printer,       /* I - Printer name */
1274                  char   *uri,           /* I - URI buffer */
1275                  size_t urisize)        /* I - Size of URI buffer */
1276 {
1277   ipp_t                 *request,       /* IPP request */
1278                         *response;      /* IPP response */
1279   ipp_attribute_t       *attr;          /* printer-type attribute */
1280   cups_ptype_t          type;           /* printer-type value */
1281
1282
1283  /*
1284   * Build a GET_PRINTER_ATTRIBUTES request, which requires the following
1285   * attributes:
1286   *
1287   *    attributes-charset
1288   *    attributes-natural-language
1289   *    printer-uri
1290   *    requested-attributes
1291   *    requesting-user-name
1292   */
1293
1294   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, (int)urisize, "ipp", NULL, "localhost", ippPort(), "/printers/%s", printer);
1295
1296   request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
1297   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1298                "printer-uri", NULL, uri);
1299   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1300                "requested-attributes", NULL, "printer-type");
1301   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1302                "requesting-user-name", NULL, cupsUser());
1303
1304  /*
1305   * Do the request...
1306   */
1307
1308   response = cupsDoRequest(http, request, "/");
1309   if ((attr = ippFindAttribute(response, "printer-type",
1310                                IPP_TAG_ENUM)) != NULL)
1311   {
1312     type = (cups_ptype_t)attr->values[0].integer;
1313
1314     if (type & CUPS_PRINTER_CLASS)
1315       httpAssembleURIf(HTTP_URI_CODING_ALL, uri, (int)urisize, "ipp", NULL, "localhost", ippPort(), "/classes/%s", printer);
1316   }
1317   else
1318     type = CUPS_PRINTER_LOCAL;
1319
1320   ippDelete(response);
1321
1322   return (type);
1323 }
1324
1325
1326 /*
1327  * 'set_printer_options()' - Set the printer options.
1328  */
1329
1330 static int                              /* O - 0 on success, 1 on fail */
1331 set_printer_options(
1332     http_t        *http,                /* I - Server connection */
1333     char          *printer,             /* I - Printer */
1334     int           num_options,          /* I - Number of options */
1335     cups_option_t *options,             /* I - Options */
1336     char          *file)                /* I - PPD file/interface script */
1337 {
1338   ipp_t         *request;               /* IPP Request */
1339   const char    *ppdfile;               /* PPD filename */
1340   int           ppdchanged = 0;         /* PPD changed? */
1341   ppd_file_t    *ppd;                   /* PPD file */
1342   ppd_choice_t  *choice;                /* Marked choice */
1343   char          uri[HTTP_MAX_URI],      /* URI for printer/class */
1344                 line[1024],             /* Line from PPD file */
1345                 keyword[1024],          /* Keyword from Default line */
1346                 *keyptr,                /* Pointer into keyword... */
1347                 tempfile[1024];         /* Temporary filename */
1348   cups_file_t   *in,                    /* PPD file */
1349                 *out;                   /* Temporary file */
1350   const char    *ppdname,               /* ppd-name value */
1351                 *protocol,              /* Old protocol option */
1352                 *customval,             /* Custom option value */
1353                 *boolval;               /* Boolean value */
1354   int           wrote_ipp_supplies = 0, /* Wrote cupsIPPSupplies keyword? */
1355                 wrote_snmp_supplies = 0,/* Wrote cupsSNMPSupplies keyword? */
1356                 copied_options = 0;     /* Copied options? */
1357
1358
1359   DEBUG_printf(("set_printer_options(http=%p, printer=\"%s\", num_options=%d, "
1360                 "options=%p, file=\"%s\")\n", http, printer, num_options,
1361                 options, file));
1362
1363  /*
1364   * Build a CUPS-Add-Modify-Printer or CUPS-Add-Modify-Class request,
1365   * which requires the following attributes:
1366   *
1367   *    attributes-charset
1368   *    attributes-natural-language
1369   *    printer-uri
1370   *    requesting-user-name
1371   *    other options
1372   */
1373
1374   if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS)
1375     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_CLASS);
1376   else
1377     request = ippNewRequest(IPP_OP_CUPS_ADD_MODIFY_PRINTER);
1378
1379   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1380   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser());
1381
1382  /*
1383   * Add the options...
1384   */
1385
1386   if (file)
1387     ppdfile = file;
1388   else if ((ppdname = cupsGetOption("ppd-name", num_options, options)) != NULL && strcmp(ppdname, "raw") && num_options > 1)
1389   {
1390     if ((ppdfile = cupsGetServerPPD(http, ppdname)) != NULL)
1391     {
1392      /*
1393       * Copy options array and remove ppd-name from it...
1394       */
1395
1396       cups_option_t *temp = NULL, *optr;
1397       int i, num_temp = 0;
1398       for (i = num_options, optr = options; i > 0; i --, optr ++)
1399         if (strcmp(optr->name, "ppd-name"))
1400           num_temp = cupsAddOption(optr->name, optr->value, num_temp, &temp);
1401
1402       copied_options = 1;
1403       ppdchanged     = 1;
1404       num_options    = num_temp;
1405       options        = temp;
1406     }
1407   }
1408   else if (request->request.op.operation_id == IPP_OP_CUPS_ADD_MODIFY_PRINTER)
1409     ppdfile = cupsGetPPD(printer);
1410   else
1411     ppdfile = NULL;
1412
1413   cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
1414   cupsEncodeOptions2(request, num_options, options, IPP_TAG_PRINTER);
1415
1416   if ((protocol = cupsGetOption("protocol", num_options, options)) != NULL)
1417   {
1418     if (!_cups_strcasecmp(protocol, "bcp"))
1419       ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor",
1420                    NULL, "bcp");
1421     else if (!_cups_strcasecmp(protocol, "tbcp"))
1422       ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor",
1423                    NULL, "tbcp");
1424   }
1425
1426   if (ppdfile)
1427   {
1428    /*
1429     * Set default options in the PPD file...
1430     */
1431
1432     if ((ppd = ppdOpenFile(ppdfile)) == NULL)
1433     {
1434       int               linenum;        /* Line number of error */
1435       ppd_status_t      status = ppdLastError(&linenum);
1436                                         /* Status code */
1437
1438       _cupsLangPrintf(stderr, _("lpadmin: Unable to open PPD \"%s\": %s on line %d."), ppdfile, ppdErrorString(status), linenum);
1439     }
1440
1441     ppdMarkDefaults(ppd);
1442     cupsMarkOptions(ppd, num_options, options);
1443
1444     if ((out = cupsTempFile2(tempfile, sizeof(tempfile))) == NULL)
1445     {
1446       _cupsLangPrintError(NULL, _("lpadmin: Unable to create temporary file"));
1447       ippDelete(request);
1448       if (ppdfile != file)
1449         unlink(ppdfile);
1450       if (copied_options)
1451         cupsFreeOptions(num_options, options);
1452       return (1);
1453     }
1454
1455     if ((in = cupsFileOpen(ppdfile, "r")) == NULL)
1456     {
1457       _cupsLangPrintf(stderr,
1458                       _("lpadmin: Unable to open PPD file \"%s\" - %s"),
1459                       ppdfile, strerror(errno));
1460       ippDelete(request);
1461       if (ppdfile != file)
1462         unlink(ppdfile);
1463       if (copied_options)
1464         cupsFreeOptions(num_options, options);
1465       cupsFileClose(out);
1466       unlink(tempfile);
1467       return (1);
1468     }
1469
1470     while (cupsFileGets(in, line, sizeof(line)))
1471     {
1472       if (!strncmp(line, "*cupsIPPSupplies:", 17) &&
1473           (boolval = cupsGetOption("cupsIPPSupplies", num_options,
1474                                    options)) != NULL)
1475       {
1476         wrote_ipp_supplies = 1;
1477         cupsFilePrintf(out, "*cupsIPPSupplies: %s\n",
1478                        (!_cups_strcasecmp(boolval, "true") ||
1479                         !_cups_strcasecmp(boolval, "yes") ||
1480                         !_cups_strcasecmp(boolval, "on")) ? "True" : "False");
1481       }
1482       else if (!strncmp(line, "*cupsSNMPSupplies:", 18) &&
1483                (boolval = cupsGetOption("cupsSNMPSupplies", num_options,
1484                                         options)) != NULL)
1485       {
1486         wrote_snmp_supplies = 1;
1487         cupsFilePrintf(out, "*cupsSNMPSupplies: %s\n",
1488                        (!_cups_strcasecmp(boolval, "true") ||
1489                         !_cups_strcasecmp(boolval, "yes") ||
1490                         !_cups_strcasecmp(boolval, "on")) ? "True" : "False");
1491       }
1492       else if (strncmp(line, "*Default", 8))
1493         cupsFilePrintf(out, "%s\n", line);
1494       else
1495       {
1496        /*
1497         * Get default option name...
1498         */
1499
1500         strlcpy(keyword, line + 8, sizeof(keyword));
1501
1502         for (keyptr = keyword; *keyptr; keyptr ++)
1503           if (*keyptr == ':' || isspace(*keyptr & 255))
1504             break;
1505
1506         *keyptr++ = '\0';
1507         while (isspace(*keyptr & 255))
1508           keyptr ++;
1509
1510         if (!strcmp(keyword, "PageRegion") ||
1511             !strcmp(keyword, "PageSize") ||
1512             !strcmp(keyword, "PaperDimension") ||
1513             !strcmp(keyword, "ImageableArea"))
1514         {
1515           if ((choice = ppdFindMarkedChoice(ppd, "PageSize")) == NULL)
1516             choice = ppdFindMarkedChoice(ppd, "PageRegion");
1517         }
1518         else
1519           choice = ppdFindMarkedChoice(ppd, keyword);
1520
1521         if (choice && strcmp(choice->choice, keyptr))
1522         {
1523           if (strcmp(choice->choice, "Custom"))
1524           {
1525             cupsFilePrintf(out, "*Default%s: %s\n", keyword, choice->choice);
1526             ppdchanged = 1;
1527           }
1528           else if ((customval = cupsGetOption(keyword, num_options,
1529                                               options)) != NULL)
1530           {
1531             cupsFilePrintf(out, "*Default%s: %s\n", keyword, customval);
1532             ppdchanged = 1;
1533           }
1534           else
1535             cupsFilePrintf(out, "%s\n", line);
1536         }
1537         else
1538           cupsFilePrintf(out, "%s\n", line);
1539       }
1540     }
1541
1542     if (!wrote_ipp_supplies &&
1543         (boolval = cupsGetOption("cupsIPPSupplies", num_options,
1544                                  options)) != NULL)
1545     {
1546       cupsFilePrintf(out, "*cupsIPPSupplies: %s\n",
1547                      (!_cups_strcasecmp(boolval, "true") ||
1548                       !_cups_strcasecmp(boolval, "yes") ||
1549                       !_cups_strcasecmp(boolval, "on")) ? "True" : "False");
1550     }
1551
1552     if (!wrote_snmp_supplies &&
1553         (boolval = cupsGetOption("cupsSNMPSupplies", num_options,
1554                                  options)) != NULL)
1555     {
1556       cupsFilePrintf(out, "*cupsSNMPSupplies: %s\n",
1557                      (!_cups_strcasecmp(boolval, "true") ||
1558                       !_cups_strcasecmp(boolval, "yes") ||
1559                       !_cups_strcasecmp(boolval, "on")) ? "True" : "False");
1560     }
1561
1562     cupsFileClose(in);
1563     cupsFileClose(out);
1564     ppdClose(ppd);
1565
1566    /*
1567     * Do the request...
1568     */
1569
1570     ippDelete(cupsDoFileRequest(http, request, "/admin/",
1571                                 ppdchanged ? tempfile : file));
1572
1573    /*
1574     * Clean up temp files... (TODO: catch signals in case we CTRL-C during
1575     * lpadmin)
1576     */
1577
1578     if (ppdfile != file)
1579       unlink(ppdfile);
1580     unlink(tempfile);
1581   }
1582   else
1583   {
1584    /*
1585     * No PPD file - just set the options...
1586     */
1587
1588     ippDelete(cupsDoRequest(http, request, "/admin/"));
1589   }
1590
1591   if (copied_options)
1592     cupsFreeOptions(num_options, options);
1593
1594  /*
1595   * Check the response...
1596   */
1597
1598   if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
1599   {
1600     _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString());
1601
1602     return (1);
1603   }
1604   else
1605     return (0);
1606 }
1607
1608
1609 /*
1610  * 'validate_name()' - Make sure the printer name only contains valid chars.
1611  */
1612
1613 static int                              /* O - 0 if name is no good, 1 if name is good */
1614 validate_name(const char *name)         /* I - Name to check */
1615 {
1616   const char    *ptr;                   /* Pointer into name */
1617
1618
1619  /*
1620   * Scan the whole name...
1621   */
1622
1623   for (ptr = name; *ptr; ptr ++)
1624     if (*ptr == '@')
1625       break;
1626     else if ((*ptr >= 0 && *ptr <= ' ') || *ptr == 127 || *ptr == '/' || *ptr == '\\' || *ptr == '?' || *ptr == '\'' || *ptr == '\"' || *ptr == '#')
1627       return (0);
1628
1629  /*
1630   * All the characters are good; validate the length, too...
1631   */
1632
1633   return ((ptr - name) < 128);
1634 }