berkeley/lpq.c

   1 /*
   2  * "lpq" command for CUPS.
   3  *
   4  * Copyright 2007-2016 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 #include <cups/cups-private.h>
  15
  16
  17 /*
  18  * Local functions...
  19  */
  20
  21 static http_t   *connect_server(const char *, http_t *);
  22 static int      show_jobs(const char *, http_t *, const char *,
  23                           const char *, const int, const int);
  24 static void     show_printer(const char *, http_t *, const char *);
  25 static void     usage(void) _CUPS_NORETURN;
  26
  27
  28 /*
  29  * 'main()' - Parse options and commands.
  30  */
  31
  32 int
  33 main(int  argc,                         /* I - Number of command-line arguments */
  34      char *argv[])                      /* I - Command-line arguments */
  35 {
  36   int           i;                      /* Looping var */
  37   http_t        *http;                  /* Connection to server */
  38   const char    *opt,                   /* Option pointer */
  39                 *dest,                  /* Desired printer */
  40                 *user,                  /* Desired user */
  41                 *val;                   /* Environment variable name */
  42   char          *instance;              /* Printer instance */
  43   int           id,                     /* Desired job ID */
  44                 all,                    /* All printers */
  45                 interval,               /* Reporting interval */
  46                 longstatus;             /* Show file details */
  47   cups_dest_t   *named_dest;            /* Named destination */
  48
  49
  50   _cupsSetLocale(argv);
  51
  52  /*
  53   * Check for command-line options...
  54   */
  55
  56   http       = NULL;
  57   dest       = NULL;
  58   user       = NULL;
  59   id         = 0;
  60   interval   = 0;
  61   longstatus = 0;
  62   all        = 0;
  63
  64   for (i = 1; i < argc; i ++)
  65   {
  66     if (argv[i][0] == '+')
  67     {
  68       interval = atoi(argv[i] + 1);
  69     }
  70     else if (argv[i][0] == '-')
  71     {
  72       for (opt = argv[i] + 1; *opt; opt ++)
  73       {
  74         switch (*opt)
  75         {
  76           case 'E' : /* Encrypt */
  77 #ifdef HAVE_SSL
  78               cupsSetEncryption(HTTP_ENCRYPT_REQUIRED);
  79
  80               if (http)
  81                 httpEncryption(http, HTTP_ENCRYPT_REQUIRED);
  82 #else
  83               _cupsLangPrintf(stderr, _("%s: Sorry, no encryption support."), argv[0]);
  84 #endif /* HAVE_SSL */
  85               break;
  86
  87           case 'U' : /* Username */
  88               if (opt[1] != '\0')
  89               {
  90                 cupsSetUser(opt + 1);
  91                 opt += strlen(opt) - 1;
  92               }
  93               else
  94               {
  95                 i ++;
  96                 if (i >= argc)
  97                 {
  98                   _cupsLangPrintf(stderr, _("%s: Error - expected username after \"-U\" option."), argv[0]);
  99                   return (1);
 100                 }
 101
 102                 cupsSetUser(argv[i]);
 103               }
 104               break;
 105
 106           case 'P' : /* Printer */
 107               if (opt[1] != '\0')
 108               {
 109                 dest = opt + 1;
 110                 opt += strlen(opt) - 1;
 111               }
 112               else
 113               {
 114                 i ++;
 115
 116                 if (i >= argc)
 117                 {
 118                   httpClose(http);
 119
 120                   usage();
 121                 }
 122
 123                 dest = argv[i];
 124               }
 125
 126               if ((instance = strchr(dest, '/')) != NULL)
 127                 *instance++ = '\0';
 128
 129               http = connect_server(argv[0], http);
 130
 131               if ((named_dest = cupsGetNamedDest(http, dest, instance)) == NULL)
 132               {
 133                 if (cupsLastError() == IPP_STATUS_ERROR_BAD_REQUEST ||
 134                     cupsLastError() == IPP_STATUS_ERROR_VERSION_NOT_SUPPORTED)
 135                   _cupsLangPrintf(stderr, _("%s: Error - add '/version=1.1' to server name."), argv[0]);
 136                 else if (instance)
 137                   _cupsLangPrintf(stderr, _("%s: Error - unknown destination \"%s/%s\"."), argv[0], dest, instance);
 138                 else
 139                   _cupsLangPrintf(stderr, _("%s: Unknown destination \"%s\"."), argv[0], dest);
 140
 141                 return (1);
 142               }
 143
 144               cupsFreeDests(1, named_dest);
 145               break;
 146
 147           case 'a' : /* All printers */
 148               all = 1;
 149               break;
 150
 151           case 'h' : /* Connect to host */
 152               if (http)
 153               {
 154                 httpClose(http);
 155                 http = NULL;
 156               }
 157
 158               if (opt[1] != '\0')
 159               {
 160                 cupsSetServer(opt + 1);
 161                 opt += strlen(opt) - 1;
 162               }
 163               else
 164               {
 165                 i ++;
 166
 167                 if (i >= argc)
 168                 {
 169                   _cupsLangPrintf(stderr, _("%s: Error - expected hostname after \"-h\" option."), argv[0]);
 170                   return (1);
 171                 }
 172                 else
 173                   cupsSetServer(argv[i]);
 174               }
 175               break;
 176
 177           case 'l' : /* Long status */
 178               longstatus = 1;
 179               break;
 180
 181           default :
 182               httpClose(http);
 183
 184               usage();
 185         }
 186       }
 187     }
 188     else if (isdigit(argv[i][0] & 255))
 189     {
 190       id = atoi(argv[i]);
 191     }
 192     else
 193     {
 194       user = argv[i];
 195     }
 196   }
 197
 198   http = connect_server(argv[0], http);
 199
 200   if (dest == NULL && !all)
 201   {
 202     if ((named_dest = cupsGetNamedDest(http, NULL, NULL)) == NULL)
 203     {
 204       if (cupsLastError() == IPP_STATUS_ERROR_BAD_REQUEST ||
 205           cupsLastError() == IPP_STATUS_ERROR_VERSION_NOT_SUPPORTED)
 206       {
 207         _cupsLangPrintf(stderr,
 208                         _("%s: Error - add '/version=1.1' to server name."),
 209                         argv[0]);
 210         return (1);
 211       }
 212
 213       val = NULL;
 214
 215       if ((dest = getenv("LPDEST")) == NULL)
 216       {
 217         if ((dest = getenv("PRINTER")) != NULL)
 218         {
 219           if (!strcmp(dest, "lp"))
 220             dest = NULL;
 221           else
 222             val = "PRINTER";
 223         }
 224       }
 225       else
 226         val = "LPDEST";
 227
 228       if (dest && val)
 229         _cupsLangPrintf(stderr,
 230                         _("%s: Error - %s environment variable names "
 231                           "non-existent destination \"%s\"."), argv[0], val,
 232                         dest);
 233       else
 234         _cupsLangPrintf(stderr,
 235                         _("%s: Error - no default destination available."),
 236                         argv[0]);
 237       httpClose(http);
 238       return (1);
 239     }
 240
 241     dest = named_dest->name;
 242   }
 243
 244  /*
 245   * Show the status in a loop...
 246   */
 247
 248   for (;;)
 249   {
 250     if (dest)
 251       show_printer(argv[0], http, dest);
 252
 253     i = show_jobs(argv[0], http, dest, user, id, longstatus);
 254
 255     if (i && interval)
 256     {
 257       fflush(stdout);
 258       sleep((unsigned)interval);
 259     }
 260     else
 261       break;
 262   }
 263
 264  /*
 265   * Close the connection to the server and return...
 266   */
 267
 268   httpClose(http);
 269
 270   return (0);
 271 }
 272
 273
 274 /*
 275  * 'connect_server()' - Connect to the server as necessary...
 276  */
 277
 278 static http_t *                         /* O - New HTTP connection */
 279 connect_server(const char *command,     /* I - Command name */
 280                http_t     *http)        /* I - Current HTTP connection */
 281 {
 282   if (!http)
 283   {
 284     http = httpConnectEncrypt(cupsServer(), ippPort(),
 285                               cupsEncryption());
 286
 287     if (http == NULL)
 288     {
 289       _cupsLangPrintf(stderr, _("%s: Unable to connect to server."), command);
 290       exit(1);
 291     }
 292   }
 293
 294   return (http);
 295 }
 296
 297
 298 /*
 299  * 'show_jobs()' - Show jobs.
 300  */
 301
 302 static int                              /* O - Number of jobs in queue */
 303 show_jobs(const char *command,          /* I - Command name */
 304           http_t     *http,             /* I - HTTP connection to server */
 305           const char *dest,             /* I - Destination */
 306           const char *user,             /* I - User */
 307           const int  id,                /* I - Job ID */
 308           const int  longstatus)        /* I - 1 if long report desired */
 309 {
 310   ipp_t         *request,               /* IPP Request */
 311                 *response;              /* IPP Response */
 312   ipp_attribute_t *attr;                /* Current attribute */
 313   const char    *jobdest,               /* Pointer into job-printer-uri */
 314                 *jobuser,               /* Pointer to job-originating-user-name */
 315                 *jobname;               /* Pointer to job-name */
 316   ipp_jstate_t  jobstate;               /* job-state */
 317   int           jobid,                  /* job-id */
 318                 jobsize,                /* job-k-octets */
 319                 jobcount,               /* Number of jobs */
 320                 jobcopies,              /* Number of copies */
 321                 rank;                   /* Rank of job */
 322   char          resource[1024];         /* Resource string */
 323   char          rankstr[255];           /* Rank string */
 324   char          namestr[1024];          /* Job name string */
 325   static const char * const jobattrs[] =/* Job attributes we want to see */
 326                 {
 327                   "copies",
 328                   "job-id",
 329                   "job-k-octets",
 330                   "job-name",
 331                   "job-originating-user-name",
 332                   "job-printer-uri",
 333                   "job-priority",
 334                   "job-state"
 335                 };
 336   static const char * const ranks[10] = /* Ranking strings */
 337                 {
 338                   "th",
 339                   "st",
 340                   "nd",
 341                   "rd",
 342                   "th",
 343                   "th",
 344                   "th",
 345                   "th",
 346                   "th",
 347                   "th"
 348                 };
 349
 350
 351   if (http == NULL)
 352     return (0);
 353
 354  /*
 355   * Build an IPP_GET_JOBS or IPP_GET_JOB_ATTRIBUTES request, which requires
 356   * the following attributes:
 357   *
 358   *    attributes-charset
 359   *    attributes-natural-language
 360   *    job-uri or printer-uri
 361   *    requested-attributes
 362   *    requesting-user-name
 363   */
 364
 365   request = ippNewRequest(id ? IPP_GET_JOB_ATTRIBUTES : IPP_GET_JOBS);
 366
 367   if (id)
 368   {
 369     snprintf(resource, sizeof(resource), "ipp://localhost/jobs/%d", id);
 370     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri",
 371                  NULL, resource);
 372   }
 373   else if (dest)
 374   {
 375     httpAssembleURIf(HTTP_URI_CODING_ALL, resource, sizeof(resource), "ipp",
 376                      NULL, "localhost", 0, "/printers/%s", dest);
 377
 378     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 379                  NULL, resource);
 380   }
 381   else
 382     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 383                  NULL, "ipp://localhost/");
 384
 385   if (user)
 386   {
 387     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 388                  "requesting-user-name", NULL, user);
 389     ippAddBoolean(request, IPP_TAG_OPERATION, "my-jobs", 1);
 390   }
 391   else
 392     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 393                  "requesting-user-name", NULL, cupsUser());
 394
 395   ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 396                 "requested-attributes",
 397                 (int)(sizeof(jobattrs) / sizeof(jobattrs[0])), NULL, jobattrs);
 398
 399  /*
 400   * Do the request and get back a response...
 401   */
 402
 403   jobcount = 0;
 404
 405   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 406   {
 407     if (response->request.status.status_code > IPP_OK_CONFLICT)
 408     {
 409       _cupsLangPrintf(stderr, "%s: %s", command, cupsLastErrorString());
 410       ippDelete(response);
 411       return (0);
 412     }
 413
 414     rank = 1;
 415
 416    /*
 417     * Loop through the job list and display them...
 418     */
 419
 420     for (attr = response->attrs; attr != NULL; attr = attr->next)
 421     {
 422      /*
 423       * Skip leading attributes until we hit a job...
 424       */
 425
 426       while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
 427         attr = attr->next;
 428
 429       if (attr == NULL)
 430         break;
 431
 432      /*
 433       * Pull the needed attributes from this job...
 434       */
 435
 436       jobid       = 0;
 437       jobsize     = 0;
 438       jobstate    = IPP_JOB_PENDING;
 439       jobname     = "unknown";
 440       jobuser     = "unknown";
 441       jobdest     = NULL;
 442       jobcopies   = 1;
 443
 444       while (attr != NULL && attr->group_tag == IPP_TAG_JOB)
 445       {
 446         if (!strcmp(attr->name, "job-id") &&
 447             attr->value_tag == IPP_TAG_INTEGER)
 448           jobid = attr->values[0].integer;
 449
 450         if (!strcmp(attr->name, "job-k-octets") &&
 451             attr->value_tag == IPP_TAG_INTEGER)
 452           jobsize = attr->values[0].integer;
 453
 454         if (!strcmp(attr->name, "job-state") &&
 455             attr->value_tag == IPP_TAG_ENUM)
 456           jobstate = (ipp_jstate_t)attr->values[0].integer;
 457
 458         if (!strcmp(attr->name, "job-printer-uri") &&
 459             attr->value_tag == IPP_TAG_URI)
 460           if ((jobdest = strrchr(attr->values[0].string.text, '/')) != NULL)
 461             jobdest ++;
 462
 463         if (!strcmp(attr->name, "job-originating-user-name") &&
 464             attr->value_tag == IPP_TAG_NAME)
 465           jobuser = attr->values[0].string.text;
 466
 467         if (!strcmp(attr->name, "job-name") &&
 468             attr->value_tag == IPP_TAG_NAME)
 469           jobname = attr->values[0].string.text;
 470
 471         if (!strcmp(attr->name, "copies") &&
 472             attr->value_tag == IPP_TAG_INTEGER)
 473           jobcopies = attr->values[0].integer;
 474
 475         attr = attr->next;
 476       }
 477
 478      /*
 479       * See if we have everything needed...
 480       */
 481
 482       if (jobdest == NULL || jobid == 0)
 483       {
 484         if (attr == NULL)
 485           break;
 486         else
 487           continue;
 488       }
 489
 490       if (!longstatus && jobcount == 0)
 491         _cupsLangPuts(stdout,
 492                       _("Rank    Owner   Job     File(s)"
 493                         "                         Total Size"));
 494
 495       jobcount ++;
 496
 497      /*
 498       * Display the job...
 499       */
 500
 501       if (jobstate == IPP_JOB_PROCESSING)
 502         strlcpy(rankstr, "active", sizeof(rankstr));
 503       else
 504       {
 505        /*
 506         * Make the rank show the "correct" suffix for each number
 507         * (11-13 are the only special cases, for English anyways...)
 508         */
 509
 510         if ((rank % 100) >= 11 && (rank % 100) <= 13)
 511           snprintf(rankstr, sizeof(rankstr), "%dth", rank);
 512         else
 513           snprintf(rankstr, sizeof(rankstr), "%d%s", rank, ranks[rank % 10]);
 514
 515         rank ++;
 516       }
 517
 518       if (longstatus)
 519       {
 520         _cupsLangPuts(stdout, "\n");
 521
 522         if (jobcopies > 1)
 523           snprintf(namestr, sizeof(namestr), "%d copies of %s", jobcopies,
 524                    jobname);
 525         else
 526           strlcpy(namestr, jobname, sizeof(namestr));
 527
 528         _cupsLangPrintf(stdout, _("%s: %-33.33s [job %d localhost]"),
 529                         jobuser, rankstr, jobid);
 530         _cupsLangPrintf(stdout, _("        %-39.39s %.0f bytes"),
 531                         namestr, 1024.0 * jobsize);
 532       }
 533       else
 534         _cupsLangPrintf(stdout,
 535                         _("%-7s %-7.7s %-7d %-31.31s %.0f bytes"),
 536                         rankstr, jobuser, jobid, jobname, 1024.0 * jobsize);
 537
 538       if (attr == NULL)
 539         break;
 540     }
 541
 542     ippDelete(response);
 543   }
 544   else
 545   {
 546     _cupsLangPrintf(stderr, "%s: %s", command, cupsLastErrorString());
 547     return (0);
 548   }
 549
 550   if (jobcount == 0)
 551     _cupsLangPuts(stdout, _("no entries"));
 552
 553   return (jobcount);
 554 }
 555
 556
 557 /*
 558  * 'show_printer()' - Show printer status.
 559  */
 560
 561 static void
 562 show_printer(const char *command,       /* I - Command name */
 563              http_t     *http,          /* I - HTTP connection to server */
 564              const char *dest)          /* I - Destination */
 565 {
 566   ipp_t         *request,               /* IPP Request */
 567                 *response;              /* IPP Response */
 568   ipp_attribute_t *attr;                /* Current attribute */
 569   ipp_pstate_t  state;                  /* Printer state */
 570   char          uri[HTTP_MAX_URI];      /* Printer URI */
 571
 572
 573   if (http == NULL)
 574     return;
 575
 576  /*
 577   * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
 578   * attributes:
 579   *
 580   *    attributes-charset
 581   *    attributes-natural-language
 582   *    printer-uri
 583   */
 584
 585   request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
 586
 587   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 588                    "localhost", 0, "/printers/%s", dest);
 589   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 590                "printer-uri", NULL, uri);
 591
 592  /*
 593   * Do the request and get back a response...
 594   */
 595
 596   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 597   {
 598     if (response->request.status.status_code > IPP_OK_CONFLICT)
 599     {
 600       _cupsLangPrintf(stderr, "%s: %s", command, cupsLastErrorString());
 601       ippDelete(response);
 602       return;
 603     }
 604
 605     if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL)
 606       state = (ipp_pstate_t)attr->values[0].integer;
 607     else
 608       state = IPP_PRINTER_STOPPED;
 609
 610     switch (state)
 611     {
 612       case IPP_PRINTER_IDLE :
 613           _cupsLangPrintf(stdout, _("%s is ready"), dest);
 614           break;
 615       case IPP_PRINTER_PROCESSING :
 616           _cupsLangPrintf(stdout, _("%s is ready and printing"),
 617                           dest);
 618           break;
 619       case IPP_PRINTER_STOPPED :
 620           _cupsLangPrintf(stdout, _("%s is not ready"), dest);
 621           break;
 622     }
 623
 624     ippDelete(response);
 625   }
 626   else
 627     _cupsLangPrintf(stderr, "%s: %s", command, cupsLastErrorString());
 628 }
 629
 630
 631 /*
 632  * 'usage()' - Show program usage.
 633  */
 634
 635 static void
 636 usage(void)
 637 {
 638   _cupsLangPuts(stderr,
 639                 _("Usage: lpq [-P dest] [-U username] [-h hostname[:port]] "
 640                   "[-l] [+interval]"));
 641   exit(1);
 642 }