1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  * Copyright (C) 2016 Mopria Alliance, Inc.
4  * Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *      http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 
19 #include <stdint.h>
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include "lib_wprint.h"
23 #include "ippstatus_capabilities.h"   // move these to above the calls to cups files
24 #include "ipphelper.h"
25 #include "cups.h"
26 #include "http-private.h"
27 #include "wprint_debug.h"
28 
29 #define TAG "ippstatus_capabilities"
30 
31 /*
32  * Requested printer attributes
33  */
34 static const char *pattrs[] = {
35         "ipp-versions-supported",
36         "printer-make-and-model",
37         "printer-info",
38         "printer-dns-sd-name",
39         "printer-name",
40         "printer-location",
41         "printer-uuid",
42         "printer-uri-supported",
43         "uri-security-supported",
44         "uri-authentication-supported",
45         "color-supported",
46         "copies-supported",
47         "document-format-supported",
48         "media-col-default",
49         "media-default",
50         "media-left-margin-supported",
51         "media-right-margin-supported",
52         "media-top-margin-supported",
53         "media-bottom-margin-supported",
54         "media-supported",
55         "media-type-supported",
56         "output-bin-supported",
57         "print-color-mode-supported",
58         "print-quality-supported",
59         "printer-output-tray",
60         "printer-resolution-supported",
61         "sides-supported",
62         "printer-device-id",
63         "epcl-version-supported",
64         "pclm-raster-back-side",
65         "pclm-strip-height-preferred",
66         "pclm-compression-method-preferred",
67         "pclm-source-resolution-supported",
68         "pwg-raster-document-sheet-back",
69         "document-format-details-supported",
70         "media-ready",
71         "media-col-ready",
72         "print-scaling-supported",
73         "print-scaling-default",
74         "job-pages-per-set-supported",
75         "mopria-certified",
76         "mopria_certified"
77 };
78 
79 static void _init(const ifc_printer_capabilities_t *this_p,
80         const wprint_connect_info_t *info);
81 
82 static status_t _get_capabilities(const ifc_printer_capabilities_t *this_p,
83         printer_capabilities_t *capabilities);
84 
85 static void _destroy(const ifc_printer_capabilities_t *this_p);
86 
87 static ifc_printer_capabilities_t _capabilities_ifc = {
88         .init = _init, .get_capabilities = _get_capabilities, .get_margins = NULL,
89         .destroy = _destroy,
90 };
91 
92 typedef struct {
93     http_t *http;
94     printer_capabilities_t printer_caps;
95     ifc_printer_capabilities_t ifc;
96 } ipp_capabilities_t;
97 
ipp_status_get_capabilities_ifc(const ifc_wprint_t * wprint_ifc)98 const ifc_printer_capabilities_t *ipp_status_get_capabilities_ifc(const ifc_wprint_t *wprint_ifc) {
99     LOGD("ipp_status_get_capabilities_ifc: Enter");
100     ipp_capabilities_t *caps = (ipp_capabilities_t *) malloc(sizeof(ipp_capabilities_t));
101     if (caps == NULL) {
102         return NULL;
103     }
104 
105     memset(caps, 0, sizeof(ipp_capabilities_t));
106     caps->http = NULL;
107 
108     memcpy(&caps->ifc, &_capabilities_ifc, sizeof(ifc_printer_capabilities_t));
109     return &caps->ifc;
110 }
111 
_init(const ifc_printer_capabilities_t * this_p,const wprint_connect_info_t * connect_info)112 static void _init(const ifc_printer_capabilities_t *this_p,
113         const wprint_connect_info_t *connect_info) {
114     LOGD("_init: Enter");
115     ipp_capabilities_t *caps;
116     do {
117         if (this_p == NULL) {
118             continue;
119         }
120         caps = IMPL(ipp_capabilities_t, ifc, this_p);
121 
122         if (caps->http != NULL) {
123             LOGD("_init(): http != NULL closing HTTP");
124             httpClose(caps->http);
125         }
126 
127         caps->http = ipp_cups_connect(connect_info, caps->printer_caps.printerUri,
128                 sizeof(caps->printer_caps.printerUri));
129         getResourceFromURI(caps->printer_caps.printerUri, caps->printer_caps.httpResource, 1024);
130         if (caps->http == NULL) {
131             LOGE("_init(): http is NULL ");
132         }
133     } while (0);
134 }
135 
_get_capabilities(const ifc_printer_capabilities_t * this_p,printer_capabilities_t * capabilities)136 static status_t _get_capabilities(const ifc_printer_capabilities_t *this_p,
137         printer_capabilities_t *capabilities) {
138     LOGD("_get_capabilities: Enter");
139     status_t result = ERROR;
140     ipp_capabilities_t *caps = NULL;
141     ipp_t *request = NULL; // IPP request object
142     ipp_t *response = NULL; // IPP response object
143     ipp_attribute_t *attrptr; // Attribute pointer
144     int op = IPP_GET_PRINTER_ATTRIBUTES;
145 
146     ipp_status_t ipp_status; // Status of IPP request
147 
148     if (capabilities != NULL) {
149         memset(capabilities, 0, sizeof(printer_capabilities_t));
150     }
151 
152     do {
153         if (this_p == NULL) {
154             break;
155         }
156 
157         caps = IMPL(ipp_capabilities_t, ifc, this_p);
158         if (caps->http == NULL) {
159             LOGD("_get_capabilities: caps->http is NULL");
160             break;
161         }
162 
163         request = ippNewRequest(op);
164 
165         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
166                 caps->printer_caps.printerUri);
167 
168         ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "requested-attributes",
169                 sizeof(pattrs) / sizeof(pattrs[0]), NULL, pattrs);
170 
171         LOGD("IPP_GET_PRINTER_ATTRIBUTES %s request:", ippOpString(op));
172         for (attrptr = ippFirstAttribute(request); attrptr; attrptr = ippNextAttribute(request)) {
173             print_attr(attrptr);
174         }
175 
176         response = ipp_doCupsRequest(caps->http, request, caps->printer_caps.httpResource,
177                 caps->printer_caps.printerUri);
178         if (response == NULL) {
179             ipp_status = cupsLastError();
180             LOGE("_get_capabilities: %s response is null:  ipp_status %d %s",
181                     caps->printer_caps.printerUri, ipp_status, ippErrorString(ipp_status));
182         } else {
183             ipp_status = cupsLastError();
184             LOGD("ipp CUPS last ERROR: %d, %s", ipp_status, ippErrorString(ipp_status));
185             LOGD("%s received, now call parse_printerAttributes:", ippOpString(op));
186             parse_printerAttributes(response, capabilities);
187 
188 #if LOG_LEVEL <= LEVEL_DEBUG
189             for (attrptr = ippFirstAttribute(response); attrptr; attrptr = ippNextAttribute(
190                     response)) {
191                 print_attr(attrptr);
192             }
193 #endif // LOG_LEVEL <= LEVEL_DEBUG
194             if ((attrptr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) == NULL) {
195                 LOGD("printer-state: null");
196             } else {
197                 LOGI("printer-state %d", (ipp_pstate_t) ippGetInteger(attrptr, 0));
198             }
199         }
200 
201         if (ipp_status >= IPP_OK && ipp_status < IPP_REDIRECTION_OTHER_SITE && response != NULL) {
202             result = OK;
203         } else {
204             result = ERROR;
205         }
206     } while (0);
207 
208     ippDelete(response);
209     ippDelete(request);
210 
211     if ((caps != NULL) && (capabilities != NULL)) {
212         memcpy(capabilities->httpResource, caps->printer_caps.httpResource,
213                 sizeof(capabilities->httpResource));
214     }
215 
216     LOGI(" ippstatus_capabilities: _get_capabilities: returning %d:", result);
217     return result;
218 }
219 
_destroy(const ifc_printer_capabilities_t * this_p)220 static void _destroy(const ifc_printer_capabilities_t *this_p) {
221     ipp_capabilities_t *caps;
222     LOGD("_destroy(): enter");
223     do {
224         if (this_p == NULL) {
225             continue;
226         }
227 
228         caps = IMPL(ipp_capabilities_t, ifc, this_p);
229         if (caps->http != NULL) {
230             httpClose(caps->http);
231         }
232         free(caps);
233     } while (0);
234 }