int icusb_storage_do_unmomunt()
{
int ret = 0;
if(isMountpointMounted("/mnt/udisk/folder1"))
{
icusb_print(PRINT_WARN, "[ICUSB][INFO] ====> icusb_storage_do_unmomunt1 .\n");
ret = icusb_do_exec(vdc_cmd, unmount_stor1_argv) ;
}
icusb_print(PRINT_WARN, "[ICUSB][INFO] unmomunt icusb_storage1, return %d \n", ret);
if(isMountpointMounted("/mnt/udisk/folder2"))
{
icusb_print(PRINT_WARN, "[ICUSB][INFO] ====> icusb_storage_do_unmomunt2 .\n");
if(ret == 0)
ret = icusb_do_exec(vdc_cmd, unmount_stor2_argv) ;
}
icusb_print(PRINT_WARN, "[ICUSB][INFO] unmomunt icusb_storage2, return %d \n", ret);
icusb_print(PRINT_WARN, "[ICUSB][INFO] <==== icusb_storage_do_unmomunt\n");
return ret ;
}
int icusb_util_get_proc(char * file_path, char* buf, int size)
{
int proc_fd ;
int readed ;
proc_fd = open(file_path, O_RDONLY) ;
if(proc_fd==-1){
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_util_get_proc %s proc file not found\n", file_path);
return ICUSB_USB_PROC_NO_FD;
}
readed = read(proc_fd, buf, size);
#if 0
if(readed !=size){
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_util_get_proc read proc not complte, proc:%s, read bytes: %d, readed: %d\n", file_path, size, readed);
return ICUSB_USB_PROC_READ_FAIL;
}
#endif
close(proc_fd) ;
icusb_print(PRINT_INFO, "[ICUSB][INFO] icusb_util_get_proc, proc:%s, get bytes: %d, buf[3]: 0x%02x 0x%02x 0x%02x\n", file_path, size, buf[0], buf[1], buf[2]);
return ICUSB_OK ;
}
int ut_case_5_xxx(void)
{
icusb_print(PRINT_INFO, "[ICUSB][UT] Test Case 5 ==========> \n");
icusb_print(PRINT_INFO, "[ICUSB][UT] Test Case 5 <==========\n");
return 0 ;
}
int ut_case_1_LibusbTest(void)
{
libusb_device **devs;
int r , cnt;
icusb_print(PRINT_INFO, "[ICUSB][UT] Test Case 1 ==========> ut_case_1_LibusbTest\n");
r = libusb_init(NULL);
if (r < 0){
icusb_print(PRINT_ERROR, "[ICUSB][Error] failed to libusb_init\n");
return r;
}
cnt = libusb_get_device_list(NULL, &devs);
if (cnt < 0){
icusb_print(PRINT_ERROR, "[ICUSB][Error] failed to libusb_get_device_list\n");
return (int) cnt;
}
//ut_LibusbPrintDevs(devs); // libusb_device list
libusb_free_device_list(devs, 1);
libusb_exit(NULL);
icusb_print(PRINT_INFO, "[ICUSB][UT] Test Case 1 <==========\n");
return 0 ;
}
int icusb_util_write_proc(char * file_path, char* buf, int size)
{
int proc_fd ;
int writed ;
icusb_print(PRINT_INFO, "[ICUSB][INFO] icusb_util_write_proc, proc:%s, write bytes: %d, buf[3]: 0x%02x 0x%02x 0x%02x\n", file_path, size, buf[0], buf[1], buf[2]);
proc_fd = open(file_path, O_WRONLY) ;
if(proc_fd==-1){
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_util_write_proc %s proc file not found\n", file_path);
return ICUSB_USB_PROC_NO_FD;
}
writed = write(proc_fd, buf, size);
#if 0
if(writed !=size){
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_util_write_proc write proc not complte, proc:%s, write bytes: %d, writed: %d\n", file_path, size, writed);
return ICUSB_USB_PROC_WRITE_FAIL;
}
#endif
close(proc_fd) ;
return ICUSB_OK ;
}
int icusb_close_dev(s_icusb_device *icusb_device)
{
icusb_print(PRINT_INFO, "[ICUSB][INFO] ===> icusb_close_dev\n");
if (icusb_device->is_ready == 1){
icusb_device->is_ready = 0 ;
if (icusb_device->usb_device_handle){
icusb_print(PRINT_INFO, "[ICUSB][INFO] ===> libusb_close\n");
libusb_close(icusb_device->usb_device_handle);
icusb_print(PRINT_INFO, "[ICUSB][INFO] <=== libusb_close\n");
}
icusb_print(PRINT_INFO, "[ICUSB][INFO] ===> libusb_free_device_list\n");
libusb_free_device_list(usb_devs, 1);
icusb_print(PRINT_INFO, "[ICUSB][INFO] <=== libusb_free_device_list\n");
icusb_print(PRINT_INFO, "[ICUSB][INFO] ===> libusb_exit\n");
libusb_exit(NULL);
icusb_print(PRINT_INFO, "[ICUSB][INFO] <=== libusb_exit\n");
}
icusb_print(PRINT_INFO, "[ICUSB][INFO] <=== icusb_close_dev\n");
return ICUSB_OK;
}
int isMountpointMounted(const char *path)
{
char device[256];
char mount_path[256];
char rest[256];
FILE *fp;
char line[1024];
if (!(fp = fopen("/proc/mounts", "r"))) {
icusb_print(PRINT_WARN, "[ICUSB][INFO] ====> no /proc/mounts .\n");
return 0;
}
while(fgets(line, sizeof(line), fp)) {
line[strlen(line)-1] = '\0';
sscanf(line, "%255s %255s %255s\n", device, mount_path, rest);
if (!strcmp(mount_path, path)) {
fclose(fp);
return 1;
}
}
fclose(fp);
return 0;
}
int ut_case_IcusbClose(void)
{
int r ;
icusb_print(PRINT_INFO, "[ICUSB][UT] Test Case ==========> ut_case_IcusbClose\n");
r = icusb_close_dev(&ut_icusb_device) ;
if (r < 0){
icusb_print(PRINT_ERROR, "[ICUSB][Error] failed to icusb_close_dev\n");
return r;
}
icusb_print(PRINT_INFO, "[ICUSB][UT] Test Case <==========\n");
return 0 ;
}
int icusb_netlink_recv_msg()
{
struct msghdr msg;
struct sockaddr_nl dest_addr;
struct nlmsghdr *nlh = NULL;
struct iovec iov;
char str_buf[64];
char *rcv_buf ;
int bytes_received ;
if (netlink_sock_fd <0){
return ICUSB_USB_NL_NO_FD ;
}
nlh=(struct nlmsghdr *)nl_payload_buff ;
iov.iov_base = (void *)nlh;
iov.iov_len = NL_MAX_BUF_SIZE;
memset(&msg, 0, sizeof(msg)) ;
msg.msg_name = (void *)&(dest_addr);
msg.msg_namelen = sizeof(dest_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
sprintf(str_buf, "%d", getpid());
bytes_received = recvmsg(netlink_sock_fd, &msg, 0);
if (bytes_received > 0){
rcv_buf = NLMSG_DATA(msg.msg_iov->iov_base) ;
icusb_print(PRINT_INFO, "[ICUSB][INFO] PID : %s , Received message payload: %s\n", str_buf , rcv_buf);
if(!strcmp(str_buf, rcv_buf)){
icusb_print(PRINT_INFO, "[ICUSB][INFO] icusb_netlink_recv_msg. recieve the correct PID ACK from Kernel\n");
return ICUSB_USB_NL_ACK_PID;
}else if (!strcmp("HELLO, SS7_IC_USB!!!", rcv_buf)){
icusb_print(PRINT_INFO, "[ICUSB][INFO] icusb_netlink_recv_msg. recieve the correct Recover from Kernel\n");
return ICUSB_OK ;
}else{
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_netlink_recv_msg : get unknown message from Kernel\n");
return ICUSB_USB_NL_UNKNOWN_MSG ;
}
}else{
return ICUSB_NO_DATA ;
}
}
int icusb_open_dev(s_icusb_device *icusb_device)
{
int r , cnt ;
icusb_print(PRINT_INFO, "[ICUSB][INFO] ===> icusb_open_dev\n");
if (icusb_device->is_ready == 1){
icusb_print(PRINT_WARN, "[ICUSB][WARN] icusb_open_dev has been opened before\n");
return ICUSB_OK ;
}
r = libusb_init(NULL);
if (r < 0){
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_open_dev->libusb_init fail, ret %d\n", r);
return ICUSB_DEV_INIT_ERR;
}
cnt = icusb_get_device_list(&usb_devs);
if (cnt < 0){
libusb_exit(NULL);
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_open_dev->icusb_get_device_list is 0\n");
return ICUSB_DEV_NOT_FOUND;
}
r = icusb_find_match_device(usb_devs, icusb_device) ;
if (r < 0){
libusb_free_device_list(usb_devs, 1);
libusb_exit(NULL);
icusb_print(PRINT_WARN, "[ICUSB][WARN] icusb_open_dev->icusb_find_match_device can't find icusb device\n");
return r;
}
r = libusb_open(icusb_device->usb_dev, &icusb_device->usb_device_handle);
if (r < 0) {
libusb_free_device_list(usb_devs, 1);
libusb_exit(NULL);
icusb_print(PRINT_ERROR, "[ICUSB][Error] failed to open icusb device handle");
return ICUSB_DEV_OPEN_FAIL;
}
#if CHECK_MORE
if (libusb_kernel_driver_active(icusb_device->usb_device_handle, icusb_device->icusb_smartcard_intf_number) == 1){ // check the ICCD Interface has driver served ?
icusb_print(PRINT_ERROR, "[ICUSB][Error] iccd class should not have driver served !");
return ICUSB_DEV_HAS_DRIVER;
}
#endif
icusb_device->is_ready = 1 ;
icusb_print(PRINT_INFO, "[ICUSB][INFO] <=== icusb_open_dev\n");
return ICUSB_OK;
}
void icusb_netlink_close()
{
icusb_print(PRINT_INFO, "[ICUSB][INFO] icusb_close_netlink_to_kernel_usb\n");
close(netlink_sock_fd);
netlink_sock_fd = -1 ;
return ;
}
void ut_LibusbPrintDevs(libusb_device **devs)
{
libusb_device *usb_dev;
int i = 0 ;
libusb_device_handle *handle ;
while ((usb_dev = devs[i++]) != NULL) {
struct libusb_device_descriptor device_descriptor;
struct libusb_config_descriptor *config_descriptor;
int r ;
int j = 0 ;
r = libusb_get_device_descriptor(usb_dev, &device_descriptor);
if (r < 0) {
icusb_print(PRINT_ERROR, "[ICUSB][Error] failed to get device descriptor");
return;
}
icusb_print(PRINT_VERB, "\n\n +++++ the %d device +++++\n", i ) ;
icusb_print(PRINT_VERB, " 0x%04x:0x%04x (bus %d, device %d)\n",
device_descriptor.idVendor, device_descriptor.idProduct,
libusb_get_bus_number(usb_dev), libusb_get_device_address(usb_dev));
icusb_print(PRINT_VERB, "[device descriptor] -- \n") ;
icusb_print(PRINT_VERB, "\t bDeviceClass:0x%02x\n", device_descriptor.bDeviceClass) ;
icusb_print(PRINT_VERB, "\t bDeviceSubClass:0x%02x\n", device_descriptor.bDeviceSubClass) ;
icusb_print(PRINT_VERB, "\t bDeviceProtocol:0x%02x\n", device_descriptor.bDeviceProtocol) ;
icusb_print(PRINT_VERB, "\t idVendor:0x%04x\n", device_descriptor.idVendor) ;
icusb_print(PRINT_VERB, "\t idProduct:0x%04x\n", device_descriptor.idProduct) ;
icusb_print(PRINT_VERB, "\t bNumConfigurations:%d\n", device_descriptor.bNumConfigurations) ;
for (j=0 ; j<device_descriptor.bNumConfigurations ; j++){
int k = 0 ;
r = libusb_get_config_descriptor(usb_dev, j, &config_descriptor);
if (r < 0) {
icusb_print(PRINT_ERROR, "[ICUSB][Error] failed to get config descriptor");
return;
}
icusb_print(PRINT_VERB, "\t [configuration descriptor] -- \n") ;
icusb_print(PRINT_VERB, "\t\t bConfigurationValue:%d\n", config_descriptor->bConfigurationValue) ;
icusb_print(PRINT_VERB, "\t\t bNumInterfaces:%d\n", config_descriptor->bNumInterfaces) ;
for (k=0 ; k<config_descriptor->bNumInterfaces ; k++){
struct libusb_interface interf_descriptor;
const struct libusb_endpoint_descriptor *endpoint_descriptor[3] = {NULL};
//libusb_device_handle *handle ;
int driver_exist = 0 ;
struct libusb_class_usbicc_descriptor *uicc_descriptor;
int l = 0 ;
interf_descriptor = config_descriptor->interface[k] ;
icusb_print(PRINT_VERB, "\t\t [interface descriptor] -- \n") ;
icusb_print(PRINT_VERB, "\t\t\t num_altsetting:%d\n", interf_descriptor.num_altsetting) ;
icusb_print(PRINT_VERB, "\t\t\t bInterfaceNumber:%d\n", interf_descriptor.altsetting->bInterfaceNumber) ;
icusb_print(PRINT_VERB, "\t\t\t bNumEndpoints:%d\n", interf_descriptor.altsetting->bNumEndpoints) ;
icusb_print(PRINT_VERB, "\t\t\t bInterfaceClass:0x%02x\n", interf_descriptor.altsetting->bInterfaceClass) ;
icusb_print(PRINT_VERB, "\t\t\t bInterfaceSubClass:0x%02x\n", interf_descriptor.altsetting->bInterfaceSubClass) ;
icusb_print(PRINT_VERB, "\t\t\t bInterfaceProtocol:0x%02x\n", interf_descriptor.altsetting->bInterfaceProtocol) ;
icusb_print(PRINT_VERB, "\t\t\t extra_length:%d\n", interf_descriptor.altsetting->extra_length) ;
for (l=0 ; l<interf_descriptor.altsetting->bNumEndpoints ; l++){
endpoint_descriptor[l] = &interf_descriptor.altsetting->endpoint[l] ;
icusb_print(PRINT_VERB, "\t\t\t [endpoint descriptor] -- \n") ;
icusb_print(PRINT_VERB, "\t\t\t\t bmAttributes:0x%02x\n", endpoint_descriptor[l]->bmAttributes) ;
icusb_print(PRINT_VERB, "\t\t\t\t bEndpointAddress:0x%02x\n", endpoint_descriptor[l]->bEndpointAddress) ;
icusb_print(PRINT_VERB, "\t\t\t\t wMaxPacketSize:%d\n", endpoint_descriptor[l]->wMaxPacketSize) ;
}
if (interf_descriptor.altsetting->bInterfaceClass == 0x0b) /* smart card class*/
{
uicc_descriptor = (struct libusb_class_usbicc_descriptor *)interf_descriptor.altsetting->extra ;
if (interf_descriptor.altsetting->extra_length == 0x36 && uicc_descriptor->bDescriptorType == 0x21){ // CCID class specific
icusb_print(PRINT_VERB, "\t\t\t [UICC class specific descriptor] -- \n") ;
icusb_print(PRINT_VERB, "\t\t\t\t bLength:%d\n", uicc_descriptor->bLength) ;
icusb_print(PRINT_VERB, "\t\t\t\t bDescriptorType:0x%02x\n", uicc_descriptor->bDescriptorType) ;
icusb_print(PRINT_VERB, "\t\t\t\t bcdCCID:0x%04x\n", uicc_descriptor->bcdCCID) ;
icusb_print(PRINT_VERB, "\t\t\t\t bVoltageSupport:0x%02x\n", uicc_descriptor->bVoltageSupport) ;
icusb_print(PRINT_VERB, "\t\t\t\t dwProtocols:0x%08x\n", uicc_descriptor->dwProtocols) ;
icusb_print(PRINT_VERB, "\t\t\t\t dwMaxIFSD:0x%08x\n", uicc_descriptor->dwMaxIFSD) ;
icusb_print(PRINT_VERB, "\t\t\t\t dwFeatures:0x%08x\n", uicc_descriptor->dwFeatures) ;
icusb_print(PRINT_VERB, "\t\t\t\t dwMaxCCIDMessageLength:%d\n", uicc_descriptor->dwMaxCCIDMessageLength) ;
}
}
}
}
}
}
int ut_case_2_IcusbCCIDPowerOnPowerOff(void)
{
int r;
ssize_t cnt;
char buf[256] ;
int transferred ;
unsigned int bbb ;
icusb_print(PRINT_INFO, "[ICUSB][UT] Test Case 3 ==========> ut_case_3_IcusbBulkTransfer\n");
// test : test the bulk out transfer (power on)
struct ccid_pc2rdr_icc_pwr_on_msg *pwr_on_msg = (struct ccid_pc2rdr_icc_pwr_on_msg *)buf ;
pwr_on_msg->bMessageType = CCID_BULK_OUT_PC_TO_RDR_ICCPOWERON ;
pwr_on_msg->dwLength= 0x0 ;
pwr_on_msg->bSlot = 0x0 ;
pwr_on_msg->bSeq = sim_cmd_seq++ ;
pwr_on_msg->bPowerSelect= 0x00 ;
pwr_on_msg->abRFU[0]= 0x00 ;
pwr_on_msg->abRFU[1]= 0x00 ;
//r = libusb_bulk_transfer(handle, dwEndpoint, buf, sizeof(struct iccd_pc2rdr_icc_pwr_on_msg), &transferred, BULK_TRANSFER_TIMEOUT) ;
r = icusb_smartcard_data_bulk_out_transfer(buf, sizeof(struct ccid_pc2rdr_icc_pwr_on_msg), &transferred) ;
icusb_print(PRINT_INFO, "[ICUSB] icusb_smartcard_data_bulk_out_transfer, return: %d,transferred bytes: %d\n", r, transferred) ;
// test : test the bulk in transfer (get ATR)
sleep(1);
//r = libusb_bulk_transfer(handle, dwEndpoint, buf, sizeof(buf), &transferred, BULK_TRANSFER_TIMEOUT) ;
r = icusb_smartcard_data_bulk_in_transfer(buf, sizeof(struct ccid_pc2rdr_icc_pwr_on_msg), &transferred) ;
struct ccid_rdr2pc_data_block_msg*data_block_msg = (struct ccid_rdr2pc_data_block_msg*)buf ;
icusb_print(PRINT_INFO, "[ICUSB] iccd_rdr2pc_data_block_msg, return: %d,transferred bytes: %d\n", r, transferred) ;
icusb_print(PRINT_VERB, "data_block_msg->bMessageType : 0x%02x\n", data_block_msg->bMessageType) ; // should be ICUSB_BULK_IN_RDR_TO_PC_DATABLOCK
icusb_print(PRINT_VERB, "data_block_msg->dwLength : 0x%02x\n", data_block_msg->dwLength) ;
icusb_print(PRINT_VERB, "data_block_msg->bSeq : 0x%02x\n", data_block_msg->bSeq) ;
icusb_print(PRINT_VERB, "data_block_msg->bStatus : 0x%02x\n", data_block_msg->bStatus) ;
icusb_print(PRINT_VERB, "data_block_msg->bError : 0x%02x\n", data_block_msg->bError) ;
icusb_print(PRINT_VERB, "data_block_msg->bError : 0x%02x\n", data_block_msg->bChainParameter) ;
for (bbb =0 ; bbb<data_block_msg->dwLength ; bbb++){
icusb_print(PRINT_VERB, "0x%02x ",data_block_msg->abData[bbb]) ;
}
icusb_print(PRINT_VERB, "\n") ;
// test : test the bulk in transfer (power off)
struct ccid_pc2rdr_icc_pwr_off_msg *pwr_off_msg = (struct ccid_pc2rdr_icc_pwr_off_msg *)buf ;
pwr_off_msg->bMessageType = CCID_BULK_OUT_PC_TO_RDR_ICCPOWEROFF ;
pwr_off_msg->dwLength= 0x0 ;
pwr_off_msg->bSlot = 0x0 ;
pwr_off_msg->bSeq = sim_cmd_seq++ ;
pwr_off_msg->abRFU[0]= 0x00 ;
pwr_off_msg->abRFU[1]= 0x00 ;
pwr_off_msg->abRFU[2]= 0x00 ;
r = icusb_smartcard_data_bulk_out_transfer(buf, sizeof(struct ccid_pc2rdr_icc_pwr_off_msg), &transferred) ;
icusb_print(PRINT_INFO, "[ICUSB] iccd_pc2rdr_icc_pwr_off_msg, return: %d,transferred bytes: %d\n", r, transferred) ;
// test : test the bulk in transfer (get Slot Status)
sleep(1);
r = icusb_smartcard_data_bulk_in_transfer(buf, sizeof(buf), &transferred) ;
struct ccid_rdr2pc_slot_status_msg*slot_status = (struct ccid_rdr2pc_slot_status_msg*)buf ;
icusb_print(PRINT_INFO, "[ICUSB] iccd_rdr2pc_data_block_msg, return: %d,transferred bytes: %d\n", r, transferred) ; // should be ICUSB_BULK_IN_RDR_TO_PC_SLOTSTATUS
icusb_print(PRINT_VERB, "slot_status->bMessageType : 0x%02x\n", slot_status->bMessageType) ;
icusb_print(PRINT_VERB, "slot_status->bSeq : 0x%02x\n", slot_status->bSeq) ;
icusb_print(PRINT_VERB, "slot_status->bStatus : 0x%02x\n", slot_status->bStatus) ;
icusb_print(PRINT_VERB, "slot_status->bError : 0x%02x\n", slot_status->bError) ;
icusb_print(PRINT_INFO, "[ICUSB][UT] Test Case 3 <==========\n");
return 0 ;
}
int icusb_find_match_device(libusb_device **devs , s_icusb_device *icusb_device)
{
int r ;
int i = 0, j= 0, k=0, l=0 ;
libusb_device *iccd_dev = NULL ;
libusb_device *one_dev = NULL ;
icusb_print(PRINT_INFO, "[ICUSB][INFO] ===> icusb_find_match_device\n");
while ((one_dev = devs[i++]) != NULL) {
struct libusb_device_descriptor device_descriptor;
struct libusb_config_descriptor *config_descriptor;
r = libusb_get_device_descriptor(one_dev, &device_descriptor);
if (r < 0) {
icusb_print(PRINT_ERROR, "[ICUSB][Error] failed to get device descriptor");
return ICUSB_DEV_NOT_FOUND ;
}
icusb_print(PRINT_VERB, "\n\n +++++ the %d device +++++\n", i ) ;
icusb_print(PRINT_VERB, "VID:0x%04x PID:0x%04x (bus %d, device %d)\n", device_descriptor.idVendor, device_descriptor.idProduct, libusb_get_bus_number(one_dev), libusb_get_device_address(one_dev));
icusb_print(PRINT_VERB, "[device descriptor] -- \n") ;
icusb_print(PRINT_VERB, "\t bDeviceClass:0x%02x\n", device_descriptor.bDeviceClass) ;
icusb_print(PRINT_VERB, "\t bDeviceSubClass:0x%02x\n", device_descriptor.bDeviceSubClass) ;
icusb_print(PRINT_VERB, "\t bDeviceProtocol:0x%02x\n", device_descriptor.bDeviceProtocol) ;
icusb_print(PRINT_VERB, "\t idVendor:0x%04x\n", device_descriptor.idVendor) ;
icusb_print(PRINT_VERB, "\t idProduct:0x%04x\n", device_descriptor.idProduct) ;
icusb_print(PRINT_VERB, "\t bNumConfigurations:%d\n", device_descriptor.bNumConfigurations) ;
for (j=0 ; j<device_descriptor.bNumConfigurations ; j++){
r = libusb_get_config_descriptor(one_dev, j, &config_descriptor);
if (r < 0) {
icusb_print(PRINT_ERROR, "[ICUSB][Error] failed to get config descriptor");
return ICUSB_DEV_DESCRIPTOR_ERR;
}
icusb_print(PRINT_VERB, "\t [configuration descriptor] -- \n") ;
icusb_print(PRINT_VERB, "\t\t bConfigurationValue:%d\n", config_descriptor->bConfigurationValue) ;
icusb_print(PRINT_VERB, "\t\t bNumInterfaces:%d\n", config_descriptor->bNumInterfaces) ;
for (k=0 ; k<config_descriptor->bNumInterfaces ; k++){
struct libusb_interface interf_descriptor;
struct libusb_class_usbicc_descriptor *uicc_descriptor;
interf_descriptor = config_descriptor->interface[k] ;
icusb_print(PRINT_VERB, "\t\t [interface descriptor] -- \n") ;
icusb_print(PRINT_VERB, "\t\t\t num_altsetting:%d\n", interf_descriptor.num_altsetting) ;
icusb_print(PRINT_VERB, "\t\t\t bInterfaceNumber:%d\n", interf_descriptor.altsetting->bInterfaceNumber) ;
icusb_print(PRINT_VERB, "\t\t\t bNumEndpoints:%d\n", interf_descriptor.altsetting->bNumEndpoints) ;
icusb_print(PRINT_VERB, "\t\t\t bInterfaceClass:0x%02x\n", interf_descriptor.altsetting->bInterfaceClass) ;
icusb_print(PRINT_VERB, "\t\t\t bInterfaceSubClass:0x%02x\n", interf_descriptor.altsetting->bInterfaceSubClass) ;
icusb_print(PRINT_VERB, "\t\t\t bInterfaceProtocol:0x%02x\n", interf_descriptor.altsetting->bInterfaceProtocol) ;
icusb_print(PRINT_VERB, "\t\t\t extra_length:%d\n", interf_descriptor.altsetting->extra_length) ;
if ((interf_descriptor.altsetting->bInterfaceClass == 0x0b) /* smat card class*/
&& (interf_descriptor.altsetting->extra_length >= ICCD_CLASS_DESCRIPTOR_LENGTH)) /* UICC extra class*/
{
uicc_descriptor = (struct libusb_class_usbicc_descriptor *)interf_descriptor.altsetting->extra ;
if (uicc_descriptor->bDescriptorType == ICCD_CLASS_DESCRIPTOR_TYPE){ /* UICC bDescriptorType*/
/* FOUND !! */
const struct libusb_endpoint_descriptor *endpoint_descriptor[ICCD_MAC_EP_NUMBE] = {NULL}; // most three EPs
if (interf_descriptor.altsetting->bNumEndpoints>ICCD_MAC_EP_NUMBE){
icusb_print(PRINT_ERROR, "[ICUSB][Error] the UICC device has more than %d EPs\n", ICCD_MAC_EP_NUMBE);
return ICUSB_UICC_EP_ERR ;
}
for (l=0 ; l<interf_descriptor.altsetting->bNumEndpoints ; l++){
endpoint_descriptor[l] = &interf_descriptor.altsetting->endpoint[l] ;
if (!((endpoint_descriptor[l]->bEndpointAddress) & 0x80) && (endpoint_descriptor[l]->bmAttributes == 0x02)){ // OUT , BULK ,
icusb_print(PRINT_VERB, "\t\t\t [endpoint descriptor] OUT, BULK -- \n") ;
icusb_device->icusb_smartcard_bulk_out_ep = endpoint_descriptor[l]->bEndpointAddress ;
}else if (((endpoint_descriptor[l]->bEndpointAddress) & 0x80) && (endpoint_descriptor[l]->bmAttributes == 0x02)){ // IN , BULK ,
icusb_print(PRINT_VERB, "\t\t\t [endpoint descriptor] IN, BULK -- \n") ;
icusb_device->icusb_smartcard_bulk_in_ep = endpoint_descriptor[l]->bEndpointAddress ;
}else if (((endpoint_descriptor[l]->bEndpointAddress) & 0x80) && (endpoint_descriptor[l]->bmAttributes == 0x03)){
icusb_print(PRINT_VERB, "\t\t\t [endpoint descriptor] IN, INTERRUPT -- \n") ;
icusb_device->icusb_smartcard_interrupt_in_ep = endpoint_descriptor[l]->bEndpointAddress ;
}
icusb_print(PRINT_VERB, "\t\t\t\t bmAttributes:0x%02x\n", endpoint_descriptor[l]->bmAttributes) ;
icusb_print(PRINT_VERB, "\t\t\t\t bEndpointAddress:0x%02x\n", endpoint_descriptor[l]->bEndpointAddress) ;
icusb_print(PRINT_VERB, "\t\t\t\t wMaxPacketSize:%d\n", endpoint_descriptor[l]->wMaxPacketSize) ;
}
icusb_print(PRINT_VERB, "\t\t\t [UICC class specific descriptor] -- \n") ;
icusb_print(PRINT_VERB, "\t\t\t\t bLength:%d\n", uicc_descriptor->bLength) ;
icusb_print(PRINT_VERB, "\t\t\t\t bDescriptorType:0x%02x\n", uicc_descriptor->bDescriptorType) ;
icusb_print(PRINT_VERB, "\t\t\t\t bcdCCID:0x%04x\n", uicc_descriptor->bcdCCID) ;
icusb_print(PRINT_VERB, "\t\t\t\t bVoltageSupport:0x%02x\n", uicc_descriptor->bVoltageSupport) ;
icusb_print(PRINT_VERB, "\t\t\t\t dwProtocols:0x%08x\n", uicc_descriptor->dwProtocols) ;
icusb_print(PRINT_VERB, "\t\t\t\t dwMaxIFSD:0x%08x\n", uicc_descriptor->dwMaxIFSD) ;
icusb_print(PRINT_VERB, "\t\t\t\t dwFeatures:0x%08x\n", uicc_descriptor->dwFeatures) ;
icusb_print(PRINT_VERB, "\t\t\t\t dwMaxCCIDMessageLength:%d\n", uicc_descriptor->dwMaxCCIDMessageLength) ;
icusb_device->icusb_smartcard_num_ep = interf_descriptor.altsetting->bNumEndpoints;
icusb_device->usb_dev = one_dev ;
icusb_device->icusb_smartcard_intf_number = interf_descriptor.altsetting->bInterfaceNumber ;
FOUND_UICC:
icusb_print(PRINT_INFO, "[ICUSB][INFO] <=== icusb_find_match_device, found !!!\n");
return ICUSB_OK ;
}
}
}
}
}
icusb_print(PRINT_INFO, "[ICUSB][INFO] <=== icusb_find_match_device, not found\n");
NOT_FOUND_UICC:
return ICUSB_UICC_NOT_FOUND;
}
int icusb_netlink_open()
{
int ret ;
struct sockaddr_nl src_addr, dest_addr;
struct nlmsghdr *nlh = NULL;
struct iovec iov;
struct timeval tv;
struct msghdr msg;
icusb_print(PRINT_INFO, "[ICUSB][INFO] icusb_open_netlink_to_kernel_usb\n");
netlink_sock_fd = socket(PF_NETLINK, SOCK_RAW,NETLINK_USERSOCK);
if (netlink_sock_fd == -1){
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_open_netlink_to_kernel_usb, the socket FD create fail\n");
return ICUSB_USB_NL_NO_FD;
}
memset(&src_addr, 0, sizeof(src_addr));
src_addr.nl_family = AF_NETLINK;
src_addr.nl_pid = getpid(); /* self pid */
src_addr.nl_groups = 0; /* not in mcast groups */
if ( -1 == bind(netlink_sock_fd, (struct sockaddr*)&src_addr,sizeof(src_addr))){
icusb_netlink_close() ;
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_open_netlink_to_kernel_usb, bind socket fd fail\n");
return ICUSB_USB_NL_BIND_FAIL ;
}
tv.tv_sec = 0; /* Wait for max 10 sec on recvmsg */
tv.tv_usec = 5000;
setsockopt(netlink_sock_fd, SOL_SOCKET, SO_RCVTIMEO, (char *) &tv, sizeof(struct timeval));
memset(&dest_addr, 0, sizeof(dest_addr));
dest_addr.nl_family = AF_NETLINK;
dest_addr.nl_pid = 0; /* For Linux Kernel */
dest_addr.nl_groups = 0; /* unicast */
nlh=(struct nlmsghdr *)nl_payload_buff ;
/* Fill the netlink message header */
nlh->nlmsg_len = NLMSG_SPACE(NL_MAX_BUF_SIZE);
nlh->nlmsg_pid = getpid(); /* self pid */
nlh->nlmsg_flags = 0;
/* Fill in the netlink message payload */
strcpy(NLMSG_DATA(nlh), NL_HANDSHAKE_STRING);
iov.iov_base = (void *)nlh;
iov.iov_len = nlh->nlmsg_len;
memset(&msg, 0, sizeof(msg)) ;
msg.msg_name = (void *)&dest_addr;
msg.msg_namelen = sizeof(dest_addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
/* Send message to kernel to notify PID */
ret = sendmsg(netlink_sock_fd, &msg, 0) ;
if (-1 ==ret){
icusb_netlink_close() ;
icusb_print(PRINT_ERROR, "[ICUSB][ERROR] icusb_open_netlink_to_kernel_usb, sendmsg to handshake failed !!!\n");
perror("send fail");
return ICUSB_USB_NL_HANDSHAKE_FAIL ;
}
icusb_print(PRINT_INFO, "[ICUSB][INFO] icusb_open_netlink_to_kernel_usb, sendmsg sent %d bytes to handshake.\n", ret);
return ICUSB_OK;
}
