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   DEBUG_printf(("show_jobs(http=%p, dest=%p, user=%p, id=%d, longstatus%d)\n",
 352                 http, dest, user, id, longstatus));
 353
 354   if (http == NULL)
 355     return (0);
 356
 357  /*
 358   * Build an IPP_GET_JOBS or IPP_GET_JOB_ATTRIBUTES request, which requires
 359   * the following attributes:
 360   *
 361   *    attributes-charset
 362   *    attributes-natural-language
 363   *    job-uri or printer-uri
 364   *    requested-attributes
 365   *    requesting-user-name
 366   */
 367
 368   request = ippNewRequest(id ? IPP_GET_JOB_ATTRIBUTES : IPP_GET_JOBS);
 369
 370   if (id)
 371   {
 372     snprintf(resource, sizeof(resource), "ipp://localhost/jobs/%d", id);
 373     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri",
 374                  NULL, resource);
 375   }
 376   else if (dest)
 377   {
 378     httpAssembleURIf(HTTP_URI_CODING_ALL, resource, sizeof(resource), "ipp",
 379                      NULL, "localhost", 0, "/printers/%s", dest);
 380
 381     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 382                  NULL, resource);
 383   }
 384   else
 385     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 386                  NULL, "ipp://localhost/");
 387
 388   if (user)
 389   {
 390     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 391                  "requesting-user-name", NULL, user);
 392     ippAddBoolean(request, IPP_TAG_OPERATION, "my-jobs", 1);
 393   }
 394   else
 395     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 396                  "requesting-user-name", NULL, cupsUser());
 397
 398   ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 399                 "requested-attributes",
 400                 (int)(sizeof(jobattrs) / sizeof(jobattrs[0])), NULL, jobattrs);
 401
 402  /*
 403   * Do the request and get back a response...
 404   */
 405
 406   jobcount = 0;
 407
 408   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 409   {
 410     if (response->request.status.status_code > IPP_OK_CONFLICT)
 411     {
 412       _cupsLangPrintf(stderr, "%s: %s", command, cupsLastErrorString());
 413       ippDelete(response);
 414       return (0);
 415     }
 416
 417     rank = 1;
 418
 419    /*
 420     * Loop through the job list and display them...
 421     */
 422
 423     for (attr = response->attrs; attr != NULL; attr = attr->next)
 424     {
 425      /*
 426       * Skip leading attributes until we hit a job...
 427       */
 428
 429       while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
 430         attr = attr->next;
 431
 432       if (attr == NULL)
 433         break;
 434
 435      /*
 436       * Pull the needed attributes from this job...
 437       */
 438
 439       jobid       = 0;
 440       jobsize     = 0;
 441       jobstate    = IPP_JOB_PENDING;
 442       jobname     = "unknown";
 443       jobuser     = "unknown";
 444       jobdest     = NULL;
 445       jobcopies   = 1;
 446
 447       while (attr != NULL && attr->group_tag == IPP_TAG_JOB)
 448       {
 449         if (!strcmp(attr->name, "job-id") &&
 450             attr->value_tag == IPP_TAG_INTEGER)
 451           jobid = attr->values[0].integer;
 452
 453         if (!strcmp(attr->name, "job-k-octets") &&
 454             attr->value_tag == IPP_TAG_INTEGER)
 455           jobsize = attr->values[0].integer;
 456
 457         if (!strcmp(attr->name, "job-state") &&
 458             attr->value_tag == IPP_TAG_ENUM)
 459           jobstate = (ipp_jstate_t)attr->values[0].integer;
 460
 461         if (!strcmp(attr->name, "job-printer-uri") &&
 462             attr->value_tag == IPP_TAG_URI)
 463           if ((jobdest = strrchr(attr->values[0].string.text, '/')) != NULL)
 464             jobdest ++;
 465
 466         if (!strcmp(attr->name, "job-originating-user-name") &&
 467             attr->value_tag == IPP_TAG_NAME)
 468           jobuser = attr->values[0].string.text;
 469
 470         if (!strcmp(attr->name, "job-name") &&
 471             attr->value_tag == IPP_TAG_NAME)
 472           jobname = attr->values[0].string.text;
 473
 474         if (!strcmp(attr->name, "copies") &&
 475             attr->value_tag == IPP_TAG_INTEGER)
 476           jobcopies = attr->values[0].integer;
 477
 478         attr = attr->next;
 479       }
 480
 481      /*
 482       * See if we have everything needed...
 483       */
 484
 485       if (jobdest == NULL || jobid == 0)
 486       {
 487         if (attr == NULL)
 488           break;
 489         else
 490           continue;
 491       }
 492
 493       if (!longstatus && jobcount == 0)
 494         _cupsLangPuts(stdout,
 495                       _("Rank    Owner   Job     File(s)"
 496                         "                         Total Size"));
 497
 498       jobcount ++;
 499
 500      /*
 501       * Display the job...
 502       */
 503
 504       if (jobstate == IPP_JOB_PROCESSING)
 505         strlcpy(rankstr, "active", sizeof(rankstr));
 506       else
 507       {
 508        /*
 509         * Make the rank show the "correct" suffix for each number
 510         * (11-13 are the only special cases, for English anyways...)
 511         */
 512
 513         if ((rank % 100) >= 11 && (rank % 100) <= 13)
 514           snprintf(rankstr, sizeof(rankstr), "%dth", rank);
 515         else
 516           snprintf(rankstr, sizeof(rankstr), "%d%s", rank, ranks[rank % 10]);
 517
 518         rank ++;
 519       }
 520
 521       if (longstatus)
 522       {
 523         _cupsLangPuts(stdout, "\n");
 524
 525         if (jobcopies > 1)
 526           snprintf(namestr, sizeof(namestr), "%d copies of %s", jobcopies,
 527                    jobname);
 528         else
 529           strlcpy(namestr, jobname, sizeof(namestr));
 530
 531         _cupsLangPrintf(stdout, _("%s: %-33.33s [job %d localhost]"),
 532                         jobuser, rankstr, jobid);
 533         _cupsLangPrintf(stdout, _("        %-39.39s %.0f bytes"),
 534                         namestr, 1024.0 * jobsize);
 535       }
 536       else
 537         _cupsLangPrintf(stdout,
 538                         _("%-7s %-7.7s %-7d %-31.31s %.0f bytes"),
 539                         rankstr, jobuser, jobid, jobname, 1024.0 * jobsize);
 540
 541       if (attr == NULL)
 542         break;
 543     }
 544
 545     ippDelete(response);
 546   }
 547   else
 548   {
 549     _cupsLangPrintf(stderr, "%s: %s", command, cupsLastErrorString());
 550     return (0);
 551   }
 552
 553   if (jobcount == 0)
 554     _cupsLangPuts(stdout, _("no entries"));
 555
 556   return (jobcount);
 557 }
 558
 559
 560 /*
 561  * 'show_printer()' - Show printer status.
 562  */
 563
 564 static void
 565 show_printer(const char *command,       /* I - Command name */
 566              http_t     *http,          /* I - HTTP connection to server */
 567              const char *dest)          /* I - Destination */
 568 {
 569   ipp_t         *request,               /* IPP Request */
 570                 *response;              /* IPP Response */
 571   ipp_attribute_t *attr;                /* Current attribute */
 572   ipp_pstate_t  state;                  /* Printer state */
 573   char          uri[HTTP_MAX_URI];      /* Printer URI */
 574
 575
 576   if (http == NULL)
 577     return;
 578
 579  /*
 580   * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
 581   * attributes:
 582   *
 583   *    attributes-charset
 584   *    attributes-natural-language
 585   *    printer-uri
 586   */
 587
 588   request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
 589
 590   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 591                    "localhost", 0, "/printers/%s", dest);
 592   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 593                "printer-uri", NULL, uri);
 594
 595  /*
 596   * Do the request and get back a response...
 597   */
 598
 599   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 600   {
 601     if (response->request.status.status_code > IPP_OK_CONFLICT)
 602     {
 603       _cupsLangPrintf(stderr, "%s: %s", command, cupsLastErrorString());
 604       ippDelete(response);
 605       return;
 606     }
 607
 608     if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL)
 609       state = (ipp_pstate_t)attr->values[0].integer;
 610     else
 611       state = IPP_PRINTER_STOPPED;
 612
 613     switch (state)
 614     {
 615       case IPP_PRINTER_IDLE :
 616           _cupsLangPrintf(stdout, _("%s is ready"), dest);
 617           break;
 618       case IPP_PRINTER_PROCESSING :
 619           _cupsLangPrintf(stdout, _("%s is ready and printing"),
 620                           dest);
 621           break;
 622       case IPP_PRINTER_STOPPED :
 623           _cupsLangPrintf(stdout, _("%s is not ready"), dest);
 624           break;
 625     }
 626
 627     ippDelete(response);
 628   }
 629   else
 630     _cupsLangPrintf(stderr, "%s: %s", command, cupsLastErrorString());
 631 }
 632
 633
 634 /*
 635  * 'usage()' - Show program usage.
 636  */
 637
 638 static void
 639 usage(void)
 640 {
 641   _cupsLangPuts(stderr,
 642                 _("Usage: lpq [-P dest] [-U username] [-h hostname[:port]] "
 643                   "[-l] [+interval]"));
 644   exit(1);
 645 }