1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifdef IPPOVERUSB_ENABLE
17 #include "print_usb_manager.h"
18 #include "print_log.h"
19 #include "usb_errors.h"
20 #include "print_ipp_over_usb_util.h"
21 #include "cJSON.h"
22 
23 namespace OHOS::Print {
24 using namespace OHOS;
25 using namespace OHOS::USB;
26 
PrintUsbManager()27 PrintUsbManager::PrintUsbManager()
28 {}
29 
~PrintUsbManager()30 PrintUsbManager::~PrintUsbManager()
31 {}
32 
Init()33 void PrintUsbManager::Init()
34 {
35     if (isInit) {
36         PRINT_HILOGD("has init");
37     }
38     isInit = true;
39     RefreshUsbPrinterDevice();
40 }
41 
isExistIppOverUsbPrinter(std::string printerName)42 bool PrintUsbManager::isExistIppOverUsbPrinter(std::string printerName)
43 {
44     PRINT_HILOGD("isExistIppOverUsbPrinter printerName = %{public}s", printerName.c_str());
45     if (!printerName.empty() && printDeviceMap.find(printerName) != printDeviceMap.end()) {
46         return true;
47     }
48     return false;
49 }
50 
51 
isPrintDevice(USB::UsbDevice & usbdevice,std::string & printerName)52 bool PrintUsbManager::isPrintDevice(USB::UsbDevice &usbdevice, std::string &printerName)
53 {
54     int32_t configCount = usbdevice.GetConfigCount();
55     std::vector<std::pair<int32_t, int32_t>> indexVec;
56     int32_t ippusbInterfaceCount = 0;
57     PRINT_HILOGD("name = %{public}s.", usbdevice.GetName().c_str());
58     for (int32_t configIndex = 0; configIndex < configCount; configIndex++) {
59         int32_t interfaceCount = static_cast<int32_t>(usbdevice.GetConfigs()[configIndex].GetInterfaceCount());
60         PRINT_HILOGD("configIndex = %{public}d.", configIndex);
61         for (int32_t interfaceIndex = 0; interfaceIndex < interfaceCount; interfaceIndex++) {
62             PRINT_HILOGD("interfaceIndex = %{public}d.", interfaceIndex);
63             UsbInterface usbInterface = usbdevice.GetConfigs()[configIndex].GetInterfaces()[interfaceIndex];
64             PRINT_HILOGD("isPrintDevice class = %{public}d, subclass = %{public}d, protocol = %{public}d",
65                 usbInterface.GetClass(), usbInterface.GetSubClass(), usbInterface.GetProtocol());
66             bool isSupportIpp = (usbInterface.GetClass() == USB_DEVICE_CLASS_PRINT &&
67                 usbInterface.GetSubClass() == USB_DEVICE_SUBCLASS_PRINT &&
68                 usbInterface.GetProtocol() == USB_DEVICE_PROTOCOL_PRINT);
69             if (isSupportIpp) {
70                 auto indexPair = std::make_pair(configIndex, interfaceIndex);
71                 indexVec.push_back(indexPair);
72                 ippusbInterfaceCount++;
73             }
74         }
75     }
76     // Two or more interfaces are required
77     if (ippusbInterfaceCount >= USB_INTERFACE_MIN_COUNT) {
78         printerName = GetProductName(usbdevice);
79         PRINT_HILOGI("support IppPrint printerName = %{public}s.", printerName.c_str());
80         if (printerName.empty()) {
81             return false;
82         }
83         printerIndexMap[printerName] = indexVec;
84         return true;
85     }
86     return false;
87 }
88 
RefreshUsbPrinterDevice()89 void PrintUsbManager::RefreshUsbPrinterDevice()
90 {
91     std::vector<UsbDevice> devlist;
92     int32_t ret = ERR_OK;
93     if (isUsbEnable) {
94         ret = UsbSrvClient::GetInstance().GetDevices(devlist);
95     }
96     if (ERR_OK != ret) {
97         PRINT_HILOGE("RefreshDeviceList GetDevices failed with ret = %{public}d.", ret);
98         return;
99     } else if (devlist.empty()) {
100         PRINT_HILOGE("RefreshDeviceList GetDevices empty with ret = %{public}d.", ret);
101         return;
102     }
103     for (auto dev : devlist) {
104         std::string printerName;
105         if (isPrintDevice(dev, printerName)) {
106             printDeviceMap[printerName] = dev;
107         }
108     }
109 }
110 
GetProductName(UsbDevice & usbDevice)111 std::string PrintUsbManager::GetProductName(UsbDevice &usbDevice)
112 {
113     USBDevicePipe usbDevicePipe;
114     int32_t openDeviceRet = UEC_OK;
115     if (isUsbEnable) {
116         openDeviceRet = UsbSrvClient::GetInstance().OpenDevice(usbDevice, usbDevicePipe);
117     }
118     PRINT_HILOGI("openDevice ret = %{public}d", openDeviceRet);
119     if (openDeviceRet != UEC_OK) {
120         PRINT_HILOGE("openDevice fail with ret = %{public}d", openDeviceRet);
121         return "";
122     }
123     std::string productName =
124         QueryPrinterInfoFromStringDescriptor(usbDevicePipe, USB_VALUE_DESCRIPTOR_INDEX_PRODUCT_NAME);
125     std::string serialNumber =
126         QueryPrinterInfoFromStringDescriptor(usbDevicePipe, USB_VALUE_DESCRIPTOR_INDEX_SERIAL_NUMBER);
127     size_t len = serialNumber.length();
128     if (len > HTTP_COMMON_CONST_VALUE_4) {
129         serialNumber = serialNumber.substr(len - HTTP_COMMON_CONST_VALUE_4);
130     }
131     std::string printerName = productName + "-" + serialNumber;
132     PRINT_HILOGI("getProductName printerName = %{public}s.", printerName.c_str());
133     return printerName;
134 }
135 
QueryPrinterInfoFromStringDescriptor(USBDevicePipe & usbDevicePipe,uint16_t indexInStringDescriptor)136 std::string PrintUsbManager::QueryPrinterInfoFromStringDescriptor(
137     USBDevicePipe &usbDevicePipe, uint16_t indexInStringDescriptor)
138 {
139     PRINT_HILOGI("enter QueryPrinterInfoFromStringDescriptor");
140     uint8_t requestType = USB_REQUESTTYPE_DEVICE_TO_HOST;
141     uint8_t request = USB_REQUEST_GET_DESCRIPTOR;
142     uint16_t value = (USB_VALUE_DESCRIPTOR_TYPE_STRING << HTTP_COMMON_CONST_VALUE_8) | indexInStringDescriptor;
143     uint16_t index = USB_INDEX_LANGUAGE_ID_ENGLISH;
144     int32_t timeOut = HTTP_COMMON_CONST_VALUE_500;
145     const HDI::Usb::V1_0::UsbCtrlTransfer tctrl = {requestType, request, value, index, timeOut};
146     std::vector<uint8_t> bufferData(USB_CONTROLTRANSFER_READ_TIMEOUT, 0);
147     int32_t ret = 0;
148     if (isUsbEnable) {
149         ret = UsbSrvClient::GetInstance().ControlTransfer(usbDevicePipe, tctrl, bufferData);
150     }
151     if (ret != 0 || bufferData[INDEX_0] == 0 ||
152         ((bufferData[INDEX_0] - HTTP_COMMON_CONST_VALUE_2) / HTTP_COMMON_CONST_VALUE_2) < 0) {
153         PRINT_HILOGE("ControlTransfer failed ret = %{public}d, buffer length = %{public}d", ret, bufferData[0]);
154         return "";
155     }
156 
157     std::vector<uint8_t> arr((bufferData[INDEX_0] - HTTP_COMMON_CONST_VALUE_2) / HTTP_COMMON_CONST_VALUE_2);
158     int arrIndex = 0;
159     for (int i = INDEX_2; i < bufferData[INDEX_0];) {
160         arr[arrIndex++] = bufferData[i];
161         i += HTTP_COMMON_CONST_VALUE_2;
162     }
163     std::string printerInfo(arr.begin(), arr.end());
164     PRINT_HILOGI("bufferData printerInfo: %{public}s\n", printerInfo.c_str());
165     return printerInfo;
166 }
167 
AllocateInterface(const std::string & printerName,UsbDevice & usbdevice,USBDevicePipe & usbDevicePipe)168 bool PrintUsbManager::AllocateInterface(const std::string &printerName, UsbDevice &usbdevice,
169     USBDevicePipe &usbDevicePipe)
170 {
171     PrinterTranIndex tranIndex;
172     for (auto index : printerIndexMap[printerName]) {
173         int32_t configIndex = index.first;
174         int32_t interfaceIndex = index.second;
175         UsbInterface ippInterface =
176             usbdevice.GetConfigs()[configIndex].GetInterfaces()[interfaceIndex];
177         int32_t ret = UEC_OK;
178         if (isUsbEnable) {
179             ret = UsbSrvClient::GetInstance().ClaimInterface(usbDevicePipe, ippInterface, true);
180         }
181         if (ret != UEC_OK) {
182             PRINT_HILOGE("ClaimInterface fail, ret = %{public}d", ret);
183             continue;
184         }
185         if (tranIndex.commonConfigIndex == INVAILD_VALUE) {
186             tranIndex.commonConfigIndex = configIndex;
187             tranIndex.commonInterfaceIndex = interfaceIndex;
188         } else if (tranIndex.sendDocConfigIndex == INVAILD_VALUE) {
189             tranIndex.sendDocConfigIndex = configIndex;
190             tranIndex.sendDocInterfaceIndex = interfaceIndex;
191             break;
192         }
193     }
194     if (tranIndex.commonConfigIndex == INVAILD_VALUE || tranIndex.sendDocConfigIndex == INVAILD_VALUE) {
195         PRINT_HILOGE("connect usb printerName = %{public}s fail!", printerName.c_str());
196         if (tranIndex.commonConfigIndex != INVAILD_VALUE) {
197             int32_t configIndex = tranIndex.commonConfigIndex;
198             UsbInterface commonInterface =
199                 usbdevice.GetConfigs()[configIndex].GetInterfaces()[tranIndex.commonInterfaceIndex];
200             if (isUsbEnable) {
201                 UsbSrvClient::GetInstance().ReleaseInterface(usbDevicePipe, commonInterface);
202             }
203         }
204         if (isUsbEnable) {
205             UsbSrvClient::GetInstance().Close(usbDevicePipe);
206         }
207         return false;
208     }
209 
210     printPipeMap[printerName] = usbDevicePipe;
211     printTranIndexMap[printerName] = tranIndex;
212     return true;
213 }
214 
ConnectUsbPinter(const std::string & printerName)215 bool PrintUsbManager::ConnectUsbPinter(const std::string &printerName)
216 {
217     PRINT_HILOGD("connect usb printerName = %{public}s", printerName.c_str());
218     if (!printerName.empty() && printPipeMap.find(printerName) != printPipeMap.end()) {
219         PRINT_HILOGD("printerName = %{public}s is opened", printerName.c_str());
220         return true;
221     }
222     if (!printerName.empty() && printDeviceMap.find(printerName) != printDeviceMap.end()) {
223         UsbDevice usbdevice = printDeviceMap[printerName];
224         USBDevicePipe usbDevicePipe;
225         int32_t openDeviceRet = UEC_OK;
226         if (isUsbEnable) {
227             openDeviceRet = UsbSrvClient::GetInstance().OpenDevice(usbdevice, usbDevicePipe);
228         }
229         PRINT_HILOGD("openDevice ret = %{public}d", openDeviceRet);
230         if (openDeviceRet == UEC_OK) {
231             return AllocateInterface(printerName, usbdevice, usbDevicePipe);
232         } else {
233             PRINT_HILOGE("ipp usb openDevice fail with ret = %{public}d", openDeviceRet);
234             return false;
235         }
236     }
237     return false;
238 }
239 
DisConnectUsbPinter(const std::string & printerName)240 void PrintUsbManager::DisConnectUsbPinter(const std::string &printerName)
241 {
242     if (!printerName.empty() && printDeviceMap.find(printerName) != printDeviceMap.end() &&
243         printPipeMap.find(printerName) != printPipeMap.end() &&
244         printTranIndexMap.find(printerName) != printTranIndexMap.end()) {
245         UsbDevice usbdevice = printDeviceMap[printerName];
246         USBDevicePipe usbDevicePipe = printPipeMap[printerName];
247         PrinterTranIndex tranIndex = printTranIndexMap[printerName];
248         UsbInterface commonInterface =
249             usbdevice.GetConfigs()[tranIndex.commonConfigIndex].GetInterfaces()[tranIndex.commonInterfaceIndex];
250         UsbInterface sendDocIterface =
251             usbdevice.GetConfigs()[tranIndex.sendDocConfigIndex].GetInterfaces()[tranIndex.sendDocInterfaceIndex];
252         if (isUsbEnable) {
253             UsbSrvClient::GetInstance().ReleaseInterface(usbDevicePipe, commonInterface);
254             UsbSrvClient::GetInstance().ReleaseInterface(usbDevicePipe, sendDocIterface);
255             UsbSrvClient::GetInstance().Close(usbDevicePipe);
256         }
257         printPipeMap.erase(printerName);
258         printTranIndexMap.erase(printerName);
259     }
260 }
261 
BulkTransferWrite(std::string printerName,const Operation operation,std::vector<uint8_t> & vectorRequestBuffer)262 int32_t PrintUsbManager::BulkTransferWrite(std::string printerName, const Operation operation,
263     std::vector<uint8_t> &vectorRequestBuffer)
264 {
265     if (printDeviceMap.find(printerName) == printDeviceMap.end()) {
266         return INVAILD_VALUE;
267     }
268     UsbDevice usbdevice = printDeviceMap[printerName];
269     int32_t currentConfigIndex = INVAILD_VALUE;
270     int32_t currentInterfaceIndex = INVAILD_VALUE;
271     PrinterTranIndex tranIndex = printTranIndexMap[printerName];
272     if (operation == Operation::Send_Document) {
273         currentConfigIndex = tranIndex.sendDocConfigIndex;
274         currentInterfaceIndex = tranIndex.sendDocInterfaceIndex;
275     } else {
276         currentConfigIndex = tranIndex.commonConfigIndex;
277         currentInterfaceIndex = tranIndex.commonInterfaceIndex;
278     }
279     UsbInterface useInterface = usbdevice.GetConfigs()[currentConfigIndex].GetInterfaces()[currentInterfaceIndex];
280     USBEndpoint point1 = useInterface.GetEndpoints().at(INDEX_0);
281     USBEndpoint point2 = useInterface.GetEndpoints().at(INDEX_1);
282     USBEndpoint pointWrite;
283     if (point1.GetDirection() == 0) {
284         pointWrite = point1;
285     } else {
286         pointWrite = point2;
287     }
288     USBDevicePipe usbDevicePipe = printPipeMap[printerName];
289     int32_t writeRet = 0;
290     int32_t claimRetryCount = 0;
291     if (isUsbEnable) {
292         do {
293             writeRet = UsbSrvClient::GetInstance().BulkTransfer(usbDevicePipe, pointWrite, vectorRequestBuffer,
294                 USB_BULKTRANSFER_WRITE_TIMEOUT);
295         } while (writeRet == EORROR_HDF_DEV_ERR_IO_FAILURE &&
296             UsbSrvClient::GetInstance().ClaimInterface(usbDevicePipe, useInterface, true) >= 0 &&
297             claimRetryCount++ < CLAIM_INTERFACE_RETRY_MAX_TIMES);
298     }
299     return writeRet;
300 }
301 
BulkTransferRead(std::string printerName,const Operation operation,std::vector<uint8_t> & readTempBUffer)302 int32_t PrintUsbManager::BulkTransferRead(std::string printerName, const Operation operation,
303     std::vector<uint8_t> &readTempBUffer)
304 {
305     if (printDeviceMap.find(printerName) == printDeviceMap.end()) {
306         return INVAILD_VALUE;
307     }
308     UsbDevice usbdevice = printDeviceMap[printerName];
309     int32_t currentConfigIndex = INVAILD_VALUE;
310     int32_t currentInterfaceIndex = INVAILD_VALUE;
311     PrinterTranIndex tranIndex = printTranIndexMap[printerName];
312     if (operation == Operation::Send_Document) {
313         currentConfigIndex = tranIndex.sendDocConfigIndex;
314         currentInterfaceIndex = tranIndex.sendDocInterfaceIndex;
315     } else {
316         currentConfigIndex = tranIndex.commonConfigIndex;
317         currentInterfaceIndex = tranIndex.commonInterfaceIndex;
318     }
319     UsbInterface useInterface = usbdevice.GetConfigs()[currentConfigIndex].GetInterfaces()[currentInterfaceIndex];
320     USBEndpoint point1 = useInterface.GetEndpoints().at(INDEX_0);
321     USBEndpoint point2 = useInterface.GetEndpoints().at(INDEX_1);
322     USBEndpoint pointRead;
323     if (point1.GetDirection() == 0) {
324         pointRead = point2;
325     } else {
326         pointRead = point1;
327     }
328     USBDevicePipe usbDevicePipe = printPipeMap[printerName];
329     int32_t readFromUsbRes = 0;
330     int32_t claimRetryCount = 0;
331     if (isUsbEnable) {
332         do {
333             readFromUsbRes = UsbSrvClient::GetInstance().BulkTransfer(usbDevicePipe, pointRead, readTempBUffer,
334                 USB_BULKTRANSFER_READ_TIMEOUT);
335         } while (readFromUsbRes == EORROR_HDF_DEV_ERR_IO_FAILURE &&
336             UsbSrvClient::GetInstance().ClaimInterface(usbDevicePipe, useInterface, true) >= 0 &&
337             claimRetryCount++ < CLAIM_INTERFACE_RETRY_MAX_TIMES);
338     }
339     return readFromUsbRes;
340 }
341 
DealUsbDevStatusChange(const std::string & devStr,bool isAttach)342 void PrintUsbManager::DealUsbDevStatusChange(const std::string &devStr, bool isAttach)
343 {
344     PRINT_HILOGD("DealUsbDevStatusChange isAttach = %{public}d, devStr = %{public}s.",
345         isAttach, devStr.c_str());
346     cJSON *devJson = cJSON_Parse(devStr.c_str());
347     if (devJson == nullptr) {
348         PRINT_HILOGE("Create devJson error");
349         return;
350     }
351     UsbDevice *dev = new (std::nothrow) UsbDevice(devJson);
352     if (dev == nullptr) {
353         PRINT_HILOGE("Create dev error");
354         cJSON_Delete(devJson);
355         return;
356     }
357     if (!isAttach) {
358         std::string printerName = GetPrinterName(dev->GetName());
359         PRINT_HILOGI("DealUsbDevStatusChange detached dev->GetName() = %{public}s, printerName = %{public}s.",
360             dev->GetName().c_str(), printerName.c_str());
361         if (!printerName.empty()) {
362             DisConnectUsbPinter(printerName);
363             printDeviceMap.erase(printerName);
364             printerIndexMap.erase(printerName);
365         }
366     } else {
367         std::string printerName;
368         if (isPrintDevice(*dev, printerName)) {
369             printDeviceMap[printerName] = *dev;
370             PRINT_HILOGI("DealUsbDevStatusChange attached dev->GetName() = %{public}s , printerName = %{public}s.",
371                 dev->GetName().c_str(), printerName.c_str());
372         }
373     }
374     cJSON_Delete(devJson);
375     delete dev;
376     dev = nullptr;
377 }
378 
GetPrinterName(const std::string & name)379 std::string PrintUsbManager::GetPrinterName(const std::string &name)
380 {
381     for (const auto& pair : printDeviceMap) {
382         if (pair.second.GetName() == name) {
383             return pair.first;
384         }
385     }
386     return "";
387 }
388 }
389 
390 #endif // IPPOVERUSB_ENABLE