cgi-bin/classes.c

   1 /*
   2  * Class status CGI for CUPS.
   3  *
   4  * Copyright 2007-2016 by Apple Inc.
   5  * Copyright 1997-2006 by Easy Software Products.
   6  *
   7  * These coded instructions, statements, and computer programs are the
   8  * property of Apple Inc. and are protected by Federal copyright
   9  * law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  10  * which should have been included with this file.  If this file is
  11  * file is missing or damaged, see the license at "http://www.cups.org/".
  12  */
  13
  14 /*
  15  * Include necessary headers...
  16  */
  17
  18 #include "cgi-private.h"
  19
  20
  21 /*
  22  * Local functions...
  23  */
  24
  25 static void     do_class_op(http_t *http, const char *printer, ipp_op_t op,
  26                             const char *title);
  27 static void     show_all_classes(http_t *http, const char *username);
  28 static void     show_class(http_t *http, const char *printer);
  29
  30
  31 /*
  32  * 'main()' - Main entry for CGI.
  33  */
  34
  35 int                                     /* O - Exit status */
  36 main(void)
  37 {
  38   const char    *pclass;                /* Class name */
  39   const char    *user;                  /* Username */
  40   http_t        *http;                  /* Connection to the server */
  41   ipp_t         *request,               /* IPP request */
  42                 *response;              /* IPP response */
  43   ipp_attribute_t *attr;                /* IPP attribute */
  44   const char    *op;                    /* Operation to perform, if any */
  45   static const char *def_attrs[] =      /* Attributes for default printer */
  46                 {
  47                   "printer-name",
  48                   "printer-uri-supported"
  49                 };
  50
  51
  52  /*
  53   * Get any form variables...
  54   */
  55
  56   cgiInitialize();
  57
  58   op = cgiGetVariable("OP");
  59
  60  /*
  61   * Set the web interface section...
  62   */
  63
  64   cgiSetVariable("SECTION", "classes");
  65   cgiSetVariable("REFRESH_PAGE", "");
  66
  67  /*
  68   * See if we are displaying a printer or all classes...
  69   */
  70
  71   if ((pclass = getenv("PATH_INFO")) != NULL)
  72   {
  73     pclass ++;
  74
  75     if (!*pclass)
  76       pclass = NULL;
  77
  78     if (pclass)
  79       cgiSetVariable("PRINTER_NAME", pclass);
  80   }
  81
  82  /*
  83   * See who is logged in...
  84   */
  85
  86   user = getenv("REMOTE_USER");
  87
  88  /*
  89   * Connect to the HTTP server...
  90   */
  91
  92   http = httpConnectEncrypt(cupsServer(), ippPort(), cupsEncryption());
  93
  94  /*
  95   * Get the default printer...
  96   */
  97
  98   if (!op || !cgiIsPOST())
  99   {
 100    /*
 101     * Get the default destination...
 102     */
 103
 104     request = ippNewRequest(CUPS_GET_DEFAULT);
 105
 106     ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 107                   "requested-attributes",
 108                   sizeof(def_attrs) / sizeof(def_attrs[0]), NULL, def_attrs);
 109
 110     if ((response = cupsDoRequest(http, request, "/")) != NULL)
 111     {
 112       if ((attr = ippFindAttribute(response, "printer-name", IPP_TAG_NAME)) != NULL)
 113         cgiSetVariable("DEFAULT_NAME", attr->values[0].string.text);
 114
 115       if ((attr = ippFindAttribute(response, "printer-uri-supported", IPP_TAG_URI)) != NULL)
 116       {
 117         char    url[HTTP_MAX_URI];      /* New URL */
 118
 119
 120         cgiSetVariable("DEFAULT_URI",
 121                        cgiRewriteURL(attr->values[0].string.text,
 122                                      url, sizeof(url), NULL));
 123       }
 124
 125       ippDelete(response);
 126     }
 127
 128    /*
 129     * See if we need to show a list of classes or the status of a
 130     * single printer...
 131     */
 132
 133     if (!pclass)
 134       show_all_classes(http, user);
 135     else
 136       show_class(http, pclass);
 137   }
 138   else if (pclass)
 139   {
 140     if (!*op)
 141     {
 142       const char *server_port = getenv("SERVER_PORT");
 143                                         /* Port number string */
 144       int       port = atoi(server_port ? server_port : "0");
 145                                         /* Port number */
 146       char      uri[1024];              /* URL */
 147
 148       httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri),
 149                        getenv("HTTPS") ? "https" : "http", NULL,
 150                        getenv("SERVER_NAME"), port, "/classes/%s", pclass);
 151
 152       printf("Location: %s\n\n", uri);
 153     }
 154     else if (!strcmp(op, "start-class"))
 155       do_class_op(http, pclass, IPP_RESUME_PRINTER, cgiText(_("Resume Class")));
 156     else if (!strcmp(op, "stop-class"))
 157       do_class_op(http, pclass, IPP_PAUSE_PRINTER, cgiText(_("Pause Class")));
 158     else if (!strcmp(op, "accept-jobs"))
 159       do_class_op(http, pclass, CUPS_ACCEPT_JOBS, cgiText(_("Accept Jobs")));
 160     else if (!strcmp(op, "reject-jobs"))
 161       do_class_op(http, pclass, CUPS_REJECT_JOBS, cgiText(_("Reject Jobs")));
 162     else if (!strcmp(op, "cancel-jobs"))
 163       do_class_op(http, pclass, IPP_OP_CANCEL_JOBS, cgiText(_("Cancel Jobs")));
 164     else if (!_cups_strcasecmp(op, "print-test-page"))
 165       cgiPrintTestPage(http, pclass);
 166     else if (!_cups_strcasecmp(op, "move-jobs"))
 167       cgiMoveJobs(http, pclass, 0);
 168     else
 169     {
 170      /*
 171       * Unknown/bad operation...
 172       */
 173
 174       cgiStartHTML(pclass);
 175       cgiCopyTemplateLang("error-op.tmpl");
 176       cgiEndHTML();
 177     }
 178   }
 179   else
 180   {
 181    /*
 182     * Unknown/bad operation...
 183     */
 184
 185     cgiStartHTML(cgiText(_("Classes")));
 186     cgiCopyTemplateLang("error-op.tmpl");
 187     cgiEndHTML();
 188   }
 189
 190  /*
 191   * Close the HTTP server connection...
 192   */
 193
 194   httpClose(http);
 195
 196  /*
 197   * Return with no errors...
 198   */
 199
 200   return (0);
 201 }
 202
 203
 204 /*
 205  * 'do_class_op()' - Do a class operation.
 206  */
 207
 208 static void
 209 do_class_op(http_t      *http,          /* I - HTTP connection */
 210             const char  *printer,       /* I - Printer name */
 211             ipp_op_t    op,             /* I - Operation to perform */
 212             const char  *title)         /* I - Title of page */
 213 {
 214   ipp_t         *request;               /* IPP request */
 215   char          uri[HTTP_MAX_URI],      /* Printer URI */
 216                 resource[HTTP_MAX_URI]; /* Path for request */
 217
 218
 219  /*
 220   * Build a printer request, which requires the following
 221   * attributes:
 222   *
 223   *    attributes-charset
 224   *    attributes-natural-language
 225   *    printer-uri
 226   */
 227
 228   request = ippNewRequest(op);
 229
 230   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 231                    "localhost", 0, "/classes/%s", printer);
 232   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 233                NULL, uri);
 234
 235  /*
 236   * Do the request and get back a response...
 237   */
 238
 239   snprintf(resource, sizeof(resource), "/classes/%s", printer);
 240   ippDelete(cupsDoRequest(http, request, resource));
 241
 242   if (cupsLastError() == IPP_NOT_AUTHORIZED)
 243   {
 244     puts("Status: 401\n");
 245     exit(0);
 246   }
 247   else if (cupsLastError() > IPP_OK_CONFLICT)
 248   {
 249     cgiStartHTML(title);
 250     cgiShowIPPError(_("Unable to do maintenance command"));
 251   }
 252   else
 253   {
 254    /*
 255     * Redirect successful updates back to the printer page...
 256     */
 257
 258     char        url[1024],              /* Printer/class URL */
 259                 refresh[1024];          /* Refresh URL */
 260
 261
 262     cgiRewriteURL(uri, url, sizeof(url), NULL);
 263     cgiFormEncode(uri, url, sizeof(uri));
 264     snprintf(refresh, sizeof(refresh), "5;URL=%s", uri);
 265     cgiSetVariable("refresh_page", refresh);
 266
 267     cgiStartHTML(title);
 268
 269     cgiSetVariable("IS_CLASS", "YES");
 270
 271     if (op == IPP_PAUSE_PRINTER)
 272       cgiCopyTemplateLang("printer-stop.tmpl");
 273     else if (op == IPP_RESUME_PRINTER)
 274       cgiCopyTemplateLang("printer-start.tmpl");
 275     else if (op == CUPS_ACCEPT_JOBS)
 276       cgiCopyTemplateLang("printer-accept.tmpl");
 277     else if (op == CUPS_REJECT_JOBS)
 278       cgiCopyTemplateLang("printer-reject.tmpl");
 279     else if (op == IPP_OP_CANCEL_JOBS)
 280       cgiCopyTemplateLang("printer-cancel-jobs.tmpl");
 281   }
 282
 283   cgiEndHTML();
 284 }
 285
 286
 287 /*
 288  * 'show_all_classes()' - Show all classes...
 289  */
 290
 291 static void
 292 show_all_classes(http_t     *http,      /* I - Connection to server */
 293                  const char *user)      /* I - Username */
 294 {
 295   int                   i;              /* Looping var */
 296   ipp_t                 *request,       /* IPP request */
 297                         *response;      /* IPP response */
 298   cups_array_t          *classes;       /* Array of class objects */
 299   ipp_attribute_t       *pclass;        /* Class object */
 300   int                   first,          /* First class to show */
 301                         count;          /* Number of classes */
 302   const char            *var;           /* Form variable */
 303   void                  *search;        /* Search data */
 304   char                  val[1024];      /* Form variable */
 305
 306
 307  /*
 308   * Show the standard header...
 309   */
 310
 311   cgiStartHTML(cgiText(_("Classes")));
 312
 313  /*
 314   * Build a CUPS_GET_CLASSES request, which requires the following
 315   * attributes:
 316   *
 317   *    attributes-charset
 318   *    attributes-natural-language
 319   *    requesting-user-name
 320   */
 321
 322   request = ippNewRequest(CUPS_GET_CLASSES);
 323
 324   if (user)
 325     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 326                  "requesting-user-name", NULL, user);
 327
 328   cgiGetAttributes(request, "classes.tmpl");
 329
 330  /*
 331   * Do the request and get back a response...
 332   */
 333
 334   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 335   {
 336    /*
 337     * Get a list of matching job objects.
 338     */
 339
 340     if ((var = cgiGetVariable("QUERY")) != NULL &&
 341         !cgiGetVariable("CLEAR"))
 342       search = cgiCompileSearch(var);
 343     else
 344       search = NULL;
 345
 346     classes = cgiGetIPPObjects(response, search);
 347     count   = cupsArrayCount(classes);
 348
 349     if (search)
 350       cgiFreeSearch(search);
 351
 352    /*
 353     * Figure out which classes to display...
 354     */
 355
 356     if ((var = cgiGetVariable("FIRST")) != NULL)
 357       first = atoi(var);
 358     else
 359       first = 0;
 360
 361     if (first >= count)
 362       first = count - CUPS_PAGE_MAX;
 363
 364     first = (first / CUPS_PAGE_MAX) * CUPS_PAGE_MAX;
 365
 366     if (first < 0)
 367       first = 0;
 368
 369     sprintf(val, "%d", count);
 370     cgiSetVariable("TOTAL", val);
 371
 372     for (i = 0, pclass = (ipp_attribute_t *)cupsArrayIndex(classes, first);
 373          i < CUPS_PAGE_MAX && pclass;
 374          i ++, pclass = (ipp_attribute_t *)cupsArrayNext(classes))
 375       cgiSetIPPObjectVars(pclass, NULL, i);
 376
 377    /*
 378     * Save navigation URLs...
 379     */
 380
 381     cgiSetVariable("THISURL", "/classes/");
 382
 383     if (first > 0)
 384     {
 385       sprintf(val, "%d", first - CUPS_PAGE_MAX);
 386       cgiSetVariable("PREV", val);
 387     }
 388
 389     if ((first + CUPS_PAGE_MAX) < count)
 390     {
 391       sprintf(val, "%d", first + CUPS_PAGE_MAX);
 392       cgiSetVariable("NEXT", val);
 393     }
 394
 395     if (count > CUPS_PAGE_MAX)
 396     {
 397       snprintf(val, sizeof(val), "%d", CUPS_PAGE_MAX * (count / CUPS_PAGE_MAX));
 398       cgiSetVariable("LAST", val);
 399     }
 400
 401    /*
 402     * Then show everything...
 403     */
 404
 405     cgiCopyTemplateLang("search.tmpl");
 406
 407     cgiCopyTemplateLang("classes-header.tmpl");
 408
 409     if (count > CUPS_PAGE_MAX)
 410       cgiCopyTemplateLang("pager.tmpl");
 411
 412     cgiCopyTemplateLang("classes.tmpl");
 413
 414     if (count > CUPS_PAGE_MAX)
 415       cgiCopyTemplateLang("pager.tmpl");
 416
 417    /*
 418     * Delete the response...
 419     */
 420
 421     cupsArrayDelete(classes);
 422     ippDelete(response);
 423   }
 424   else
 425   {
 426    /*
 427     * Show the error...
 428     */
 429
 430     cgiShowIPPError(_("Unable to get class list"));
 431   }
 432
 433    cgiEndHTML();
 434 }
 435
 436
 437 /*
 438  * 'show_class()' - Show a single class.
 439  */
 440
 441 static void
 442 show_class(http_t     *http,            /* I - Connection to server */
 443            const char *pclass)          /* I - Name of class */
 444 {
 445   ipp_t         *request,               /* IPP request */
 446                 *response;              /* IPP response */
 447   ipp_attribute_t *attr;                /* IPP attribute */
 448   char          uri[HTTP_MAX_URI];      /* Printer URI */
 449   char          refresh[1024];          /* Refresh URL */
 450
 451
 452  /*
 453   * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
 454   * attributes:
 455   *
 456   *    attributes-charset
 457   *    attributes-natural-language
 458   *    printer-uri
 459   */
 460
 461   request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
 462
 463   httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 464                    "localhost", 0, "/classes/%s", pclass);
 465   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
 466                uri);
 467
 468   cgiGetAttributes(request, "class.tmpl");
 469
 470  /*
 471   * Do the request and get back a response...
 472   */
 473
 474   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 475   {
 476    /*
 477     * Got the result; set the CGI variables and check the status of a
 478     * single-queue request...
 479     */
 480
 481     cgiSetIPPVars(response, NULL, NULL, NULL, 0);
 482
 483     if (pclass && (attr = ippFindAttribute(response, "printer-state",
 484                                             IPP_TAG_ENUM)) != NULL &&
 485         attr->values[0].integer == IPP_PRINTER_PROCESSING)
 486     {
 487      /*
 488       * Class is processing - automatically refresh the page until we
 489       * are done printing...
 490       */
 491
 492       cgiFormEncode(uri, pclass, sizeof(uri));
 493       snprintf(refresh, sizeof(refresh), "10;URL=/classes/%s", uri);
 494       cgiSetVariable("refresh_page", refresh);
 495     }
 496
 497    /*
 498     * Delete the response...
 499     */
 500
 501     ippDelete(response);
 502
 503    /*
 504     * Show the standard header...
 505     */
 506
 507     cgiStartHTML(pclass);
 508
 509    /*
 510     * Show the class status...
 511     */
 512
 513     cgiCopyTemplateLang("class.tmpl");
 514
 515    /*
 516     * Show jobs for the specified class...
 517     */
 518
 519     cgiCopyTemplateLang("class-jobs-header.tmpl");
 520     cgiShowJobs(http, pclass);
 521   }
 522   else
 523   {
 524    /*
 525     * Show the IPP error...
 526     */
 527
 528     cgiStartHTML(pclass);
 529     cgiShowIPPError(_("Unable to get class status"));
 530   }
 531
 532    cgiEndHTML();
 533 }