Modified cackey.c from [cf1bec3529] to [65f29eb7d2].

   505    505   	CACKEY_TLV_OBJID_CAC_BENEFITS      = 0x0202,
   506    506   	CACKEY_TLV_OBJID_CAC_OTHERBENEFITS = 0x0203,
   507    507   	CACKEY_TLV_OBJID_CAC_PERSONNEL     = 0x0201,
   508    508   	CACKEY_TLV_OBJID_CAC_PKICERT       = 0x02FE
   509    509   } cackey_tlv_objectid;
   510    510   
   511    511   typedef enum {
   512         -	CACKEY_LOGIN_OK     = 0,
   513         -	CACKEY_LOGIN_BADPIN = -1,
   514         -	CACKEY_LOGIN_LOCKED = -2
   515         -} cackey_login_ret;
          512  +	CACKEY_PCSC_S_TOKENPRESENT    = 2,
          513  +	CACKEY_PCSC_S_TOKENABSENT     = 1,
          514  +	CACKEY_PCSC_S_OK              = 0,
          515  +	CACKEY_PCSC_E_GENERIC         = -1,
          516  +	CACKEY_PCSC_E_BADPIN          = -2,
          517  +	CACKEY_PCSC_E_LOCKED          = -3,
          518  +} cackey_ret;
   516    519   
   517    520   struct cackey_tlv_cardurl {
   518    521   	unsigned char        rid[5];
   519    522   	cackey_tlv_apptype   apptype;
   520    523   	cackey_tlv_objectid  objectid;
   521    524   	cackey_tlv_objectid  appid;
   522    525   	unsigned char        pinid;
................................................................................
   599    602   	}
   600    603   
   601    604   	CACKEY_DEBUG_PRINTF("Returning");
   602    605   
   603    606   	return;
   604    607   }
   605    608   
   606         -static int cackey_pcsc_connect(void) {
          609  +static cackey_ret cackey_pcsc_connect(void) {
   607    610   	LONG scard_est_context_ret;
   608    611   #ifdef HAVE_SCARDISVALIDCONTEXT
   609    612   	LONG scard_isvalid_ret;
   610    613   #endif
   611    614   
   612    615   	CACKEY_DEBUG_PRINTF("Called.");
   613    616   
................................................................................
   614    617   	if (cackey_pcsc_handle == NULL) {
   615    618   		cackey_pcsc_handle = malloc(sizeof(*cackey_pcsc_handle));
   616    619   		if (cackey_pcsc_handle == NULL) {
   617    620   			CACKEY_DEBUG_PRINTF("Call to malloc() failed, returning in failure");
   618    621   
   619    622   			cackey_slots_disconnect_all();
   620    623   
   621         -			return(-1);
          624  +			return(CACKEY_PCSC_E_GENERIC);
   622    625   		}
   623    626   
   624    627   		CACKEY_DEBUG_PRINTF("SCardEstablishContext() called");
   625    628   		scard_est_context_ret = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL, cackey_pcsc_handle);
   626    629   		if (scard_est_context_ret != SCARD_S_SUCCESS) {
   627    630   			CACKEY_DEBUG_PRINTF("Call to SCardEstablishContext failed (returned %s/%li), returning in failure", CACKEY_DEBUG_FUNC_SCARDERR_TO_STR(scard_est_context_ret), (long) scard_est_context_ret);
   628    631   
   629    632   			free(cackey_pcsc_handle);
   630    633   
   631    634   			cackey_slots_disconnect_all();
   632    635   
   633         -			return(-1);
          636  +			return(CACKEY_PCSC_E_GENERIC);
   634    637   		}
   635    638   	}
   636    639   
   637    640   #ifdef HAVE_SCARDISVALIDCONTEXT
   638    641   	CACKEY_DEBUG_PRINTF("SCardIsValidContext() called");
   639    642   	scard_isvalid_ret = SCardIsValidContext(*cackey_pcsc_handle);
   640    643   	if (scard_isvalid_ret != SCARD_S_SUCCESS) {
................................................................................
   645    648   		if (scard_est_context_ret != SCARD_S_SUCCESS) {
   646    649   			CACKEY_DEBUG_PRINTF("Call to SCardEstablishContext failed (returned %s/%li), returning in failure", CACKEY_DEBUG_FUNC_SCARDERR_TO_STR(scard_est_context_ret), (long) scard_est_context_ret);
   647    650   
   648    651   			free(cackey_pcsc_handle);
   649    652   
   650    653   			cackey_slots_disconnect_all();
   651    654   
   652         -			return(-1);
          655  +			return(CACKEY_PCSC_E_GENERIC);
   653    656   		}
   654    657   
   655    658   		CACKEY_DEBUG_PRINTF("Handle has been re-established");
   656    659   	}
   657    660   #endif
   658    661   
   659    662   	CACKEY_DEBUG_PRINTF("Sucessfully connected to PC/SC, returning in success");
   660    663   
   661         -	return(0);
          664  +	return(CACKEY_PCSC_S_OK);
   662    665   }
   663    666   
   664    667   /* APDU Related Functions */
   665    668   /** Le = 0x00 to indicate not to send Le **/
   666         -static int cackey_send_apdu(struct cackey_slot *slot, unsigned char class, unsigned char instruction, unsigned char p1, unsigned char p2, unsigned char lc, unsigned char *data, unsigned char le, uint16_t *respcode, unsigned char *respdata, size_t *respdata_len) {
          669  +static cackey_ret cackey_send_apdu(struct cackey_slot *slot, unsigned char class, unsigned char instruction, unsigned char p1, unsigned char p2, unsigned char lc, unsigned char *data, unsigned char le, uint16_t *respcode, unsigned char *respdata, size_t *respdata_len) {
   667    670   	uint8_t major_rc, minor_rc;
   668    671   	size_t bytes_to_copy, tmp_respdata_len;
   669    672   	DWORD protocol;
   670    673   	DWORD xmit_len, recv_len;
   671    674   	LONG scard_conn_ret, scard_xmit_ret, scard_reconn_ret;
   672    675   	BYTE xmit_buf[1024], recv_buf[1024];
   673    676   	int pcsc_connect_ret, pcsc_getresp_ret;
................................................................................
   674    677   	int idx;
   675    678   
   676    679   	CACKEY_DEBUG_PRINTF("Called.");
   677    680   
   678    681   	if (!slot) {
   679    682   		CACKEY_DEBUG_PRINTF("Invalid slot specified.");
   680    683   
   681         -		return(-1);
          684  +		return(CACKEY_PCSC_E_GENERIC);
   682    685   	}
   683    686   
   684    687   	pcsc_connect_ret = cackey_pcsc_connect();
   685         -	if (pcsc_connect_ret < 0) {
          688  +	if (pcsc_connect_ret != CACKEY_PCSC_S_OK) {
   686    689   		CACKEY_DEBUG_PRINTF("Connection to PC/SC failed, returning in failure");
   687    690   
   688         -		return(-1);
          691  +		return(CACKEY_PCSC_E_GENERIC);
   689    692   	}
   690    693   
   691    694   	/* Connect to reader, if needed */
   692    695   	if (!slot->pcsc_card_connected) {
   693    696   		CACKEY_DEBUG_PRINTF("SCardConnect(%s) called", slot->pcsc_reader);
   694    697   		scard_conn_ret = SCardConnect(*cackey_pcsc_handle, slot->pcsc_reader, SCARD_SHARE_SHARED, SCARD_PROTOCOL_T0, &slot->pcsc_card, &protocol);
   695    698   
   696    699   		if (scard_conn_ret != SCARD_S_SUCCESS) {
   697    700   			CACKEY_DEBUG_PRINTF("Connection to card failed, returning in failure (SCardConnect() = %s/%li)", CACKEY_DEBUG_FUNC_SCARDERR_TO_STR(scard_conn_ret), (long) scard_conn_ret);
   698    701   
   699         -			return(-1);
          702  +			return(CACKEY_PCSC_E_GENERIC);
   700    703   		}
   701    704   
   702    705   		slot->pcsc_card_connected = 1;
   703    706   	}
   704    707   
   705    708   	/* Transmit */
   706    709   	xmit_len = 0;
................................................................................
   736    739   
   737    740   				if (scard_xmit_ret != SCARD_S_SUCCESS) {
   738    741   					CACKEY_DEBUG_PRINTF("Retransmit failed, returning in failure after disconnecting the card (SCardTransmit = %s/%li)", CACKEY_DEBUG_FUNC_SCARDERR_TO_STR(scard_xmit_ret), (long) scard_xmit_ret);
   739    742   
   740    743   					SCardDisconnect(slot->pcsc_card, SCARD_RESET_CARD);
   741    744   					slot->pcsc_card_connected = 0;
   742    745   
   743         -					return(-1);
          746  +					return(CACKEY_PCSC_E_GENERIC);
   744    747   				}
   745    748   			} else {
   746    749   				CACKEY_DEBUG_PRINTF("Disconnecting card");
   747    750   
   748    751   				SCardDisconnect(slot->pcsc_card, SCARD_RESET_CARD);
   749    752   				slot->pcsc_card_connected = 0;
   750    753   
   751    754   				CACKEY_DEBUG_PRINTF("Returning in failure");
   752         -				return(-1);
          755  +				return(CACKEY_PCSC_E_GENERIC);
   753    756   			}
   754    757   		} else {
   755    758   			CACKEY_DEBUG_PRINTF("Disconnecting card");
   756    759   
   757    760   			SCardDisconnect(slot->pcsc_card, SCARD_RESET_CARD);
   758    761   			slot->pcsc_card_connected = 0;
   759    762   
   760    763   			CACKEY_DEBUG_PRINTF("Returning in failure");
   761         -			return(-1);
          764  +			return(CACKEY_PCSC_E_GENERIC);
   762    765   		}
   763    766   	}
   764    767   
   765    768   	CACKEY_DEBUG_PRINTBUF("Returned Value:", recv_buf, recv_len);
   766    769   
   767    770   	if (recv_len < 2) {
   768    771   		/* Minimal response length is 2 bytes, returning in failure */
   769    772   		CACKEY_DEBUG_PRINTF("Response too small, returning in failure (recv_len = %lu)", (unsigned long) recv_len);
   770    773   
   771         -		return(-1);
          774  +		return(CACKEY_PCSC_E_GENERIC);
   772    775   	}
   773    776   
   774    777   	/* Determine result code */
   775    778   	major_rc = recv_buf[recv_len - 2];
   776    779   	minor_rc = recv_buf[recv_len - 1];
   777    780   	if (respcode) {
   778    781   		*respcode = (major_rc << 8) | minor_rc;
................................................................................
   806    809   	}
   807    810   
   808    811   	if (major_rc == 0x61) {
   809    812   		/* We need to READ */
   810    813   		CACKEY_DEBUG_PRINTF("Buffer read required");
   811    814   
   812    815   		pcsc_getresp_ret = cackey_send_apdu(slot, GSCIS_CLASS_ISO7816, GSCIS_INSTR_GET_RESPONSE, 0x00, 0x00, 0, NULL, minor_rc, respcode, respdata, &tmp_respdata_len);
   813         -		if (pcsc_getresp_ret < 0) {
          816  +		if (pcsc_getresp_ret != CACKEY_PCSC_S_OK) {
   814    817   			CACKEY_DEBUG_PRINTF("Buffer read failed!  Returning in failure");
   815    818   
   816         -			return(-1);
          819  +			return(CACKEY_PCSC_E_GENERIC);
   817    820   		}
   818    821   
   819    822   		if (respdata_len) {
   820    823   			*respdata_len += tmp_respdata_len;
   821    824   		}
   822    825   
   823    826   		CACKEY_DEBUG_PRINTF("Returning in success (buffer read complete)");
   824         -		return(0);
          827  +		return(CACKEY_PCSC_S_OK);
   825    828   	}
   826    829   
   827    830   	if (major_rc == 0x90) {
   828    831   		/* Success */
   829    832   		CACKEY_DEBUG_PRINTF("Returning in success (major_rc = 0x90)");
   830    833   
   831         -		return(0);
          834  +		return(CACKEY_PCSC_S_OK);
   832    835   	}
   833    836   
   834    837   
   835    838   	CACKEY_DEBUG_PRINTF("APDU Returned an error, returning in failure");
   836    839   
   837         -	return(-1);
          840  +	return(CACKEY_PCSC_E_GENERIC);
   838    841   }
   839    842   
   840    843   static ssize_t cackey_read_buffer(struct cackey_slot *slot, unsigned char *buffer, size_t count, unsigned char t_or_v, size_t initial_offset) {
   841    844   	size_t offset = 0, max_offset, max_count;
   842    845   	unsigned char cmd[2];
   843    846   	uint16_t respcode;
   844    847   	int send_ret;
................................................................................
   861    864   		if (count > max_count) {
   862    865   			count = max_count;
   863    866   		}
   864    867   
   865    868   		cmd[1] = count;
   866    869   
   867    870   		send_ret = cackey_send_apdu(slot, GSCIS_CLASS_GLOBAL_PLATFORM, GSCIS_INSTR_READ_BUFFER, ((initial_offset + offset) >> 8) & 0xff, (initial_offset + offset) & 0xff, sizeof(cmd), cmd, 0x00, &respcode, buffer + offset, &count);
   868         -		if (send_ret < 0) {
          871  +		if (send_ret != CACKEY_PCSC_S_OK) {
   869    872   			if (respcode == 0x6A86) {
   870    873   				if (max_count == 1) {
   871    874   					break;
   872    875   				}
   873    876   
   874    877   				max_count = max_count / 2;
   875    878   
................................................................................
   891    894   	}
   892    895   
   893    896   	CACKEY_DEBUG_PRINTF("Returning in success, read %lu bytes", (unsigned long) offset);
   894    897   
   895    898   	return(offset);
   896    899   }
   897    900   
   898         -static int cackey_select_applet(struct cackey_slot *slot, unsigned char *aid, size_t aid_len) {
          901  +static cackey_ret cackey_select_applet(struct cackey_slot *slot, unsigned char *aid, size_t aid_len) {
   899    902   	int send_ret;
   900    903   
   901    904   	CACKEY_DEBUG_PRINTF("Called.");
   902    905   
   903    906   	CACKEY_DEBUG_PRINTBUF("Selecting applet:", aid, aid_len);
   904    907   
   905    908   	send_ret = cackey_send_apdu(slot, GSCIS_CLASS_ISO7816, GSCIS_INSTR_SELECT, GSCIS_PARAM_SELECT_APPLET, 0x0C, aid_len, aid, 0x00, NULL, NULL, NULL);
   906         -	if (send_ret < 0) {
          909  +	if (send_ret != CACKEY_PCSC_S_OK) {
   907    910   		CACKEY_DEBUG_PRINTF("Failed to open applet, returning in failure");
   908    911   
   909         -		return(-1);
          912  +		return(CACKEY_PCSC_E_GENERIC);
   910    913   	}
   911    914   
   912    915   	CACKEY_DEBUG_PRINTF("Successfully selected file");
   913    916   
   914         -	return(0);
          917  +	return(CACKEY_PCSC_S_OK);
   915    918   }
   916    919   
   917         -static int cackey_select_file(struct cackey_slot *slot, uint16_t ef) {
          920  +static cackey_ret cackey_select_file(struct cackey_slot *slot, uint16_t ef) {
   918    921   	unsigned char fid_buf[2];
   919    922   	int send_ret;
   920    923   
   921    924   	CACKEY_DEBUG_PRINTF("Called.");
   922    925   
   923    926   	/* Open the elementary file */
   924    927   	fid_buf[0] = (ef >> 8) & 0xff;
   925    928   	fid_buf[1] = ef & 0xff;
   926    929   
   927    930   	CACKEY_DEBUG_PRINTF("Selecting file: %04lx", (unsigned long) ef);
   928    931   
   929    932   	send_ret = cackey_send_apdu(slot, GSCIS_CLASS_ISO7816, GSCIS_INSTR_SELECT, 0x02, 0x0C, sizeof(fid_buf), fid_buf, 0x00, NULL, NULL, NULL);
   930         -	if (send_ret < 0) {
          933  +	if (send_ret != CACKEY_PCSC_S_OK) {
   931    934   		CACKEY_DEBUG_PRINTF("Failed to open file, returning in failure");
   932    935   
   933         -		return(-1);
          936  +		return(CACKEY_PCSC_E_GENERIC);
   934    937   	}
   935    938   
   936    939   	CACKEY_DEBUG_PRINTF("Successfully selected file");
   937    940   
   938         -	return(0);
          941  +	return(CACKEY_PCSC_S_OK);
   939    942   }
   940    943   
   941    944   static void cackey_free_tlv(struct cackey_tlv_entity *root) {
   942    945   	struct cackey_tlv_entity *curr, *next;
   943    946   
   944    947   	if (root == NULL) {
   945    948   		return;
................................................................................
  1167   1170   		certs_resizable = 1;
  1168   1171   	} else {
  1169   1172   		certs_resizable = 0;
  1170   1173   	}
  1171   1174   
  1172   1175   	/* Select the CCC Applet */
  1173   1176   	send_ret = cackey_select_applet(slot, ccc_aid, sizeof(ccc_aid));
  1174         -	if (send_ret < 0) {
         1177  +	if (send_ret != CACKEY_PCSC_S_OK) {
  1175   1178   		CACKEY_DEBUG_PRINTF("Unable to select CCC Applet, returning in failure");
  1176   1179   
  1177   1180   		return(NULL);
  1178   1181   	}
  1179   1182   
  1180   1183   	/* Read all the applets from the CCC's TLV */
  1181   1184   	ccc_tlv = cackey_read_tlv(slot);
................................................................................
  1202   1205   
  1203   1206   		memcpy(curr_aid, ccc_curr->value_cardurl->rid, sizeof(ccc_curr->value_cardurl->rid));
  1204   1207   		curr_aid[sizeof(curr_aid) - 2] = (ccc_curr->value_cardurl->appid >> 8) & 0xff;
  1205   1208   		curr_aid[sizeof(curr_aid) - 1] = ccc_curr->value_cardurl->appid & 0xff;
  1206   1209   
  1207   1210   		/* Select found applet ... */
  1208   1211   		select_ret = cackey_select_applet(slot, curr_aid, sizeof(curr_aid));
  1209         -		if (select_ret < 0) {
         1212  +		if (select_ret != CACKEY_PCSC_S_OK) {
  1210   1213   			CACKEY_DEBUG_PRINTF("Failed to select applet, skipping processing of this object");
  1211   1214   
  1212   1215   			continue;
  1213   1216   		}
  1214   1217   
  1215   1218   		/* ... and object (file) */
  1216   1219   		select_ret = cackey_select_file(slot, ccc_curr->value_cardurl->objectid);
  1217         -		if (select_ret < 0) {
         1220  +		if (select_ret != CACKEY_PCSC_S_OK) {
  1218   1221   			CACKEY_DEBUG_PRINTF("Failed to select file, skipping processing of this object");
  1219   1222   
  1220   1223   			continue;
  1221   1224   		}
  1222   1225   
  1223   1226   		/* Process this file's TLV looking for certificates */
  1224   1227   		app_tlv = cackey_read_tlv(slot);
................................................................................
  1267   1270   	if (certs_resizable) {
  1268   1271   		certs = realloc(certs, sizeof(*certs) * (*count));
  1269   1272   	}
  1270   1273   
  1271   1274   	return(certs);
  1272   1275   }
  1273   1276   
  1274         -static int cackey_login(struct cackey_slot *slot, unsigned char *pin, unsigned long pin_len, int *tries_remaining_p) {
         1277  +static cackey_ret cackey_login(struct cackey_slot *slot, unsigned char *pin, unsigned long pin_len, int *tries_remaining_p) {
  1275   1278   	uint16_t response_code;
  1276   1279   	int tries_remaining;
  1277   1280   	int send_ret;
  1278   1281   
  1279   1282   	/* Indicate that we do not know about how many tries are remaining */
  1280   1283   	if (tries_remaining_p) {
  1281   1284   		*tries_remaining_p = -1;
  1282   1285   	}
  1283   1286   
  1284   1287   	/* Issue PIN Verify */
  1285   1288   	send_ret = cackey_send_apdu(slot, GSCIS_CLASS_ISO7816, GSCIS_INSTR_VERIFY, 0x00, 0x00, pin_len, pin, 0x00, &response_code, NULL, NULL);
  1286         -	if (send_ret < 0) {
         1289  +	if (send_ret != CACKEY_PCSC_S_OK) {
  1287   1290   		if ((response_code & 0x63C0) == 0x63C0) {
  1288   1291   			tries_remaining = (response_code & 0xF);
  1289   1292   
  1290   1293   			CACKEY_DEBUG_PRINTF("PIN Verification failed, %i tries remaining", tries_remaining);
  1291   1294   
  1292   1295   			if (tries_remaining_p) {
  1293   1296   				*tries_remaining_p = tries_remaining;
  1294   1297   			}
         1298  +
         1299  +			return(CACKEY_PCSC_E_BADPIN);
  1295   1300   		}
  1296   1301   
  1297   1302   		if (response_code == 0x6983) {
  1298         -			return(CACKEY_LOGIN_LOCKED);
  1299         -		} else {
  1300         -			return(CACKEY_LOGIN_BADPIN);
         1303  +			CACKEY_DEBUG_PRINTF("PIN Verification failed, device is locked");
         1304  +
         1305  +			return(CACKEY_PCSC_E_LOCKED);
  1301   1306   		}
         1307  +
         1308  +		return(CACKEY_PCSC_E_GENERIC);
  1302   1309   	}
  1303   1310   
  1304         -	return(CACKEY_LOGIN_OK);
         1311  +	CACKEY_DEBUG_PRINTF("PIN Verification succeeded");
         1312  +
         1313  +	return(CACKEY_PCSC_S_OK);
  1305   1314   }
  1306   1315   
  1307   1316   /* Returns 1 if a token is in the specified slot, 0 otherwise */
  1308         -static int cackey_token_present(struct cackey_slot *slot) {
         1317  +static cackey_ret cackey_token_present(struct cackey_slot *slot) {
  1309   1318   	unsigned char ccc_aid[] = {GSCIS_AID_CCC};
  1310   1319   	int send_ret;
  1311   1320   
  1312   1321   	/* Select the CCC Applet */
  1313   1322   	send_ret = cackey_select_applet(slot, ccc_aid, sizeof(ccc_aid));
  1314         -	if (send_ret < 0) {
  1315         -		return(0);
         1323  +	if (send_ret != CACKEY_PCSC_S_OK) {
         1324  +		return(CACKEY_PCSC_S_TOKENABSENT);
  1316   1325   	}
  1317   1326   
  1318         -	return(1);
         1327  +	return(CACKEY_PCSC_S_TOKENPRESENT);
  1319   1328   }
  1320   1329   
  1321   1330   /* Returns 0 on success */
  1322   1331   static int cackey_mutex_create(void **mutex) {
  1323   1332   	pthread_mutex_t *pthread_mutex;
  1324   1333   	int pthread_retval;
  1325   1334   	CK_RV custom_retval;
................................................................................
  1961   1970   
  1962   1971   			cackey_slots[currslot].active = 0;
  1963   1972   		}
  1964   1973   	}
  1965   1974   
  1966   1975   	/* Determine list of readers */
  1967   1976   	pcsc_connect_ret = cackey_pcsc_connect();
  1968         -	if (pcsc_connect_ret < 0) {
         1977  +	if (pcsc_connect_ret != CACKEY_PCSC_S_OK) {
  1969   1978   		CACKEY_DEBUG_PRINTF("Connection to PC/SC failed, assuming no slots");
  1970   1979   
  1971   1980   		slot_count = 0;
  1972   1981   	} else {
  1973   1982   		pcsc_readers_len = 0;
  1974   1983   
  1975   1984   		scard_listreaders_ret = SCardListReaders(*cackey_pcsc_handle, NULL, NULL, &pcsc_readers_len);
................................................................................
  2099   2108   	if (sizeof(pInfo->manufacturerID) < bytes_to_copy) {
  2100   2109   		bytes_to_copy = sizeof(pInfo->manufacturerID);
  2101   2110   	}
  2102   2111   	memcpy(pInfo->manufacturerID, cackey_slots[slotID].pcsc_reader, bytes_to_copy);
  2103   2112   
  2104   2113   	pInfo->flags = 0;
  2105   2114   
  2106         -	if (cackey_token_present(&cackey_slots[slotID])) {
         2115  +	if (cackey_token_present(&cackey_slots[slotID]) == CACKEY_PCSC_S_TOKENPRESENT) {
  2107   2116   		pInfo->flags |= CKF_TOKEN_PRESENT;
  2108   2117   	}
  2109   2118   
  2110   2119   	pInfo->hardwareVersion.major = (cackey_getversion() >> 16) & 0xff;
  2111   2120   	pInfo->hardwareVersion.minor = (cackey_getversion() >> 8) & 0xff;
  2112   2121   
  2113   2122   	pInfo->firmwareVersion.major = 0x00;
................................................................................
  2145   2154   
  2146   2155   	if (!cackey_initialized) {
  2147   2156   		CACKEY_DEBUG_PRINTF("Error.  Not initialized.");
  2148   2157   
  2149   2158   		return(CKR_CRYPTOKI_NOT_INITIALIZED);
  2150   2159   	}
  2151   2160   
  2152         -	if (!cackey_token_present(&cackey_slots[slotID])) {
         2161  +	if (cackey_token_present(&cackey_slots[slotID]) != CACKEY_PCSC_S_TOKENPRESENT) {
  2153   2162   		CACKEY_DEBUG_PRINTF("No token is present in slotID = %lu", slotID);
  2154   2163   
  2155   2164   		return(CKR_TOKEN_NOT_PRESENT);
  2156   2165   	}
  2157   2166   
  2158   2167   	memset(pInfo->label, ' ', sizeof(pInfo->label));
  2159   2168   	if (1) {
................................................................................
  2375   2384   	if (!cackey_initialized) {
  2376   2385   		CACKEY_DEBUG_PRINTF("Error.  Not initialized.");
  2377   2386   
  2378   2387   		return(CKR_CRYPTOKI_NOT_INITIALIZED);
  2379   2388   	}
  2380   2389   
  2381   2390   	/* Verify that the card is actually in the slot. */
  2382         -	if (!cackey_token_present(&cackey_slots[slotID])) {
         2391  +	if (cackey_token_present(&cackey_slots[slotID]) != CACKEY_PCSC_S_TOKENPRESENT) {
  2383   2392   		CACKEY_DEBUG_PRINTF("Error.  Card not present.  Returning CKR_DEVICE_REMOVED");
  2384   2393   
  2385   2394   		return(CKR_DEVICE_REMOVED);
  2386   2395   	}
  2387   2396   
  2388   2397   	mutex_retval = cackey_mutex_lock(cackey_biglock);
  2389   2398   	if (mutex_retval != 0) {
................................................................................
  2676   2685   
  2677   2686   		CACKEY_DEBUG_PRINTF("Error.  Session not active.");
  2678   2687   		
  2679   2688   		return(CKR_SESSION_HANDLE_INVALID);
  2680   2689   	}
  2681   2690   
  2682   2691   	login_ret = cackey_login(&cackey_slots[cackey_sessions[hSession].slotID], pPin, ulPinLen, NULL);
  2683         -	if (login_ret != CACKEY_LOGIN_OK) {
         2692  +	if (login_ret != CACKEY_PCSC_S_OK) {
  2684   2693   		cackey_mutex_unlock(cackey_biglock);
  2685   2694   
  2686         -		if (login_ret == CACKEY_LOGIN_LOCKED) {
         2695  +		if (login_ret == CACKEY_PCSC_E_LOCKED) {
  2687   2696   			CACKEY_DEBUG_PRINTF("Error.  Token is locked.");
  2688   2697   
  2689   2698   			return(CKR_PIN_LOCKED);
  2690         -		} else {
         2699  +		} else if (login_ret == CACKEY_PCSC_E_BADPIN) {
  2691   2700   			CACKEY_DEBUG_PRINTF("Error.  Invalid PIN.");
  2692   2701   
  2693   2702   			return(CKR_PIN_INCORRECT);
  2694   2703   		}
         2704  +
         2705  +		CACKEY_DEBUG_PRINTF("Error.  Unknown error returned from cackey_login() (%i)", login_ret);
         2706  +
         2707  +		return(CKR_GENERAL_ERROR);
  2695   2708   	}
  2696   2709   
  2697   2710   	cackey_sessions[hSession].state = CKS_RO_USER_FUNCTIONS;
  2698   2711   
  2699   2712   	mutex_retval = cackey_mutex_unlock(cackey_biglock);
  2700   2713   	if (mutex_retval != 0) {
  2701   2714   		CACKEY_DEBUG_PRINTF("Error.  Unlocking failed.");