import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / printing / print_cups.c
1 /*
2  * Support code for the Common UNIX Printing System ("CUPS")
3  *
4  * Copyright 1999-2003 by Michael R Sweet.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  * 
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  * 
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20
21 #include "includes.h"
22 #include "printing.h"
23
24 #ifdef HAVE_CUPS
25 #include <cups/cups.h>
26 #include <cups/language.h>
27
28
29 /*
30  * CUPS printing interface definitions...
31  */
32
33 static int cups_job_delete(int snum, struct printjob *pjob);
34 static int cups_job_pause(int snum, struct printjob *pjob);
35 static int cups_job_resume(int snum, struct printjob *pjob);
36 static int cups_job_submit(int snum, struct printjob *pjob);
37 static int cups_queue_get(int snum, print_queue_struct **q,
38                           print_status_struct *status);
39 static int cups_queue_pause(int snum);
40 static int cups_queue_resume(int snum);
41
42
43 struct printif  cups_printif =
44                 {
45                   cups_queue_get,
46                   cups_queue_pause,
47                   cups_queue_resume,
48                   cups_job_delete,
49                   cups_job_pause,
50                   cups_job_resume,
51                   cups_job_submit,
52                 };
53
54 /*
55  * 'cups_passwd_cb()' - The CUPS password callback...
56  */
57
58 static const char *                             /* O - Password or NULL */
59 cups_passwd_cb(const char *prompt)      /* I - Prompt */
60 {
61  /*
62   * Always return NULL to indicate that no password is available...
63   */
64
65   return (NULL);
66 }
67
68
69 /*
70  * 'cups_printer_fn()' - Call a function for every printer known to the
71  *                       system.
72  */
73
74 void cups_printer_fn(void (*fn)(char *, char *))
75 {
76         /* I - Function to call */
77         http_t          *http;          /* HTTP connection to server */
78         ipp_t           *request,       /* IPP Request */
79                         *response;      /* IPP Response */
80         ipp_attribute_t *attr;          /* Current attribute */
81         cups_lang_t     *language;      /* Default language */
82         char            *name,          /* printer-name attribute */
83                         *make_model,    /* printer-make-and-model attribute */
84                         *info;          /* printer-info attribute */
85         static const char *requested[] =/* Requested attributes */
86                         {
87                           "printer-name",
88                           "printer-make-and-model",
89                           "printer-info"
90                         };       
91
92
93         DEBUG(5,("cups_printer_fn(%p)\n", fn));
94
95        /*
96         * Make sure we don't ask for passwords...
97         */
98
99         cupsSetPasswordCB(cups_passwd_cb);
100
101        /*
102         * Try to connect to the server...
103         */
104
105         if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
106         {
107                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n", 
108                          cupsServer(), strerror(errno)));
109                 return;
110         }
111
112        /*
113         * Build a CUPS_GET_PRINTERS request, which requires the following
114         * attributes:
115         *
116         *    attributes-charset
117         *    attributes-natural-language
118         *    requested-attributes
119         */
120
121         request = ippNew();
122
123         request->request.op.operation_id = CUPS_GET_PRINTERS;
124         request->request.op.request_id   = 1;
125
126         language = cupsLangDefault();
127
128         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
129                      "attributes-charset", NULL, cupsLangEncoding(language));
130
131         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
132                      "attributes-natural-language", NULL, language->language);
133
134         ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
135                       "requested-attributes",
136                       (sizeof(requested) / sizeof(requested[0])),
137                       NULL, requested);
138
139        /*
140         * Do the request and get back a response...
141         */
142
143         if ((response = cupsDoRequest(http, request, "/")) == NULL)
144         {
145                 DEBUG(0,("Unable to get printer list - %s\n",
146                          ippErrorString(cupsLastError())));
147                 httpClose(http);
148                 return;
149         }
150
151         for (attr = response->attrs; attr != NULL;)
152         {
153                /*
154                 * Skip leading attributes until we hit a printer...
155                 */
156
157                 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
158                         attr = attr->next;
159
160                 if (attr == NULL)
161                         break;
162
163                /*
164                 * Pull the needed attributes from this printer...
165                 */
166
167                 name       = NULL;
168                 make_model = NULL;
169                 info       = NULL;
170
171                 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER)
172                 {
173                         if (strcmp(attr->name, "printer-name") == 0 &&
174                             attr->value_tag == IPP_TAG_NAME)
175                                 name = attr->values[0].string.text;
176
177                         if (strcmp(attr->name, "printer-make-and-model") == 0 &&
178                             attr->value_tag == IPP_TAG_TEXT)
179                                 make_model = attr->values[0].string.text;
180
181                         if (strcmp(attr->name, "printer-info") == 0 &&
182                             attr->value_tag == IPP_TAG_TEXT)
183                                 info = attr->values[0].string.text;
184
185                         attr = attr->next;
186                 }
187
188                /*
189                 * See if we have everything needed...
190                 */
191
192                 if (name == NULL)
193                         break;
194
195                 if (info == NULL || !info[0])
196                         (*fn)(name, make_model);
197                 else
198                         (*fn)(name, info);
199                 
200
201         }
202
203         ippDelete(response);
204
205
206        /*
207         * Build a CUPS_GET_CLASSES request, which requires the following
208         * attributes:
209         *
210         *    attributes-charset
211         *    attributes-natural-language
212         *    requested-attributes
213         */
214
215         request = ippNew();
216
217         request->request.op.operation_id = CUPS_GET_CLASSES;
218         request->request.op.request_id   = 1;
219
220         language = cupsLangDefault();
221
222         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
223                      "attributes-charset", NULL, cupsLangEncoding(language));
224
225         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
226                      "attributes-natural-language", NULL, language->language);
227
228         ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
229                       "requested-attributes",
230                       (sizeof(requested) / sizeof(requested[0])),
231                       NULL, requested);
232
233        /*
234         * Do the request and get back a response...
235         */
236
237         if ((response = cupsDoRequest(http, request, "/")) == NULL)
238         {
239                 DEBUG(0,("Unable to get printer list - %s\n",
240                          ippErrorString(cupsLastError())));
241                 httpClose(http);
242                 return;
243         }
244
245         for (attr = response->attrs; attr != NULL;)
246         {
247                /*
248                 * Skip leading attributes until we hit a printer...
249                 */
250
251                 while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
252                         attr = attr->next;
253
254                 if (attr == NULL)
255                         break;
256
257                /*
258                 * Pull the needed attributes from this printer...
259                 */
260
261                 name       = NULL;
262                 make_model = NULL;
263                 info       = NULL;
264
265                 while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER)
266                 {
267                         if (strcmp(attr->name, "printer-name") == 0 &&
268                             attr->value_tag == IPP_TAG_NAME)
269                                 name = attr->values[0].string.text;
270
271                         if (strcmp(attr->name, "printer-make-and-model") == 0 &&
272                             attr->value_tag == IPP_TAG_TEXT)
273                                 make_model = attr->values[0].string.text;
274
275                         if (strcmp(attr->name, "printer-info") == 0 &&
276                             attr->value_tag == IPP_TAG_TEXT)
277                                 info = attr->values[0].string.text;
278
279                         attr = attr->next;
280                 }
281
282                /*
283                 * See if we have everything needed...
284                 */
285
286                 if (name == NULL)
287                         break;
288
289                 if (info == NULL || !info[0])
290                         (*fn)(name, make_model);
291                 else
292                         (*fn)(name, info);
293                 
294
295         }
296
297         ippDelete(response);
298
299        /*
300         * Close the connection to the server...
301         */
302
303         httpClose(http);
304 }
305
306
307 /*
308  * 'cups_printername_ok()' - Provide the equivalent of pcap_printername_ok()
309  *                           for CUPS.
310  * O - 1 if printer name OK
311  * I - Name of printer 
312  */
313 int cups_printername_ok(const char *name)
314 {
315         http_t          *http;          /* HTTP connection to server */
316         ipp_t           *request,       /* IPP Request */
317                         *response;      /* IPP Response */
318         cups_lang_t     *language;      /* Default language */
319         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
320
321
322         DEBUG(5,("cups_printername_ok(\"%s\")\n", name));
323
324        /*
325         * Make sure we don't ask for passwords...
326         */
327
328         cupsSetPasswordCB(cups_passwd_cb);
329
330        /*
331         * Try to connect to the server...
332         */
333
334         if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
335         {
336                 DEBUG(3,("Unable to connect to CUPS server %s - %s\n", 
337                          cupsServer(), strerror(errno)));
338                 return (0);
339         }
340
341        /*
342         * Build an IPP_GET_PRINTER_ATTRS request, which requires the following
343         * attributes:
344         *
345         *    attributes-charset
346         *    attributes-natural-language
347         *    requested-attributes
348         *    printer-uri
349         */
350
351         request = ippNew();
352
353         request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
354         request->request.op.request_id   = 1;
355
356         language = cupsLangDefault();
357
358         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
359                      "attributes-charset", NULL, cupsLangEncoding(language));
360
361         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
362                      "attributes-natural-language", NULL, language->language);
363
364         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
365                      "requested-attributes", NULL, "printer-uri");
366
367         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s", name);
368
369         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
370                      "printer-uri", NULL, uri);
371
372        /*
373         * Do the request and get back a response...
374         */
375
376         if ((response = cupsDoRequest(http, request, "/")) == NULL)
377         {
378                 DEBUG(3,("Unable to get printer status for %s - %s\n", name,
379                          ippErrorString(cupsLastError())));
380                 httpClose(http);
381                 return (0);
382         }
383
384         httpClose(http);
385
386         if (response->request.status.status_code >= IPP_OK_CONFLICT)
387         {
388                 DEBUG(3,("Unable to get printer status for %s - %s\n", name,
389                          ippErrorString(response->request.status.status_code)));
390                 ippDelete(response);
391                 return (0);
392         }
393         else
394         {
395                 ippDelete(response);
396                 return (1);
397         }
398 }
399
400
401 /*
402  * 'cups_job_delete()' - Delete a job.
403  */
404
405 static int
406 cups_job_delete(int snum, struct printjob *pjob)
407 {
408         int             ret;            /* Return value */
409         http_t          *http;          /* HTTP connection to server */
410         ipp_t           *request,       /* IPP Request */
411                         *response;      /* IPP Response */
412         cups_lang_t     *language;      /* Default language */
413         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
414
415
416         DEBUG(5,("cups_job_delete(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
417
418        /*
419         * Make sure we don't ask for passwords...
420         */
421
422         cupsSetPasswordCB(cups_passwd_cb);
423
424        /*
425         * Try to connect to the server...
426         */
427
428         if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
429         {
430                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n", 
431                          cupsServer(), strerror(errno)));
432                 return (1);
433         }
434
435        /*
436         * Build an IPP_CANCEL_JOB request, which requires the following
437         * attributes:
438         *
439         *    attributes-charset
440         *    attributes-natural-language
441         *    job-uri
442         *    requesting-user-name
443         */
444
445         request = ippNew();
446
447         request->request.op.operation_id = IPP_CANCEL_JOB;
448         request->request.op.request_id   = 1;
449
450         language = cupsLangDefault();
451
452         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
453                      "attributes-charset", NULL, cupsLangEncoding(language));
454
455         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
456                      "attributes-natural-language", NULL, language->language);
457
458         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
459
460         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
461
462         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
463                      NULL, pjob->user);
464
465        /*
466         * Do the request and get back a response...
467         */
468
469         ret = 1;
470
471         if ((response = cupsDoRequest(http, request, "/jobs")) != NULL)
472         {
473           if (response->request.status.status_code >= IPP_OK_CONFLICT)
474                 DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
475                          ippErrorString(cupsLastError())));
476           else
477                 ret = 0;
478
479           ippDelete(response);
480         }
481         else
482           DEBUG(0,("Unable to cancel job %d - %s\n", pjob->sysjob,
483                    ippErrorString(cupsLastError())));
484
485         httpClose(http);
486
487         return (ret);
488 }
489
490
491 /*
492  * 'cups_job_pause()' - Pause a job.
493  */
494
495 static int
496 cups_job_pause(int snum, struct printjob *pjob)
497 {
498         int             ret;            /* Return value */
499         http_t          *http;          /* HTTP connection to server */
500         ipp_t           *request,       /* IPP Request */
501                         *response;      /* IPP Response */
502         cups_lang_t     *language;      /* Default language */
503         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
504
505
506         DEBUG(5,("cups_job_pause(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
507
508        /*
509         * Make sure we don't ask for passwords...
510         */
511
512         cupsSetPasswordCB(cups_passwd_cb);
513
514        /*
515         * Try to connect to the server...
516         */
517
518         if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
519         {
520                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n", 
521                          cupsServer(), strerror(errno)));
522                 return (1);
523         }
524
525        /*
526         * Build an IPP_HOLD_JOB request, which requires the following
527         * attributes:
528         *
529         *    attributes-charset
530         *    attributes-natural-language
531         *    job-uri
532         *    requesting-user-name
533         */
534
535         request = ippNew();
536
537         request->request.op.operation_id = IPP_HOLD_JOB;
538         request->request.op.request_id   = 1;
539
540         language = cupsLangDefault();
541
542         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
543                      "attributes-charset", NULL, cupsLangEncoding(language));
544
545         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
546                      "attributes-natural-language", NULL, language->language);
547
548         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
549
550         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
551
552         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
553                      NULL, pjob->user);
554
555        /*
556         * Do the request and get back a response...
557         */
558
559         ret = 1;
560
561         if ((response = cupsDoRequest(http, request, "/jobs")) != NULL)
562         {
563           if (response->request.status.status_code >= IPP_OK_CONFLICT)
564                 DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
565                          ippErrorString(cupsLastError())));
566           else
567                 ret = 0;
568
569           ippDelete(response);
570         }
571         else
572           DEBUG(0,("Unable to hold job %d - %s\n", pjob->sysjob,
573                    ippErrorString(cupsLastError())));
574
575         httpClose(http);
576
577         return (ret);
578 }
579
580
581 /*
582  * 'cups_job_resume()' - Resume a paused job.
583  */
584
585 static int
586 cups_job_resume(int snum, struct printjob *pjob)
587 {
588         int             ret;            /* Return value */
589         http_t          *http;          /* HTTP connection to server */
590         ipp_t           *request,       /* IPP Request */
591                         *response;      /* IPP Response */
592         cups_lang_t     *language;      /* Default language */
593         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
594
595
596         DEBUG(5,("cups_job_resume(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
597
598        /*
599         * Make sure we don't ask for passwords...
600         */
601
602         cupsSetPasswordCB(cups_passwd_cb);
603
604        /*
605         * Try to connect to the server...
606         */
607
608         if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
609         {
610                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n", 
611                          cupsServer(), strerror(errno)));
612                 return (1);
613         }
614
615        /*
616         * Build an IPP_RELEASE_JOB request, which requires the following
617         * attributes:
618         *
619         *    attributes-charset
620         *    attributes-natural-language
621         *    job-uri
622         *    requesting-user-name
623         */
624
625         request = ippNew();
626
627         request->request.op.operation_id = IPP_RELEASE_JOB;
628         request->request.op.request_id   = 1;
629
630         language = cupsLangDefault();
631
632         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
633                      "attributes-charset", NULL, cupsLangEncoding(language));
634
635         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
636                      "attributes-natural-language", NULL, language->language);
637
638         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/jobs/%d", pjob->sysjob);
639
640         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
641
642         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
643                      NULL, pjob->user);
644
645        /*
646         * Do the request and get back a response...
647         */
648
649         ret = 1;
650
651         if ((response = cupsDoRequest(http, request, "/jobs")) != NULL)
652         {
653           if (response->request.status.status_code >= IPP_OK_CONFLICT)
654                 DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
655                          ippErrorString(cupsLastError())));
656           else
657                 ret = 0;
658
659           ippDelete(response);
660         }
661         else
662           DEBUG(0,("Unable to release job %d - %s\n", pjob->sysjob,
663                    ippErrorString(cupsLastError())));
664
665         httpClose(http);
666
667         return (ret);
668 }
669
670
671 /*
672  * 'cups_job_submit()' - Submit a job for printing.
673  */
674
675 static int
676 cups_job_submit(int snum, struct printjob *pjob)
677 {
678         int             ret;            /* Return value */
679         http_t          *http;          /* HTTP connection to server */
680         ipp_t           *request,       /* IPP Request */
681                         *response;      /* IPP Response */
682         cups_lang_t     *language;      /* Default language */
683         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
684         char            *clientname;    /* hostname of client for job-originating-host attribute */
685         pstring         new_jobname;
686
687         DEBUG(5,("cups_job_submit(%d, %p (%d))\n", snum, pjob, pjob->sysjob));
688
689        /*
690         * Make sure we don't ask for passwords...
691         */
692
693         cupsSetPasswordCB(cups_passwd_cb);
694
695        /*
696         * Try to connect to the server...
697         */
698
699         if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
700         {
701                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n", 
702                          cupsServer(), strerror(errno)));
703                 return (1);
704         }
705
706        /*
707         * Build an IPP_PRINT_JOB request, which requires the following
708         * attributes:
709         *
710         *    attributes-charset
711         *    attributes-natural-language
712         *    printer-uri
713         *    requesting-user-name
714         *    [document-data]
715         */
716
717         request = ippNew();
718
719         request->request.op.operation_id = IPP_PRINT_JOB;
720         request->request.op.request_id   = 1;
721
722         language = cupsLangDefault();
723
724         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
725                      "attributes-charset", NULL, cupsLangEncoding(language));
726
727         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
728                      "attributes-natural-language", NULL, language->language);
729
730         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
731                  PRINTERNAME(snum));
732
733         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
734                      "printer-uri", NULL, uri);
735
736         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
737                      NULL, pjob->user);
738
739         clientname = client_name();
740         if (strcmp(clientname, "UNKNOWN") == 0) {
741                 clientname = client_addr();
742         }
743
744         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
745                      "job-originating-host-name", NULL,
746                       clientname);
747
748         pstr_sprintf(new_jobname,"%s%.8u %s", PRINT_SPOOL_PREFIX, 
749                 (unsigned int)pjob->smbjob, pjob->jobname);
750
751         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
752                      new_jobname);
753
754        /*
755         * Do the request and get back a response...
756         */
757
758         slprintf(uri, sizeof(uri) - 1, "/printers/%s", PRINTERNAME(snum));
759
760         ret = 1;
761         if ((response = cupsDoFileRequest(http, request, uri,
762                                           pjob->filename)) != NULL)
763         {
764                 if (response->request.status.status_code >= IPP_OK_CONFLICT)
765                         DEBUG(0,("Unable to print file to %s - %s\n", PRINTERNAME(snum),
766                                  ippErrorString(cupsLastError())));
767                 else
768                         ret = 0;
769
770                 ippDelete(response);
771         }
772         else
773                 DEBUG(0,("Unable to print file to `%s' - %s\n", PRINTERNAME(snum),
774                          ippErrorString(cupsLastError())));
775
776         httpClose(http);
777
778         if ( ret == 0 )
779                 unlink(pjob->filename);
780         /* else print_job_end will do it for us */
781
782         return (ret);
783 }
784
785
786 /*
787  * 'cups_queue_get()' - Get all the jobs in the print queue.
788  */
789
790 static int
791 cups_queue_get(int snum, print_queue_struct **q, print_status_struct *status)
792 {
793         http_t          *http;          /* HTTP connection to server */
794         ipp_t           *request,       /* IPP Request */
795                         *response;      /* IPP Response */
796         ipp_attribute_t *attr;          /* Current attribute */
797         cups_lang_t     *language;      /* Default language */
798         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
799         int             qcount,         /* Number of active queue entries */
800                         qalloc;         /* Number of queue entries allocated */
801         print_queue_struct *queue,      /* Queue entries */
802                         *temp;          /* Temporary pointer for queue */
803         const char      *user_name,     /* job-originating-user-name attribute */
804                         *job_name;      /* job-name attribute */
805         int             job_id;         /* job-id attribute */
806         int             job_k_octets;   /* job-k-octets attribute */
807         time_t          job_time;       /* time-at-creation attribute */
808         ipp_jstate_t    job_status;     /* job-status attribute */
809         int             job_priority;   /* job-priority attribute */
810         static const char *jattrs[] =   /* Requested job attributes */
811                         {
812                           "job-id",
813                           "job-k-octets",
814                           "job-name",
815                           "job-originating-user-name",
816                           "job-priority",
817                           "job-state",
818                           "time-at-creation",
819                         };
820         static const char *pattrs[] =   /* Requested printer attributes */
821                         {
822                           "printer-state",
823                           "printer-state-message"
824                         };
825
826
827         DEBUG(5,("cups_queue_get(%d, %p, %p)\n", snum, q, status));
828
829        /*
830         * Make sure we don't ask for passwords...
831         */
832
833         cupsSetPasswordCB(cups_passwd_cb);
834
835        /*
836         * Try to connect to the server...
837         */
838
839         if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
840         {
841                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n", 
842                          cupsServer(), strerror(errno)));
843                 return (0);
844         }
845
846        /*
847         * Generate the printer URI...
848         */
849
850         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
851                  PRINTERNAME(snum));
852
853        /*
854         * Build an IPP_GET_JOBS request, which requires the following
855         * attributes:
856         *
857         *    attributes-charset
858         *    attributes-natural-language
859         *    requested-attributes
860         *    printer-uri
861         */
862
863         request = ippNew();
864
865         request->request.op.operation_id = IPP_GET_JOBS;
866         request->request.op.request_id   = 1;
867
868         language = cupsLangDefault();
869
870         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
871                      "attributes-charset", NULL, cupsLangEncoding(language));
872
873         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
874                      "attributes-natural-language", NULL, language->language);
875
876         ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
877                       "requested-attributes",
878                       (sizeof(jattrs) / sizeof(jattrs[0])),
879                       NULL, jattrs);
880
881         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
882                      "printer-uri", NULL, uri);
883
884        /*
885         * Do the request and get back a response...
886         */
887
888         if ((response = cupsDoRequest(http, request, "/")) == NULL)
889         {
890                 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
891                          ippErrorString(cupsLastError())));
892                 httpClose(http);
893                 return (0);
894         }
895
896         if (response->request.status.status_code >= IPP_OK_CONFLICT)
897         {
898                 DEBUG(0,("Unable to get jobs for %s - %s\n", uri,
899                          ippErrorString(response->request.status.status_code)));
900                 ippDelete(response);
901                 httpClose(http);
902
903                 return (0);
904         }
905
906        /*
907         * Process the jobs...
908         */
909
910         qcount = 0;
911         qalloc = 0;
912         queue  = NULL;
913
914         for (attr = response->attrs; attr != NULL; attr = attr->next)
915         {
916                /*
917                 * Skip leading attributes until we hit a job...
918                 */
919
920                 while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
921                         attr = attr->next;
922
923                 if (attr == NULL)
924                         break;
925
926                /*
927                 * Allocate memory as needed...
928                 */
929                 if (qcount >= qalloc)
930                 {
931                         qalloc += 16;
932
933                         temp = Realloc(queue, sizeof(print_queue_struct) * qalloc);
934
935                         if (temp == NULL)
936                         {
937                                 DEBUG(0,("cups_queue_get: Not enough memory!"));
938                                 ippDelete(response);
939                                 httpClose(http);
940
941                                 SAFE_FREE(queue);
942                                 return (0);
943                         }
944
945                         queue = temp;
946                 }
947
948                 temp = queue + qcount;
949                 memset(temp, 0, sizeof(print_queue_struct));
950
951                /*
952                 * Pull the needed attributes from this job...
953                 */
954
955                 job_id       = 0;
956                 job_priority = 50;
957                 job_status   = IPP_JOB_PENDING;
958                 job_time     = 0;
959                 job_k_octets = 0;
960                 user_name    = NULL;
961                 job_name     = NULL;
962
963                 while (attr != NULL && attr->group_tag == IPP_TAG_JOB)
964                 {
965                         if (attr->name == NULL)
966                         {
967                                 attr = attr->next;
968                                 break;
969                         }
970
971                         if (strcmp(attr->name, "job-id") == 0 &&
972                             attr->value_tag == IPP_TAG_INTEGER)
973                                 job_id = attr->values[0].integer;
974
975                         if (strcmp(attr->name, "job-k-octets") == 0 &&
976                             attr->value_tag == IPP_TAG_INTEGER)
977                                 job_k_octets = attr->values[0].integer;
978
979                         if (strcmp(attr->name, "job-priority") == 0 &&
980                             attr->value_tag == IPP_TAG_INTEGER)
981                                 job_priority = attr->values[0].integer;
982
983                         if (strcmp(attr->name, "job-state") == 0 &&
984                             attr->value_tag == IPP_TAG_ENUM)
985                                 job_status = (ipp_jstate_t)(attr->values[0].integer);
986
987                         if (strcmp(attr->name, "time-at-creation") == 0 &&
988                             attr->value_tag == IPP_TAG_INTEGER)
989                                 job_time = attr->values[0].integer;
990
991                         if (strcmp(attr->name, "job-name") == 0 &&
992                             attr->value_tag == IPP_TAG_NAME)
993                                 job_name = attr->values[0].string.text;
994
995                         if (strcmp(attr->name, "job-originating-user-name") == 0 &&
996                             attr->value_tag == IPP_TAG_NAME)
997                                 user_name = attr->values[0].string.text;
998
999                         attr = attr->next;
1000                 }
1001
1002                /*
1003                 * See if we have everything needed...
1004                 */
1005
1006                 if (user_name == NULL || job_name == NULL || job_id == 0)
1007                 {
1008                   if (attr == NULL)
1009                     break;
1010                   else
1011                     continue;
1012                 }
1013
1014                 temp->job      = job_id;
1015                 temp->size     = job_k_octets * 1024;
1016                 temp->status   = job_status == IPP_JOB_PENDING ? LPQ_QUEUED :
1017                                  job_status == IPP_JOB_STOPPED ? LPQ_PAUSED :
1018                                  job_status == IPP_JOB_HELD ? LPQ_PAUSED :
1019                                  LPQ_PRINTING;
1020                 temp->priority = job_priority;
1021                 temp->time     = job_time;
1022                 strncpy(temp->fs_user, user_name, sizeof(temp->fs_user) - 1);
1023                 strncpy(temp->fs_file, job_name, sizeof(temp->fs_file) - 1);
1024
1025                 qcount ++;
1026
1027                 if (attr == NULL)
1028                   break;
1029         }
1030
1031         ippDelete(response);
1032
1033        /*
1034         * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the
1035         * following attributes:
1036         *
1037         *    attributes-charset
1038         *    attributes-natural-language
1039         *    requested-attributes
1040         *    printer-uri
1041         */
1042
1043         request = ippNew();
1044
1045         request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
1046         request->request.op.request_id   = 1;
1047
1048         language = cupsLangDefault();
1049
1050         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1051                      "attributes-charset", NULL, cupsLangEncoding(language));
1052
1053         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1054                      "attributes-natural-language", NULL, language->language);
1055
1056         ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1057                       "requested-attributes",
1058                       (sizeof(pattrs) / sizeof(pattrs[0])),
1059                       NULL, pattrs);
1060
1061         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
1062                      "printer-uri", NULL, uri);
1063
1064        /*
1065         * Do the request and get back a response...
1066         */
1067
1068         if ((response = cupsDoRequest(http, request, "/")) == NULL)
1069         {
1070                 DEBUG(0,("Unable to get printer status for %s - %s\n", PRINTERNAME(snum),
1071                          ippErrorString(cupsLastError())));
1072                 httpClose(http);
1073                 *q = queue;
1074                 return (qcount);
1075         }
1076
1077         if (response->request.status.status_code >= IPP_OK_CONFLICT)
1078         {
1079                 DEBUG(0,("Unable to get printer status for %s - %s\n", PRINTERNAME(snum),
1080                          ippErrorString(response->request.status.status_code)));
1081                 ippDelete(response);
1082                 httpClose(http);
1083                 *q = queue;
1084                 return (qcount);
1085         }
1086
1087        /*
1088         * Get the current printer status and convert it to the SAMBA values.
1089         */
1090
1091         if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL)
1092         {
1093                 if (attr->values[0].integer == IPP_PRINTER_STOPPED)
1094                         status->status = LPSTAT_STOPPED;
1095                 else
1096                         status->status = LPSTAT_OK;
1097         }
1098
1099         if ((attr = ippFindAttribute(response, "printer-state-message",
1100                                      IPP_TAG_TEXT)) != NULL)
1101                 fstrcpy(status->message, attr->values[0].string.text);
1102
1103         ippDelete(response);
1104
1105        /*
1106         * Return the job queue...
1107         */
1108
1109         httpClose(http);
1110
1111         *q = queue;
1112         return (qcount);
1113 }
1114
1115
1116 /*
1117  * 'cups_queue_pause()' - Pause a print queue.
1118  */
1119
1120 static int
1121 cups_queue_pause(int snum)
1122 {
1123         extern userdom_struct current_user_info;
1124         int             ret;            /* Return value */
1125         http_t          *http;          /* HTTP connection to server */
1126         ipp_t           *request,       /* IPP Request */
1127                         *response;      /* IPP Response */
1128         cups_lang_t     *language;      /* Default language */
1129         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
1130
1131
1132         DEBUG(5,("cups_queue_pause(%d)\n", snum));
1133
1134         /*
1135          * Make sure we don't ask for passwords...
1136          */
1137
1138         cupsSetPasswordCB(cups_passwd_cb);
1139
1140         /*
1141          * Try to connect to the server...
1142          */
1143
1144         if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
1145         {
1146                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n", 
1147                          cupsServer(), strerror(errno)));
1148                 return (1);
1149         }
1150
1151         /*
1152          * Build an IPP_PAUSE_PRINTER request, which requires the following
1153          * attributes:
1154          *
1155          *    attributes-charset
1156          *    attributes-natural-language
1157          *    printer-uri
1158          *    requesting-user-name
1159          */
1160
1161         request = ippNew();
1162
1163         request->request.op.operation_id = IPP_PAUSE_PRINTER;
1164         request->request.op.request_id   = 1;
1165
1166         language = cupsLangDefault();
1167
1168         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1169                      "attributes-charset", NULL, cupsLangEncoding(language));
1170
1171         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1172                      "attributes-natural-language", NULL, language->language);
1173
1174         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
1175                  PRINTERNAME(snum));
1176
1177         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1178
1179         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1180                      NULL, current_user_info.unix_name);
1181
1182        /*
1183         * Do the request and get back a response...
1184         */
1185
1186         ret = 1;
1187
1188         if ((response = cupsDoRequest(http, request, "/admin/")) != NULL)
1189         {
1190           if (response->request.status.status_code >= IPP_OK_CONFLICT)
1191                 DEBUG(0,("Unable to pause printer %s - %s\n", PRINTERNAME(snum),
1192                          ippErrorString(cupsLastError())));
1193           else
1194                 ret = 0;
1195
1196           ippDelete(response);
1197         }
1198         else
1199           DEBUG(0,("Unable to pause printer %s - %s\n", PRINTERNAME(snum),
1200                    ippErrorString(cupsLastError())));
1201
1202         httpClose(http);
1203
1204         return (ret);
1205 }
1206
1207
1208 /*
1209  * 'cups_queue_resume()' - Restart a print queue.
1210  */
1211
1212 static int
1213 cups_queue_resume(int snum)
1214 {
1215         extern userdom_struct current_user_info;
1216         int             ret;            /* Return value */
1217         http_t          *http;          /* HTTP connection to server */
1218         ipp_t           *request,       /* IPP Request */
1219                         *response;      /* IPP Response */
1220         cups_lang_t     *language;      /* Default language */
1221         char            uri[HTTP_MAX_URI]; /* printer-uri attribute */
1222
1223
1224         DEBUG(5,("cups_queue_resume(%d)\n", snum));
1225
1226        /*
1227         * Make sure we don't ask for passwords...
1228         */
1229
1230         cupsSetPasswordCB(cups_passwd_cb);
1231
1232        /*
1233         * Try to connect to the server...
1234         */
1235
1236         if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
1237         {
1238                 DEBUG(0,("Unable to connect to CUPS server %s - %s\n", 
1239                          cupsServer(), strerror(errno)));
1240                 return (1);
1241         }
1242
1243        /*
1244         * Build an IPP_RESUME_PRINTER request, which requires the following
1245         * attributes:
1246         *
1247         *    attributes-charset
1248         *    attributes-natural-language
1249         *    printer-uri
1250         *    requesting-user-name
1251         */
1252
1253         request = ippNew();
1254
1255         request->request.op.operation_id = IPP_RESUME_PRINTER;
1256         request->request.op.request_id   = 1;
1257
1258         language = cupsLangDefault();
1259
1260         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1261                      "attributes-charset", NULL, cupsLangEncoding(language));
1262
1263         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1264                      "attributes-natural-language", NULL, language->language);
1265
1266         slprintf(uri, sizeof(uri) - 1, "ipp://localhost/printers/%s",
1267                  PRINTERNAME(snum));
1268
1269         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
1270
1271         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1272                      NULL, current_user_info.unix_name);
1273
1274        /*
1275         * Do the request and get back a response...
1276         */
1277
1278         ret = 1;
1279
1280         if ((response = cupsDoRequest(http, request, "/admin/")) != NULL)
1281         {
1282           if (response->request.status.status_code >= IPP_OK_CONFLICT)
1283                 DEBUG(0,("Unable to resume printer %s - %s\n", PRINTERNAME(snum),
1284                          ippErrorString(cupsLastError())));
1285           else
1286                 ret = 0;
1287
1288           ippDelete(response);
1289         }
1290         else
1291           DEBUG(0,("Unable to resume printer %s - %s\n", PRINTERNAME(snum),
1292                    ippErrorString(cupsLastError())));
1293
1294         httpClose(http);
1295
1296         return (ret);
1297 }
1298
1299
1300 #else
1301  /* this keeps fussy compilers happy */
1302  void print_cups_dummy(void) {}
1303 #endif /* HAVE_CUPS */