自学教程：C++ EstEID_log函数代码示例

void *getNativeWindowHandle(PluginInstance *obj) {	void *nativeWindowHandle = obj->nativeWindowHandle;#ifdef _WIN32	EstEID_log("_WIN32 detected, forcing nativeWindowHandle query from browser");	nativeWindowHandle = 0;#endif	if (!nativeWindowHandle) {		browserFunctions->getvalue(obj->npp, NPNVnetscapeWindow, &nativeWindowHandle);		EstEID_log("reading nativeWindowHandle=%p from browserFunctions", nativeWindowHandle);	}	else {		EstEID_log("reading nativeWindowHandle=%p from PluginInstance", nativeWindowHandle);	}	return nativeWindowHandle;}

int EstEID_getSlotId(char* certId, CK_SLOT_ID* slotId) {	int certIndex;	EstEID_Certs *certs = EstEID_loadCerts();	EstEID_log("certs loaded");	if (!certs) {		EstEID_log("%s", EstEID_error);		return FALSE;	}	else if ((certIndex = EstEID_findNonRepuditionCert(certs, certId)) == NOT_FOUND) {		EstEID_log("card is changed");		return FALSE;	}	*slotId = certs->slotIDs[certIndex];	return TRUE;}

void CEstEIDCertificate::readFromCertContext() {	LOG_LOCATION;	PCCERT_CONTEXT pCertContext = NULL;	HCERTSTORE hCertStore = NULL;	CRYPTUI_SELECTCERTIFICATE_STRUCT sel = {sizeof(sel)};	int counter = 0;	hCertStore = CertOpenStore(CERT_STORE_PROV_SYSTEM, 0, NULL, CERT_SYSTEM_STORE_CURRENT_USER | CERT_STORE_READONLY_FLAG, L"MY");	if(!hCertStore){		throw CryptoException();	}	sel.pvCallbackData = &counter;	sel.pFilterCallback = filter_proc;	sel.rghDisplayStores = &hCertStore;	sel.cDisplayStores = 1;	#ifdef _SEB_BUILD		EstEID_log("SEB build");	PCCERT_CONTEXT pCertContextForEnumeration = NULL;	int certificatesCount = 0;	while(pCertContextForEnumeration = CertEnumCertificatesInStore(hCertStore, pCertContextForEnumeration)) {		if(isValidForSigning(pCertContextForEnumeration)) {			certificatesCount++;				pCertContext = pCertContextForEnumeration;		}	}	EstEID_log("Certificates count %i", certificatesCount);	if(certificatesCount != 1) {		pCertContext = CryptUIDlgSelectCertificate(&sel);	}#else	pCertContext = CryptUIDlgSelectCertificate(&sel);#endif	if(!pCertContext) {		EstEID_log("User didn't select sertificate");		throw CryptoException(ESTEID_USER_CANCEL);	}	loadCertContexts(pCertContext);	if(pCertContext){		CertFreeCertificateContext(pCertContext);	}	if(hCertStore) {		CertCloseStore(hCertStore, CERT_CLOSE_STORE_FORCE_FLAG);	}}

void EstEID_logInitInfo(CK_INFO info) {	char *libraryDescription = EstEID_createString(info.libraryDescription, 32);	char *manufacturerID = EstEID_createString(info.manufacturerID, 32);	EstEID_log("cryptoki %i.%i, library %i.%i %s, %s", info.cryptokiVersion.major, info.cryptokiVersion.minor, info.libraryVersion.major, info.libraryVersion.minor, libraryDescription, manufacturerID);	free(libraryDescription);	free(manufacturerID);}

int EstEID_isPinPad(CK_SLOT_ID slotID) {	CK_TOKEN_INFO tokenInfo;	if (EstEID_CK_failure("C_GetTokenInfo", fl->C_GetTokenInfo(slotID, &tokenInfo))) return 0;	EstEID_log("flags: %li (%lx)", tokenInfo.flags, tokenInfo.flags);	if (tokenInfo.flags & CKF_PROTECTED_AUTHENTICATION_PATH) return 1;	else return 0;}

THREAD_RETURN_TYPE EstEID_pinPadLogin(void* threadData) {#ifndef _WIN32	LOG_LOCATION;	pthread_mutex_lock(&pinpad_thread_mutex);	CK_SESSION_HANDLE session = ((EstEID_PINPadThreadData*)threadData)->session;	CK_RV loginResult = fl->C_Login(session, CKU_USER, NULL, 0);			((EstEID_PINPadThreadData*)threadData)->result = loginResult;	closePinPadModalSheet();	EstEID_log("modal sheet/dialog destroyed");	pinpad_thread_completed = TRUE;	pthread_cond_broadcast(&pinpad_thread_condition);	pthread_mutex_unlock(&pinpad_thread_mutex);	pthread_exit(NULL);#else	EstEID_PINPromptDataEx* pinPromptDataEx;	LOG_LOCATION;	WaitForSingleObject(pinpad_thread_mutex, INFINITE);	pinPromptDataEx = (EstEID_PINPromptDataEx*)threadData;	pinPromptDataEx->pinPromptData.promptFunction(NULL, pinPromptDataEx->name, pinPromptDataEx->message, 0, TRUE);		ReleaseMutex(pinpad_thread_mutex);	return TRUE;#endif}

void EstEID_logBase64(char *message, char* data, int dataLength) {	char *base64;	LOG_LOCATION;	base64 = EstEID_base64Encode(data, dataLength);	EstEID_log(message, base64);	free(base64);}

INT_PTR CALLBACK PinPadDialogProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {			switch(message) {		case WM_INITDIALOG:			dialogWindowHandle = hwnd;						SetPinDialogLabels(dialogWindowHandle, lParam);			SetDialogItemText(hwnd, IDC_PINPAD_PIN2_LABEL, l10n("For signing enter PIN2 from PIN pad"));			countdownValue = 30; // in seconds			EstEID_log("initializing pinpad countdown timer with value %i", countdownValue);			SendMessage(GetDlgItem(dialogWindowHandle, IDC_PROGRESSBAR), PBM_SETSTATE, (WPARAM)PBST_PAUSED, 0L);			SendMessage(GetDlgItem(dialogWindowHandle, IDC_PROGRESSBAR), PBM_SETRANGE, 0, MAKELPARAM(0, countdownValue));			UpdateProgerssBar(dialogWindowHandle, countdownValue);			SendMessage(GetDlgItem(dialogWindowHandle, IDC_PROGRESSBAR), PBM_SETSTATE, (WPARAM)PBST_NORMAL, 0L);			SetTimer(dialogWindowHandle, 1, 1000, NULL);			break;		case WM_DESTROY:			KillCountdownTimer();			break;		case WM_TIMER:			CountdownTimerProc();			break;		case WM_CTLCOLORSTATIC:			if(GetDlgItem(hwnd, IDC_ERROR) == ((HWND)lParam)){				return SetMessageLabelColorToRed(wParam);			}		default:						return false;	}	return DefWindowProc(hwnd, message, wParam, lParam);	}

static GtkTreeModel* createAndFillModel() {	GtkListStore *certificatesList = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);	GtkTreeIter iterator;	char *validTo = NULL;		EstEID_Certs *certs = EstEID_loadCerts();	EstEID_log("%i certificates found", certs->count);	for(int i = 0; i < certs->count; i++) {		EstEID_Map cert = certs->certs[i];		if (!EstEID_mapGet(cert, "usageNonRepudiation")) continue;		validTo = getDateFromDateTime(EstEID_mapGet(cert, "validTo"));		gtk_list_store_append(certificatesList, &iterator);		gtk_list_store_set(certificatesList, &iterator,			0, EstEID_mapGet(cert, "commonName"),			1, EstEID_mapGet(cert, "organizationName"),			2, validTo,			3, EstEID_mapGet(cert, "certHash"),			-1);		if(validTo) {						free(validTo);			validTo = NULL;		}	}	return GTK_TREE_MODEL(certificatesList);}

int promptForCertificate(void *nativeWindowHandle, char* certId) {	certId[0] = '/0';	GtkWidget *window = getGtkWindow(nativeWindowHandle);	GtkWidget *dialog = gtk_dialog_new_with_buttons("Select certificate", GTK_WINDOW(window), // ToDo l10n		GTK_DIALOG_DESTROY_WITH_PARENT,		GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,		GTK_STOCK_OK, GTK_RESPONSE_OK,		NULL);	GtkWidget* certificatesView = createCertificateSelectionView(dialog);	gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK, FALSE);		gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), certificatesView);	setDialogProperties(dialog, window);	gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);	gtk_widget_show_all(dialog);	gint result = gtk_dialog_run(GTK_DIALOG(dialog));	gtk_widget_hide(dialog);	int returnValue = IDCANCEL;	if (result == GTK_RESPONSE_OK) {		GtkTreeSelection* selectedRow = gtk_tree_view_get_selection(GTK_TREE_VIEW(certificatesView));		GtkTreeModel* model = NULL;		GtkTreeIter iter;		if(gtk_tree_selection_get_selected(selectedRow, &model, &iter)){			gchar* id;			gtk_tree_model_get(model, &iter, 3, &id, -1);			strcpy(certId, id);			g_free(id);			returnValue = IDOK;			EstEID_log("promptForCertificate dialog returned cert ID %s", certId);		}		else {			EstEID_log("promptForCertificate dialog returned without cert selection");		}	}	else {				EstEID_log("promptForCertificate dialog canceled by user");	}	gtk_widget_destroy(dialog);	return returnValue;}

bool certGetProperty(CertInstance *obj, NPIdentifier name, NPVariant *variant) {	NPUTF8* nameString = browserFunctions->utf8fromidentifier(name);	EstEID_log("name=%s", (char *)nameString);	const char *result = EstEID_mapGet(obj->certInfo, EstEID_getCertPropertyName(nameString));	browserFunctions->memfree(nameString);	if (result) return copyStringToNPVariant(result, variant);	return false;}

int EstEID_tokensChanged() {  LOG_LOCATION;	CK_SLOT_ID slotID;	int changed = FALSE;	while (fl->C_WaitForSlotEvent(CKF_DONT_BLOCK, &slotID, NULL_PTR) == CKR_OK) {    EstEID_log("C_WaitForSlotEvent() pass cycle 1");		changed = TRUE;	}	if (!changed) {		while (fl->C_WaitForSlotEvent(CKF_DONT_BLOCK, &slotID, NULL_PTR) == CKR_OK) {      EstEID_log("C_WaitForSlotEvent() pass cycle 2");			changed = TRUE;		}	}    EstEID_log("tokens change %sdetected", changed ? "" : "not ");	return changed;}

int EstEID_CK_failure(const char *name, CK_RV result) {	EstEID_clear_error();	if (result == CKR_OK || result == CKR_CRYPTOKI_ALREADY_INITIALIZED) return FAILURE;	sprintf(EstEID_error, "%s error: %s (%li)", name, pkcs11_error_message(result), result);	EstEID_errorCode = ESTEID_PKCS11_ERROR;	EstEID_log("cryptoki error: %s", EstEID_error);	return SUCCESS;}

char *EstEID_sign(char *certId, char *hash, EstEID_PINPromptData pinPromptData) {		EstEID_log("called, hash=%s", hash);	char *signature = NULL;	int i;	EstEID_log("calling EstEID_loadCerts()");	EstEID_Certs *certs = EstEID_loadCerts();	EstEID_log("certs loaded");	if (!certs) {		EstEID_log("%s", EstEID_error);	}	else if ((i = EstEID_findNonRepuditionCert(certs, certId)) == NOT_FOUND) {		snprintf(EstEID_error, sizeof(EstEID_error) - 1, "no cert has ID: %s", certId);		EstEID_errorCode = ESTEID_CERT_NOT_FOUND_ERROR;		EstEID_error[sizeof(EstEID_error) - 1] = 0;		EstEID_log("%s", EstEID_error);	}	else if (EstEID_signHashHex(&signature, certs->slotIDs[i], certs->certs[i], hash, pinPromptData)) {		EstEID_log("signature=%s", signature);	}	else {		EstEID_log("%s", EstEID_error);	}	free(certId);	free(hash);	return signature;}

int EstEID_md5_failure(void *ptr) {	EstEID_clear_error();	if (ptr) return FALSE;	snprintf(EstEID_error, sizeof(EstEID_error) - 1, "Cert id creation failed");	EstEID_errorCode = ESTEID_MD5_ERROR;	EstEID_error[sizeof(EstEID_error) - 1] = 0;	EstEID_log("%s", EstEID_error);	return TRUE;}

bool isAllowedSite() {	if(!allowedSite) {		sprintf(EstEID_error, "Site is not allowed");		EstEID_errorCode = ESTEID_SITE_NOT_ALLOWED;		EstEID_log("called from forbidden site");		return false;	}	return true;}

int EstEID_dl_failure(const char *name, void *ptr) {	EstEID_clear_error();	if (ptr) return FALSE;	snprintf(EstEID_error, sizeof(EstEID_error) - 1, "%s failed: %s", name, library_error());	EstEID_errorCode = ESTEID_LIBRARY_LOAD_ERROR;	EstEID_error[sizeof(EstEID_error) - 1] = 0;	EstEID_log("dl error: %s", EstEID_error);	return TRUE;}

std::string CEstEIDCertificate::dateToString(FILETIME *filetime) {	EstEID_log("");	SYSTEMTIME systemtime;	FileTimeToSystemTime(filetime, &systemtime);	char buf[40] = {0};	sprintf_s(buf, "%02d.%02d.%04d %02d:%02d:%02d", systemtime.wDay, systemtime.wMonth, systemtime.wYear, systemtime.wHour, systemtime.wMinute, systemtime.wSecond);	std::string result = buf;	return result;}

int EstEID_getRemainingTries(CK_SLOT_ID slotID) {	CK_TOKEN_INFO tokenInfo;	if (EstEID_CK_failure("C_GetTokenInfo", fl->C_GetTokenInfo(slotID, &tokenInfo))) return -1;	EstEID_log("flags: %li (%lx)", tokenInfo.flags, tokenInfo.flags);	if (tokenInfo.flags & CKF_USER_PIN_LOCKED) return 0;	else if (tokenInfo.flags & CKF_USER_PIN_FINAL_TRY) return 1;	else if (tokenInfo.flags & CKF_USER_PIN_COUNT_LOW) return 2;	else return 3;}

int EstEID_startInitializeCryptokiThread() {	LOG_LOCATION;	initialization_result = -1;	FAIL_IF_THREAD_ERROR("CreateMutex", (initialization_mutex = CreateMutex(NULL, FALSE, NULL)));	EstEID_log("initialization_mutex = %p", initialization_mutex);	DWORD threadId;	FAIL_IF_THREAD_ERROR("CreateThread", CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&EstEID_initializeCryptokiThread, NULL, 0, &threadId));		return SUCCESS;}

INT_PTR CALLBACK CertSelectionDialogProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {		static char* selectedCertID;	switch(message) {		case WM_INITDIALOG:			buildCertificatesList(hwnd);			selectedCertID = (char*)lParam;			selectedCertID[0] = '/0';			break;		case WM_COMMAND:			switch(LOWORD(wParam)) {				case IDOK: {					int index = ListView_GetNextItem(GetDlgItem(hwnd, IDC_CERTIFICATESLIST), -1, LVNI_SELECTED);					TCHAR unicodeSelectedCertID[256];					ListView_GetItemText(GetDlgItem(hwnd, IDC_CERTIFICATESLIST), index, 3, (LPTSTR)unicodeSelectedCertID, 33);					strcpy(selectedCertID, CW2A(unicodeSelectedCertID));					EstEID_log("selected certificate id in dialog proc: %s", selectedCertID);				}				default:					EndDialog(hwnd, LOWORD(wParam));			}				break;		case WM_NOTIFY:						if(wParam == IDC_CERTIFICATESLIST) {				switch(((LPNMHDR)lParam)->code) {					case LVN_ITEMCHANGED:					case NM_CLICK:						Button_Enable(GetDlgItem(hwnd, IDOK), ((LPNMITEMACTIVATE)lParam)->iItem != -1);						break;					case LVN_ITEMACTIVATE: {						int selectedCertIndex = ((LPNMITEMACTIVATE)lParam)->iItem;						TCHAR unicodeSelectedCertID[256];						ListView_GetItemText(GetDlgItem(hwnd, IDC_CERTIFICATESLIST), selectedCertIndex, 3, (LPTSTR)unicodeSelectedCertID, 33);						strcpy(selectedCertID, CW2A(unicodeSelectedCertID));						EstEID_log("dblcklicked certificate id in dialog proc: %s", selectedCertID);						EndDialog(hwnd, LOWORD(wParam));					}				}			}					default:			return false;	}	return DefWindowProc(hwnd, message, wParam, lParam);	}

char *promptForPIN(void *nativeWindowHandle, const char *name, const char *message) {	GtkWidget *window = getGtkWindow(nativeWindowHandle);	GtkWidget *entry = gtk_entry_new();	GtkWidget *dialog = createDialog(window, entry, name, message);	gint result = gtk_dialog_run(GTK_DIALOG(dialog));	gtk_widget_hide(dialog);	char *pin;	if (result == GTK_RESPONSE_OK) {		pin = strdup(gtk_entry_get_text(GTK_ENTRY(entry)));		EstEID_log("promptForPIN/t got pin");	}	else {		pin = strdup("");		EstEID_log("promptForPIN/t user canceled");	}	gtk_widget_destroy(dialog);	return pin;}

void CEstEIDIEPluginBHO::mapInternalErrorCodes(unsigned int code) {	EstEID_log("Mapping error code %Xh:", code, code);	if(code == ESTEID_USER_CANCEL || code == 0x3E5 || code == 0xB7 || code == 0x05DE || code == SCARD_W_CANCELLED_BY_USER){ // 0x03E5 for ???; 0x05DE for SL base package; SCARD_W_CANCELLED_BY_USER (0x8010006E) for SK base package		EstEID_log("    mapped to ESTEID_USER_CANCEL (%Xh)", ESTEID_USER_CANCEL);		setError(ESTEID_USER_CANCEL);	}	else if(code == 0x80092004){				EstEID_log("    mapped to ESTEID_CERT_NOT_FOUND_ERROR (%Xh)", ESTEID_CERT_NOT_FOUND_ERROR);		setError(ESTEID_CERT_NOT_FOUND_ERROR);	}	else if(code > 0x80000000) {				EstEID_log("    mapped to ESTEID_CRYPTO_API_ERROR (%Xh)", ESTEID_CRYPTO_API_ERROR);		setError(ESTEID_CRYPTO_API_ERROR);	}	else {		EstEID_log("    mapped to ESTEID_UNKNOWN_ERROR (%Xh)", ESTEID_UNKNOWN_ERROR);		setError(ESTEID_UNKNOWN_ERROR);	}}

char *EstEID_getLocaleFromEnvironment() {	char *result = NULL;	char *lang = getenv("LANG");	if (lang && strlen(lang) >= 2) {		result = (char *)malloc(3);		strncpy(result, lang, 2);		result[2] = 0;		EstEID_log("locale from getenv('LANG'): %s => %s", lang, result);	}	return result;}

char *promptForPIN(void *nativeWindowHandle, const char *name, const char *message) {	char *pin2;	DialogData dialogData;	dialogData.pin2[0] = '/0';	dialogData.name = name;	dialogData.message = message;	INT_PTR result = DialogBoxParamW(pluginInstance, MAKEINTRESOURCEW(IDD_PIN_DIALOG), (HWND)nativeWindowHandle, Pin2DialogProc, (LPARAM)&dialogData);	if (result == IDOK) {				pin2 = strdup(dialogData.pin2);		memset(dialogData.pin2, '/0', PIN2_MAX_LEN + 2);		EstEID_log("promptForPIN/t got pin");	}	else {		pin2 = strdup("");		EstEID_log("promptForPIN/t user canceled");	}		return pin2;}

bool doGetCertificate(PluginInstance *obj, NPVariant *result) {	LOG_LOCATION;	FAIL_IF_NOT_ALLOWED_SITE;	char selectedCertID[33];	int dlg_result = 0;	#ifdef _WIN32	HWND ownerWindowHandle = (HWND)getNativeWindowHandle(obj);	EstEID_log("owner window handle passed to DialogBoxParam() = %08X", ownerWindowHandle);	dlg_result = (int)DialogBoxParam(pluginInstance, MAKEINTRESOURCE(IDD_CERTIFICATESELECTIONDLG), ownerWindowHandle, CertSelectionDialogProc, (LPARAM)selectedCertID);#else	dlg_result = promptForCertificate(getNativeWindowHandle(obj), selectedCertID);#endif	EstEID_log("Certificate selection dialog result = %i", dlg_result);	EstEID_log("Selected certificate ID = %s", selectedCertID);	if(dlg_result == IDCANCEL) {		sprintf(EstEID_error, "User canceled");		EstEID_errorCode = ESTEID_USER_CANCEL;		EstEID_log("EstEID_error = %s", EstEID_error);		browserFunctions->setexception(&obj->header, EstEID_error);			return false;	}		CertInstance *certInstance = (CertInstance *)browserFunctions->createobject(obj->npp, certClass());	certInstance->npp = obj->npp;	certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCertById(selectedCertID));//	certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCert());	EstEID_log("certObject=%p", certInstance);	OBJECT_TO_NPVARIANT((NPObject *)certInstance, *result);	EstEID_log("result=%p", result);		return true;}

bool doSign(PluginInstance *obj, NPVariant *args, unsigned argCount, NPVariant *result) {	EstEID_log("obj=%p, name=sign argCount=%u", obj, argCount);	FAIL_IF_NOT_ALLOWED_SITE;	if (argCount < 2) {		browserFunctions->setexception(&obj->header, "Missing arguments");		return false;	}		if(argCount > 2 && NPVARIANT_IS_OBJECT(args[2])){		strncpy(pluginLanguage, getLanguageFromOptions(obj, args[2]), 2);	}	EstEID_setLocale(pluginLanguage);	if(argCount > 3 && NPVARIANT_IS_OBJECT(args[3])){		strcpy(promptMessage, createStringFromNPVariant(args[3]));	}	void* wnd = getNativeWindowHandle(obj);	EstEID_PINPromptData pinPromptData = {promptForPIN, showAlert, wnd, promptMessage, NULL};	NPUTF8* certId = createStringFromNPVariant(&args[0]);	NPUTF8* hash = createStringFromNPVariant(&args[1]);	char *signature = NULL;	signature = EstEID_sign(certId, hash, pinPromptData);	LOG_LOCATION	if (signature) {		copyStringToNPVariant(signature, result);		free(signature);		return true;	}	else {		EstEID_log("EstEID_error=%s", EstEID_error);		browserFunctions->setexception(&obj->header, EstEID_error);		return false;	}}

bool pluginGetProperty(PluginInstance *obj, NPIdentifier name, NPVariant *variant) {	LOG_LOCATION;	if (isSameIdentifier(name, "version"))		return copyStringToNPVariant(ESTEID_PLUGIN_VERSION, variant);	else if (isSameIdentifier(name, "errorMessage")){		EstEID_log("Reading error message: %s", EstEID_error);		return copyStringToNPVariant(EstEID_error, variant);	}	else if (isSameIdentifier(name, "errorCode")) {		INT32_TO_NPVARIANT(EstEID_errorCode, *variant);		EstEID_log("returning errorCode=%i", EstEID_errorCode);		return true;	}	else if (isSameIdentifier(name, "authCert") || isSameIdentifier(name, "signCert")){		return doGetCertificate(obj, variant);	}	else if (isSameIdentifier(name, "pluginLanguage")){		return copyStringToNPVariant(pluginLanguage, variant);	}	EstEID_log("returning false");	return false;}

BOOL CEstEidPin2Dlg::OnInitDialog() {	LOG_LOCATION;	CDialog::OnInitDialog();	WCHAR label[512];	int certIndex;	EstEID_Certs *certs = EstEID_loadCerts();	if (!certs) {		EstEID_log("no certs found");	}	else if ((certIndex = EstEID_findNonRepuditionCert(certs, ATL::CW2A(this->certId))) == NOT_FOUND) {		EstEID_log("card is changed");	}	EstEID_Map cert = certs->certs[certIndex];	char* name = EstEID_getFullNameWithPersonalCode(cert);	MultiByteToWideChar(CP_UTF8, 0, name, -1, label, sizeof(label) / sizeof(WCHAR));	this->SetWindowText(label);	SetDlgItemText(IDC_NAME, label);	this->pin2MinLen = (unsigned)atoi(EstEID_mapGet(cert, "minPinLen"));	free(name);	MultiByteToWideChar(CP_UTF8, 0, l10n("For signing enter PIN2:"), -1, label, sizeof(label) / sizeof(WCHAR));	SetDlgItemText(IDC_PIN2_LABEL, label);	MultiByteToWideChar(CP_UTF8, 0, l10n("Sign"), -1, label, sizeof(label) / sizeof(WCHAR));	SetDlgItemText(IDOK, label);	MultiByteToWideChar(CP_UTF8, 0, l10n("Cancel"), -1, label, sizeof(label) / sizeof(WCHAR));	SetDlgItemText(IDCANCEL, label);	SetDlgItemText(IDC_ERROR, L"");	EndDialogIfPIN2Blocked(SetUpPin2Dialog());	return TRUE;}