libcacard/vcard.c

   1 /*
   2  * implement the Java card standard.
   3  *
   4  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
   5  * See the COPYING.LIB file in the top-level directory.
   6  */
   7
   8 #include "qemu-common.h"
   9
  10 #include "vcard.h"
  11 #include "vcard_emul.h"
  12 #include "card_7816t.h"
  13
  14 struct VCardAppletStruct {
  15     VCardApplet   *next;
  16     VCardProcessAPDU process_apdu;
  17     VCardResetApplet reset_applet;
  18     unsigned char *aid;
  19     int aid_len;
  20     void *applet_private;
  21     VCardAppletPrivateFree applet_private_free;
  22 };
  23
  24 struct VCardStruct {
  25     int reference_count;
  26     VCardApplet *applet_list;
  27     VCardApplet *current_applet[MAX_CHANNEL];
  28     VCardBufferResponse *vcard_buffer_response;
  29     VCardType type;
  30     VCardEmul *vcard_private;
  31     VCardEmulFree vcard_private_free;
  32     VCardGetAtr vcard_get_atr;
  33 };
  34
  35 VCardBufferResponse *
  36 vcard_buffer_response_new(unsigned char *buffer, int size)
  37 {
  38     VCardBufferResponse *new_buffer;
  39
  40     new_buffer = (VCardBufferResponse *)g_malloc(sizeof(VCardBufferResponse));
  41     new_buffer->buffer = (unsigned char *)g_malloc(size);
  42     memcpy(new_buffer->buffer, buffer, size);
  43     new_buffer->buffer_len = size;
  44     new_buffer->current = new_buffer->buffer;
  45     new_buffer->len = size;
  46     return new_buffer;
  47 }
  48
  49 void
  50 vcard_buffer_response_delete(VCardBufferResponse *buffer_response)
  51 {
  52     if (buffer_response == NULL) {
  53         return;
  54     }
  55     if (buffer_response->buffer) {
  56         g_free(buffer_response->buffer);
  57     }
  58     g_free(buffer_response);
  59 }
  60
  61
  62 /*
  63  * clean up state after a reset
  64  */
  65 void
  66 vcard_reset(VCard *card, VCardPower power)
  67 {
  68     int i;
  69     VCardApplet *applet = NULL;
  70
  71     if (card->type ==  VCARD_DIRECT) {
  72         /* select the last applet */
  73         VCardApplet *current_applet = NULL;
  74         for (current_applet = card->applet_list; current_applet;
  75                                        current_applet = current_applet->next) {
  76             applet = current_applet;
  77         }
  78     }
  79     for (i = 0; i < MAX_CHANNEL; i++) {
  80         card->current_applet[i] = applet;
  81     }
  82     if (card->vcard_buffer_response) {
  83         vcard_buffer_response_delete(card->vcard_buffer_response);
  84         card->vcard_buffer_response = NULL;
  85     }
  86     vcard_emul_reset(card, power);
  87     if (applet) {
  88         applet->reset_applet(card, 0);
  89     }
  90 }
  91
  92 /* applet utilities */
  93
  94 /*
  95  * applet utilities
  96  */
  97 /* constructor */
  98 VCardApplet *
  99 vcard_new_applet(VCardProcessAPDU applet_process_function,
 100                  VCardResetApplet applet_reset_function,
 101                  unsigned char *aid, int aid_len)
 102 {
 103     VCardApplet *applet;
 104
 105     applet = (VCardApplet *)g_malloc(sizeof(VCardApplet));
 106     applet->next = NULL;
 107     applet->applet_private = NULL;
 108     applet->applet_private_free = NULL;
 109     applet->process_apdu = applet_process_function;
 110     applet->reset_applet = applet_reset_function;
 111
 112     applet->aid = g_malloc(aid_len);
 113     memcpy(applet->aid, aid, aid_len);
 114     applet->aid_len = aid_len;
 115     return applet;
 116 }
 117
 118 /* destructor */
 119 void
 120 vcard_delete_applet(VCardApplet *applet)
 121 {
 122     if (applet == NULL) {
 123         return;
 124     }
 125     if (applet->applet_private_free) {
 126         applet->applet_private_free(applet->applet_private);
 127         applet->applet_private = NULL;
 128     }
 129     if (applet->aid) {
 130         g_free(applet->aid);
 131         applet->aid = NULL;
 132     }
 133     g_free(applet);
 134 }
 135
 136 /* accessor */
 137 void
 138 vcard_set_applet_private(VCardApplet *applet, VCardAppletPrivate *private,
 139                          VCardAppletPrivateFree private_free)
 140 {
 141     if (applet->applet_private_free) {
 142         applet->applet_private_free(applet->applet_private);
 143     }
 144     applet->applet_private = private;
 145     applet->applet_private_free = private_free;
 146 }
 147
 148 VCard *
 149 vcard_new(VCardEmul *private, VCardEmulFree private_free)
 150 {
 151     VCard *new_card;
 152     int i;
 153
 154     new_card = (VCard *)g_malloc(sizeof(VCard));
 155     new_card->applet_list = NULL;
 156     for (i = 0; i < MAX_CHANNEL; i++) {
 157         new_card->current_applet[i] = NULL;
 158     }
 159     new_card->vcard_buffer_response = NULL;
 160     new_card->type = VCARD_VM;
 161     new_card->vcard_private = private;
 162     new_card->vcard_private_free = private_free;
 163     new_card->vcard_get_atr = NULL;
 164     new_card->reference_count = 1;
 165     return new_card;
 166 }
 167
 168 VCard *
 169 vcard_reference(VCard *vcard)
 170 {
 171     if (vcard == NULL) {
 172         return NULL;
 173     }
 174     vcard->reference_count++;
 175     return vcard;
 176 }
 177
 178 void
 179 vcard_free(VCard *vcard)
 180 {
 181     VCardApplet *current_applet = NULL;
 182     VCardApplet *next_applet = NULL;
 183
 184     if (vcard == NULL) {
 185         return;
 186     }
 187     vcard->reference_count--;
 188     if (vcard->reference_count != 0) {
 189         return;
 190     }
 191     if (vcard->vcard_private_free) {
 192         (*vcard->vcard_private_free)(vcard->vcard_private);
 193         vcard->vcard_private_free = 0;
 194         vcard->vcard_private = 0;
 195     }
 196     for (current_applet = vcard->applet_list; current_applet;
 197                                         current_applet = next_applet) {
 198         next_applet = current_applet->next;
 199         vcard_delete_applet(current_applet);
 200     }
 201     vcard_buffer_response_delete(vcard->vcard_buffer_response);
 202     g_free(vcard);
 203 }
 204
 205 void
 206 vcard_get_atr(VCard *vcard, unsigned char *atr, int *atr_len)
 207 {
 208     if (vcard->vcard_get_atr) {
 209         (*vcard->vcard_get_atr)(vcard, atr, atr_len);
 210         return;
 211     }
 212     vcard_emul_get_atr(vcard, atr, atr_len);
 213 }
 214
 215 void
 216 vcard_set_atr_func(VCard *card, VCardGetAtr vcard_get_atr)
 217 {
 218     card->vcard_get_atr = vcard_get_atr;
 219 }
 220
 221
 222 VCardStatus
 223 vcard_add_applet(VCard *card, VCardApplet *applet)
 224 {
 225     applet->next = card->applet_list;
 226     card->applet_list = applet;
 227     /* if our card-type is direct, always call the applet */
 228     if (card->type ==  VCARD_DIRECT) {
 229         int i;
 230
 231         for (i = 0; i < MAX_CHANNEL; i++) {
 232             card->current_applet[i] = applet;
 233         }
 234     }
 235     return VCARD_DONE;
 236 }
 237
 238 /*
 239  * manage applets
 240  */
 241 VCardApplet *
 242 vcard_find_applet(VCard *card, unsigned char *aid, int aid_len)
 243 {
 244     VCardApplet *current_applet;
 245
 246     for (current_applet = card->applet_list; current_applet;
 247                                         current_applet = current_applet->next) {
 248         if (current_applet->aid_len != aid_len) {
 249             continue;
 250         }
 251         if (memcmp(current_applet->aid, aid, aid_len) == 0) {
 252             break;
 253         }
 254     }
 255     return current_applet;
 256 }
 257
 258 unsigned char *
 259 vcard_applet_get_aid(VCardApplet *applet, int *aid_len)
 260 {
 261     if (applet == NULL) {
 262         return NULL;
 263     }
 264     *aid_len = applet->aid_len;
 265     return applet->aid;
 266 }
 267
 268
 269 void
 270 vcard_select_applet(VCard *card, int channel, VCardApplet *applet)
 271 {
 272     assert(channel < MAX_CHANNEL);
 273     card->current_applet[channel] = applet;
 274     /* reset the applet */
 275     if (applet && applet->reset_applet) {
 276         applet->reset_applet(card, channel);
 277     }
 278 }
 279
 280 VCardAppletPrivate *
 281 vcard_get_current_applet_private(VCard *card, int channel)
 282 {
 283     VCardApplet *applet = card->current_applet[channel];
 284
 285     if (applet == NULL) {
 286         return NULL;
 287     }
 288     return applet->applet_private;
 289 }
 290
 291 VCardStatus
 292 vcard_process_applet_apdu(VCard *card, VCardAPDU *apdu,
 293                           VCardResponse **response)
 294 {
 295     if (card->current_applet[apdu->a_channel]) {
 296         return card->current_applet[apdu->a_channel]->process_apdu(
 297                                                         card, apdu, response);
 298     }
 299     return VCARD_NEXT;
 300 }
 301
 302 /*
 303  * Accessor functions
 304  */
 305 /* accessor functions for the response buffer */
 306 VCardBufferResponse *
 307 vcard_get_buffer_response(VCard *card)
 308 {
 309     return card->vcard_buffer_response;
 310 }
 311
 312 void
 313 vcard_set_buffer_response(VCard *card, VCardBufferResponse *buffer)
 314 {
 315     card->vcard_buffer_response = buffer;
 316 }
 317
 318
 319 /* accessor functions for the type */
 320 VCardType
 321 vcard_get_type(VCard *card)
 322 {
 323     return card->type;
 324 }
 325
 326 void
 327 vcard_set_type(VCard *card, VCardType type)
 328 {
 329     card->type = type;
 330 }
 331
 332 /* accessor for private data */
 333 VCardEmul *
 334 vcard_get_private(VCard *vcard)
 335 {
 336     return vcard->vcard_private;
 337 }
 338