test-client/test-client.cpp

   1 /*
   2 * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <glib.h>
  21
  22 #include "Debug.h"
  23 #include "SEService.h"
  24 #include "Reader.h"
  25 #include "Session.h"
  26 #include "APDUHelper.h"
  27
  28 using namespace smartcard_service_api;
  29
  30 typedef struct _user_context_t
  31 {
  32         Session *clientSession;
  33         SEServiceHelper *clientService;
  34         Channel *clientChannel;
  35 }
  36 user_context_t;
  37
  38 /* global variable */
  39 GMainLoop *loop = NULL;
  40 user_context_t user_context = { 0, };
  41
  42 void testCloseCallback(int error, void *userData);
  43 void testTransmitCallback(unsigned char *buffer, unsigned int length, int error, void *userData);
  44 void testOpenChannelCallback(Channel *channel, int error, void *userData);
  45 void testGetATRCallback(unsigned char *atr, unsigned int length, int error, void *userData);
  46 void testCloseSessionCallback(int error, void *userData);
  47 void testOpenSessionCallback(SessionHelper *session, int error, void *userData);
  48 void testConnectedCallback(SEServiceHelper *service, void *context);
  49
  50 class TestEventHandler : public SEServiceListener
  51 {
  52         void serviceConnected(SEServiceHelper *service, void *userData)
  53         {
  54                 SCARD_BEGIN();
  55                 testConnectedCallback(service, userData);
  56                 SCARD_END();
  57         }
  58
  59         void eventHandler(SEServiceHelper *service, char *seName, int event, void *userData)
  60         {
  61 //              user_context_t *context = (user_context_t *)userData;
  62                 vector<ReaderHelper *> readers;
  63                 size_t i;
  64
  65                 SCARD_BEGIN();
  66
  67                 SCARD_DEBUG("event occured service [%p], seName[%s], event [%d], userData [%p]", service, seName, event, userData);
  68
  69                 readers = service->getReaders();
  70
  71                 for (i = 0; i < readers.size(); i++)
  72                 {
  73                         SCARD_DEBUG("Reader[%d] : name [%s], %s", i, readers[i]->getName(), readers[i]->isSecureElementPresent() ? "available" : "unavailable");
  74                 }
  75
  76                 if (event == 1)
  77                 {
  78                         testConnectedCallback(service, userData);
  79                 }
  80
  81                 SCARD_END();
  82         }
  83
  84         void errorHandler(SEServiceHelper *service, int error, void *userData)
  85         {
  86                 SCARD_BEGIN();
  87
  88                 SCARD_DEBUG("error occured service [%p], error [%d]", service, error);
  89
  90                 SCARD_END();
  91         }
  92 };
  93
  94 TestEventHandler testEventHandler;
  95
  96 void testCloseCallback(int error, void *userData)
  97 {
  98         user_context_t *context = (user_context_t *)userData;
  99
 100         SCARD_DEBUG("result [%d], userData [%p]", error, userData);
 101
 102         context->clientService->shutdown();
 103 }
 104
 105 void testTransmitCallback(unsigned char *buffer, unsigned int length, int error, void *userData)
 106 {
 107         ByteArray response(buffer, length);
 108         user_context_t *context = (user_context_t *)userData;
 109
 110         SCARD_DEBUG("buffer [%p], length [%d], error [%d], userData [%p]", buffer, length, error, userData);
 111
 112         context->clientChannel->close(testCloseCallback, userData);
 113 }
 114
 115 void testOpenChannelCallback(Channel *channel, int error, void *userData)
 116 {
 117         SCARD_DEBUG("channel [%p]", channel);
 118
 119         if (error == 0 && channel != NULL)
 120         {
 121                 ByteArray response;
 122                 ByteArray data, command;
 123                 int fid = 0x00003150;
 124                 user_context_t *context = (user_context_t *)userData;
 125
 126                 context->clientChannel = channel;
 127
 128                 response = channel->getSelectResponse();
 129
 130                 SCARD_DEBUG("response : %s", response.toString());
 131
 132                 SCARD_DEBUG("isBasicChannel() = %s", channel->isBasicChannel() ? "Basic" : "Logical");
 133                 SCARD_DEBUG("isClosed() = %s", channel->isClosed() ? "Closed" : "Opened");
 134
 135                 data.setBuffer((unsigned char *)&fid, 2);
 136                 command = APDUHelper::generateAPDU(APDUHelper::COMMAND_SELECT_BY_ID, 0, data);
 137                 context->clientChannel->transmit(command, testTransmitCallback, userData);
 138         }
 139         else
 140         {
 141                 SCARD_DEBUG_ERR("openBasicChannel failed");
 142         }
 143 }
 144
 145 void testGetATRCallback(unsigned char *atr, unsigned int length, int error, void *userData)
 146 {
 147 //      unsigned char MF[] = { 0x3F, 0x00 };
 148         unsigned char MF[] = { 0xA0, 0x00, 0x00, 0x00, 0x63, 0x50, 0x4B, 0x43, 0x53, 0x2D, 0x31, 0x35 };
 149         ByteArray aid, result(atr, length);
 150         user_context_t *context = (user_context_t *)userData;
 151
 152         SCARD_DEBUG("atr[%d] : %s", result.getLength(), result.toString());
 153
 154         aid.setBuffer(MF, sizeof(MF));
 155         context->clientSession->openLogicalChannel(aid, testOpenChannelCallback, userData);
 156 }
 157
 158 void testCloseSessionCallback(int error, void *userData)
 159 {
 160
 161 }
 162
 163 void testOpenSessionCallback(SessionHelper *session, int error, void *userData)
 164 {
 165         SCARD_DEBUG("session [%p]", session);
 166
 167         if (session != NULL)
 168         {
 169                 user_context_t *context = (user_context_t *)userData;
 170
 171                 context->clientSession = (Session *)session;
 172                 context->clientSession->getATR(testGetATRCallback, userData);
 173         }
 174         else
 175         {
 176                 SCARD_DEBUG_ERR("openSession failed");
 177         }
 178 }
 179
 180 void testConnectedCallback(SEServiceHelper *service, void *userData)
 181 {
 182         vector<ReaderHelper *> readers;
 183         user_context_t *context = (user_context_t *)userData;
 184
 185         SCARD_BEGIN();
 186
 187         if (service != NULL)
 188         {
 189                 SCARD_DEBUG("callback called, service [%p]", service);
 190
 191                 context->clientService = service;
 192
 193                 readers = service->getReaders();
 194
 195                 if (readers.size() > 0)
 196                 {
 197                         Reader *reader = NULL;
 198
 199                         reader = (Reader *)readers[0];
 200
 201                         SCARD_DEBUG("reader [%p]", reader);
 202
 203                         reader->openSession(testOpenSessionCallback, userData);
 204                 }
 205                 else
 206                 {
 207                         SCARD_DEBUG_ERR("reader is empty");
 208                 }
 209         }
 210         else
 211         {
 212                 SCARD_DEBUG_ERR("service is NULL");
 213         }
 214
 215         SCARD_END();
 216 }
 217
 218 int main(int argv, char *args[])
 219 {
 220         SEService *service = new SEService((void *)&user_context, &testEventHandler);
 221
 222         loop = g_main_new(TRUE);
 223         g_main_loop_run(loop);
 224
 225         if (service != NULL)
 226                 delete service;
 227
 228         return 0;
 229 }