//* Microsoft Windows ** //* Copyright(c) Microsoft Corp., 1999 ** //********************************************************************* // // MSOBMAIN.CPP - Header for the implementation of CObMain // // HISTORY: // // 1/27/99 a-jaswed Created. // // Class which will provide the an IOleSite to the WebOC #include "userinfo.h" #include "appdefs.h" #include "dispids.h" #include "windowsx.h" #include "msobmain.h" #include "pid.h" #include "msobmain.h" #include "resource.h" #include "shlwapi.h" #define USER_INFO_INIFILE OEMINFO_INI_FILENAME #define USER_COMP_MANF_SEC L"General" #define USER_COMP_MANF_KEY L"Manufacturer" #define USERINFO_REG_KEY_FIRSTNAME L"FirstName" #define USERINFO_REG_KEY_MIDDLEINITIAL L"MiddleInitial" #define USERINFO_REG_KEY_LASTNAME L"LastName" #define USERINFO_REG_KEY_FURIGANANAME L"FuriganaName" #define USERINFO_REG_KEY_COMPANYNAME L"CompanyName" #define USERINFO_REG_KEY_ADDRESS1 L"Address1" #define USERINFO_REG_KEY_ADDRESS2 L"Address2" #define USERINFO_REG_KEY_CITY L"City" #define USERINFO_REG_KEY_STATE L"State" #define USERINFO_REG_KEY_ZIP L"Zip" #define USERINFO_REG_KEY_COUNTRY L"Country" #define USERINFO_REG_KEY_PRIMARYEMAIL L"PrimaryEmail" #define USERINFO_REG_KEY_SECONDARYEMAIL L"SecondaryEmail" #define USERINFO_REG_KEY_AREACODE L"AreaCode" #define USERINFO_REG_KEY_PHONENUMBER L"PhoneNumber" #define USERINFO_REG_KEY_IDENTITY L"Identity" #define USERINFO_REG_KEY_OWNERNAME L"OwnerName" #define USERINFO_REG_KEY_DEFAULTNEWUSER L"DefaultNewUser" #define DEFAULT_USEIDENTITIES TRUE DISPATCHLIST UserInfoExternalInterface[] = { {L"get_FirstName", DISPID_USERINFO_GET_FIRSTNAME }, {L"set_FirstName", DISPID_USERINFO_SET_FIRSTNAME }, {L"get_MiddleInitial", DISPID_USERINFO_GET_MIDDLEINITIAL }, {L"set_MiddleInitial", DISPID_USERINFO_SET_MIDDLEINITIAL }, {L"get_LastName", DISPID_USERINFO_GET_LASTNAME }, {L"set_LastName", DISPID_USERINFO_SET_LASTNAME }, {L"get_FuriganaName", DISPID_USERINFO_GET_FURIGANANAME }, {L"set_FuriganaName", DISPID_USERINFO_SET_FURIGANANAME }, {L"get_CompanyName", DISPID_USERINFO_GET_COMPANYNAME }, {L"set_CompanyName", DISPID_USERINFO_SET_COMPANYNAME }, {L"get_Address1", DISPID_USERINFO_GET_ADDRESS1 }, {L"set_Address1", DISPID_USERINFO_SET_ADDRESS1 }, {L"get_Address2", DISPID_USERINFO_GET_ADDRESS2 }, {L"set_Address2", DISPID_USERINFO_SET_ADDRESS2 }, {L"get_City", DISPID_USERINFO_GET_CITY }, {L"set_City", DISPID_USERINFO_SET_CITY }, {L"get_State", DISPID_USERINFO_GET_STATE }, {L"set_State", DISPID_USERINFO_SET_STATE }, {L"get_Zip", DISPID_USERINFO_GET_ZIP }, {L"set_Zip", DISPID_USERINFO_SET_ZIP }, {L"get_Country", DISPID_USERINFO_GET_COUNTRY }, {L"set_Country", DISPID_USERINFO_SET_COUNTRY }, {L"get_CountryID", DISPID_USERINFO_GET_COUNTRYID }, {L"set_CountryID", DISPID_USERINFO_SET_COUNTRYID }, {L"get_PrimaryEmail", DISPID_USERINFO_GET_PRIMARYEMAIL }, {L"set_PrimaryEmail", DISPID_USERINFO_SET_PRIMARYEMAIL }, {L"get_SecondaryEmail", DISPID_USERINFO_GET_SECONDARYEMAIL }, {L"set_SecondaryEmail", DISPID_USERINFO_SET_SECONDARYEMAIL }, {L"get_AreaCode", DISPID_USERINFO_GET_AREACODE }, {L"set_AreaCode", DISPID_USERINFO_SET_AREACODE }, {L"get_PhoneNumber", DISPID_USERINFO_GET_PHONENUMBER }, {L"set_PhoneNumber", DISPID_USERINFO_SET_PHONENUMBER }, {L"get_MSUpdate", DISPID_USERINFO_GET_MSUPDATE }, {L"set_MSUpdate", DISPID_USERINFO_SET_MSUPDATE }, {L"get_MSOffer", DISPID_USERINFO_GET_MSOFFER }, {L"set_MSOffer", DISPID_USERINFO_SET_MSOFFER }, {L"get_OtherOffer", DISPID_USERINFO_GET_OTHEROFFER }, {L"set_OtherOffer", DISPID_USERINFO_SET_OTHEROFFER }, {L"get_Identity", DISPID_USERINFO_GET_IDENTITY }, {L"set_Identity", DISPID_USERINFO_SET_IDENTITY }, {L"get_IdentitiesMax", DISPID_USERINFO_GET_IDENTITIESMAX }, {L"check_Identity", DISPID_USERINFO_CHECK_IDENTITY }, {L"SuggestIdentity0", DISPID_USERINFO_SUGGESTIDENTITY0 }, {L"get_UseIdentities", DISPID_USERINFO_GET_USEIDENTITIES }, {L"set_UseIdentities", DISPID_USERINFO_SET_USEIDENTITIES }, {L"get_OEMIdentities", DISPID_USERINFO_GET_OEMIDENTITIES }, {L"get_OwnerName", DISPID_USERINFO_GET_OWNERNAME }, {L"set_OwnerName", DISPID_USERINFO_SET_OWNERNAME }, {L"get_DefaultNewUser", DISPID_USERINFO_GET_DEFAULTNEWUSER }, }; const WCHAR csz_ADDR1[] = L"Addr1"; const WCHAR csz_ADDR2[] = L"Addr2"; const WCHAR csz_ADDRTYPE[] = L"AddrType"; const WCHAR csz_AREACODE[] = L"AreaCode"; const WCHAR csz_CITY[] = L"City"; const WCHAR csz_COMPANYNAME[] = L"CompanyName"; const WCHAR csz_COUNTRYCODE[] = L"CountryCode"; const WCHAR csz_DIVISIONNAME[] = L"DivisionName"; const WCHAR csz_EMAILNAME[] = L"EmailName"; const WCHAR csz_EXTENSION[] = L"Extension"; const WCHAR csz_FNAME[] = L"FName"; const WCHAR csz_INFLUENCELEVEL[] = L"InfluenceLevel"; const WCHAR csz_LANGCODE[] = L"LangCode"; const WCHAR csz_LANGNAME[] = L"LangName"; const WCHAR csz_LNAME[] = L"LName"; const WCHAR csz_MNAME[] = L"MName"; const WCHAR csz_NOOTHER[] = L"NoOther"; const WCHAR csz_PHONE[] = L"Phone"; const WCHAR csz_PID[] = L"PID"; const WCHAR csz_PRODUCT[] = L"Product"; const WCHAR csz_REGWIZVER[] = L"RegWizVer"; const WCHAR csz_SOFTWAREROLE[] = L"SoftwareRole"; const WCHAR csz_STATE[] = L"State"; const WCHAR csz_USERID[] = L"UserID"; const WCHAR csz_ZIP[] = L"Zip"; const WCHAR CSZ_COMPUTERMANF[] = L"ComputerManf"; REGDATAELEMENT aryRegDataElements[] = { { csz_ADDR1, NULL, 0}, { csz_ADDR2, NULL, 0}, { csz_ADDRTYPE, NULL, 0}, { csz_AREACODE, NULL, 0}, { csz_CITY, NULL, 0}, { csz_COMPANYNAME, NULL, 0}, { csz_COUNTRYCODE, NULL, 0}, { csz_DIVISIONNAME, NULL, 0}, { csz_EMAILNAME, NULL, 0}, { csz_EXTENSION, NULL, 0}, { csz_FNAME, NULL, 0}, { csz_INFLUENCELEVEL, NULL, 0}, { csz_LANGCODE, NULL, 0}, { csz_LANGNAME, NULL, 0}, { csz_LNAME, NULL, 0}, { csz_MNAME, NULL, 0}, { csz_NOOTHER, NULL, 0}, { csz_PHONE, NULL, 0}, { csz_PID, NULL, 0}, { csz_PRODUCT, NULL, 0}, { csz_REGWIZVER, NULL, 0}, { csz_SOFTWAREROLE, NULL, 0}, { csz_STATE, NULL, 0}, { csz_USERID, NULL, 0}, { csz_ZIP, NULL, 0}, { CSZ_COMPUTERMANF, NULL, 0} }; enum { INDEX_ADDR1 = 0, INDEX_ADDR2, // = 1, INDEX_ADDRTYPE, // = 2, INDEX_AREACODE, // = 3, INDEX_CITY, // = 4, INDEX_COMPANYNAME, // = 5, INDEX_COUNTRYCODE, // = 6, INDEX_DIVISIONNAME, // = 7, INDEX_EMAILNAME, // = 8, INDEX_EXTENSION, // = 9, INDEX_FNAME, // = 10, INDEX_INFLUENCELEVEL, // = 11, INDEX_LANGCODE, // = 12, INDEX_LANGNAME, // = 13, INDEX_LNAME, // = 14, INDEX_MNAME, // = 15, INDEX_NOOTHER, // = 16, INDEX_PHONE, // = 17, INDEX_PID, // = 18, INDEX_PRODUCT, // = 19, INDEX_REGWIZVER, // = 20, INDEX_SOFTWAREROLE, // = 21, INDEX_STATE, // = 22, INDEX_USERID, // = 23, INDEX_ZIP, // = 24, INDEX_COMPUTERMANF // = 25 }; #define REGDATAELEMENTS_LEN sizeof(aryRegDataElements) / sizeof(REGDATAELEMENT) const CUserInfo::RESERVED_IDENTITIES_IDS[] = { IDS_ACCTNAME_ADMINISTRATOR, IDS_ACCTNAME_GUEST }; ///////////////////////////////////////////////////////////// // CUserInfo::CUserInfo CUserInfo::CUserInfo(HINSTANCE hInstance) : m_hInstance(hInstance) { WCHAR szKeyName[] = REG_KEY_OOBE_TEMP; HKEY hKey = NULL; BOOL bName, bOrg; // Init member vars m_cRef = 0; // What if it failed? GetCanonicalizedPath(m_szUserInfoINIFile, USER_INFO_INIFILE); RegOpenKey(HKEY_LOCAL_MACHINE, szKeyName, &hKey); // Initialize or restore registration data ReadUserInfo(hKey, USERINFO_REG_KEY_FIRSTNAME, m_szFirstName, sizeof(m_szFirstName) ); ReadUserInfo(hKey, USERINFO_REG_KEY_MIDDLEINITIAL, m_szMiddleInitial, sizeof(m_szMiddleInitial) ); ReadUserInfo(hKey, USERINFO_REG_KEY_LASTNAME, m_szLastName, sizeof(m_szLastName) ); ReadUserInfo(hKey, USERINFO_REG_KEY_FURIGANANAME, m_szFuriganaName, sizeof(m_szFuriganaName) ); ReadUserInfo(hKey, USERINFO_REG_KEY_COMPANYNAME, m_szCompanyName, sizeof(m_szCompanyName) ); ReadUserInfo(hKey, USERINFO_REG_KEY_ADDRESS1, m_szAddress1, sizeof(m_szAddress1) ); ReadUserInfo(hKey, USERINFO_REG_KEY_ADDRESS2, m_szAddress2, sizeof(m_szAddress2) ); ReadUserInfo(hKey, USERINFO_REG_KEY_CITY, m_szCity, sizeof(m_szCity) ); ReadUserInfo(hKey, USERINFO_REG_KEY_STATE, m_szState, sizeof(m_szState) ); ReadUserInfo(hKey, USERINFO_REG_KEY_ZIP, m_szZip, sizeof(m_szZip) ); ReadUserInfo(hKey, USERINFO_REG_KEY_COUNTRY, m_szCountry, sizeof(m_szCountry) ); ReadUserInfo(hKey, USERINFO_REG_KEY_PRIMARYEMAIL, m_szPrimaryEmail, sizeof(m_szPrimaryEmail) ); ReadUserInfo(hKey, USERINFO_REG_KEY_SECONDARYEMAIL, m_szSecondaryEmail, sizeof(m_szSecondaryEmail) ); ReadUserInfo(hKey, USERINFO_REG_KEY_AREACODE, m_szAreaCode, sizeof(m_szAreaCode) ); ReadUserInfo(hKey, USERINFO_REG_KEY_PHONENUMBER, m_szPhoneNumber, sizeof(m_szPhoneNumber) ); // Initialize or restore new user accounts ReadUserInfo(hKey, USERINFO_REG_KEY_OWNERNAME, m_szOwnerName, sizeof(m_szOwnerName) ); ReadUserInfo(hKey, USERINFO_REG_KEY_DEFAULTNEWUSER ,m_szDefaultNewUser, sizeof(m_szDefaultNewUser) ); m_fUseIdentities = DEFAULT_USEIDENTITIES; m_fMSUpdate = VARIANT_TRUE; m_fMSOffer = VARIANT_TRUE; m_fOtherOffer = VARIANT_TRUE; m_dwCountryID = 0; // Need to distinguish between OEM preset identities and // Registry value, so ReadUserInfo is not used m_fOEMIdentities = FALSE; for (UINT uiIndex = 0; uiIndex < IDENTITIES_MAX; uiIndex++) { wsprintf(m_rgIdentities[uiIndex].rgchRegValue, L"%s%03d", USERINFO_REG_KEY_IDENTITY, uiIndex ); GetPrivateProfileString(USER_INFO_KEYNAME, m_rgIdentities[uiIndex].rgchRegValue, L"\0", m_rgIdentities[uiIndex].rgchIdentity, IDENTITY_CCH_MAX, m_szUserInfoINIFile); TRACE4( L"%s/%s/%s=%s", m_szUserInfoINIFile, USER_INFO_KEYNAME, m_rgIdentities[uiIndex].rgchRegValue, m_rgIdentities[uiIndex].rgchIdentity ); m_fOEMIdentities = m_fOEMIdentities || (m_rgIdentities[uiIndex].rgchIdentity[0] != L'\0'); } if ( (!m_fOEMIdentities) && (hKey != NULL) ) { for (uiIndex = 0; uiIndex < IDENTITIES_MAX; uiIndex++) { DWORD dwType = 0; DWORD dwSize = IDENTITY_CCH_MAX; RegQueryValueEx(hKey, m_rgIdentities[uiIndex].rgchRegValue, 0, &dwType, (LPBYTE)m_rgIdentities[uiIndex].rgchIdentity, &dwSize); } } if ( hKey ) RegCloseKey(hKey); // Get the default name or org if there wasn't one already saved. // bName = FALSE; bOrg = ( *m_szCompanyName == L'\0' ); // This is so OEMs can prepopulate the user or org field. We just store the name // in the first name field. We might want to split it up into First, MI, and Last // in the future? // if ( bName || bOrg ) { SetupGetSetupInfo( bName ? m_szFirstName : NULL, bName ? sizeof(m_szFirstName) : 0, m_szCompanyName ? m_szCompanyName : NULL, m_szCompanyName ? sizeof(m_szCompanyName) : 0, NULL, 0, NULL ); } m_RegDataElements = aryRegDataElements; m_RegDataElements[0].lpQueryElementValue = (LPWSTR) m_szAddress1; m_RegDataElements[1].lpQueryElementValue = (LPWSTR) m_szAddress2; m_RegDataElements[3].lpQueryElementValue = (LPWSTR) m_szAreaCode; m_RegDataElements[4].lpQueryElementValue = (LPWSTR) m_szCity; m_RegDataElements[5].lpQueryElementValue = (LPWSTR) m_szCompanyName; m_RegDataElements[8].lpQueryElementValue = (LPWSTR) m_szPrimaryEmail; m_RegDataElements[10].lpQueryElementValue = (LPWSTR) m_szFirstName; m_RegDataElements[15].lpQueryElementValue = (LPWSTR) m_szMiddleInitial; m_RegDataElements[14].lpQueryElementValue = (LPWSTR) m_szLastName; m_RegDataElements[17].lpQueryElementValue = (LPWSTR) m_szPhoneNumber; m_RegDataElements[22].lpQueryElementValue = (LPWSTR) m_szState; m_RegDataElements[24].lpQueryElementValue = (LPWSTR) m_szZip; for (int i = 0; i < RESERVED_IDENTITIES_MAX; i++) { if (!LoadString( m_hInstance, RESERVED_IDENTITIES_IDS[i], m_szReservedIdentities[i], sizeof(m_szReservedIdentities[i]) / sizeof(TCHAR) )) { m_szReservedIdentities[i][0] = L'\0'; } } } ///////////////////////////////////////////////////////////// // CUserInfo::~CUserInfo CUserInfo::~CUserInfo() { assert(m_cRef == 0); } void CUserInfo::ReadUserInfo(HKEY hKey, WCHAR* pszKey, WCHAR* pszValue, DWORD dwSize) { DWORD dwType = 0; DWORD cSize = dwSize; *pszValue = L'\0'; if( ( hKey == NULL) || ( ERROR_SUCCESS != RegQueryValueEx(hKey, pszKey, 0, &dwType, (LPBYTE)pszValue, &dwSize) || *pszValue == L'\0' ) ) { GetPrivateProfileString(USER_INFO_KEYNAME, pszKey, L"\0", pszValue, cSize, m_szUserInfoINIFile); } } void CUserInfo::WriteUserInfo(WCHAR* pszBuf, WCHAR* pszKey, WCHAR* pszValue) { WCHAR szKeyName[] = REG_KEY_OOBE_TEMP; HKEY hKey; // A null value must be converted to an empty string. // if ( pszValue ) lstrcpy(pszBuf, pszValue); else *pszBuf = L'\0'; // Commit the data to the registry. // if ( RegCreateKeyEx(HKEY_LOCAL_MACHINE, szKeyName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, NULL) == ERROR_SUCCESS ) { if ( *pszBuf ) RegSetValueEx(hKey, pszKey, 0, REG_SZ, (LPBYTE) pszValue, BYTES_REQUIRED_BY_SZ(pszValue)); else RegDeleteValue(hKey, pszKey); RegFlushKey(hKey); RegCloseKey(hKey); } } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: Identity //// HRESULT CUserInfo::get_Identity(UINT uiIndex, BSTR* pbstrVal) { if (uiIndex >= IDENTITIES_MAX) { return E_INVALIDARG; } *pbstrVal = SysAllocString(m_rgIdentities[uiIndex].rgchIdentity); if (NULL == *pbstrVal) { return E_OUTOFMEMORY; } return S_OK; } HRESULT CUserInfo::set_Identity(UINT uiIndex, WCHAR* pszVal) { if (uiIndex < IDENTITIES_MAX) { if (!pszVal) // delete the account if it exists { WriteUserInfo(m_rgIdentities[uiIndex].rgchIdentity, m_rgIdentities[uiIndex].rgchRegValue, NULL); } else { if (lstrlen(pszVal) <= IDENTITY_CCH_MAX) { WriteUserInfo(m_rgIdentities[uiIndex].rgchIdentity, m_rgIdentities[uiIndex].rgchRegValue, pszVal ); } } } return S_OK; } HRESULT CUserInfo::get_Identities(PSTRINGLIST* pUserList) { for (UINT uiIndex = 0; uiIndex < IDENTITIES_MAX; uiIndex++) { if (lstrlen(m_rgIdentities[uiIndex].rgchIdentity) > 0) { PSTRINGLIST Cell; Cell = CreateStringCell(m_rgIdentities[uiIndex].rgchIdentity); if (Cell) { FixString(Cell->String); InsertList(pUserList, Cell); } } } return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: UseIdentities //// HRESULT CUserInfo::get_UseIdentities(VARIANT_BOOL *pfVal) { *pfVal = m_fUseIdentities; return S_OK; } HRESULT CUserInfo::set_UseIdentities(VARIANT_BOOL fVal) { m_fUseIdentities = fVal; return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: MSUpdate //// HRESULT CUserInfo::get_MSUpdate(VARIANT_BOOL *pfVal) { *pfVal = m_fMSUpdate; return S_OK; } HRESULT CUserInfo::set_MSUpdate(VARIANT_BOOL fVal) { m_fMSUpdate = fVal; return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: MSOffer //// HRESULT CUserInfo::get_MSOffer(VARIANT_BOOL *pfVal) { *pfVal = m_fMSOffer; return S_OK; } HRESULT CUserInfo::set_MSOffer(VARIANT_BOOL fVal) { m_fMSOffer = fVal; return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: OtherOffer //// HRESULT CUserInfo::get_OtherOffer(VARIANT_BOOL *pfVal) { *pfVal = m_fOtherOffer; return S_OK; } HRESULT CUserInfo::set_OtherOffer(VARIANT_BOOL fVal) { m_fOtherOffer = fVal; return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: CountryID //// HRESULT CUserInfo::get_CountryID(DWORD *pdwVal) { *pdwVal = m_dwCountryID; return S_OK; } HRESULT CUserInfo::set_CountryID(DWORD dwVal) { m_dwCountryID = dwVal; return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// CHECK :: Identity //// // constant strings used for name validation #define DOT_CHAR '.' #define DOT_AND_SPACE_STR TEXT(". ") #define CTRL_CHARS_0 TEXT( "\001\002\003\004\005\006\007") #define CTRL_CHARS_1 TEXT("\010\011\012\013\014\015\016\017") #define CTRL_CHARS_2 TEXT("\020\021\022\023\024\025\026\027") #define CTRL_CHARS_3 TEXT("\030\031\032\033\034\035\036\037") #define CTRL_CHARS_STR CTRL_CHARS_0 CTRL_CHARS_1 CTRL_CHARS_2 CTRL_CHARS_3 #define ILLEGAL_FAT_CHARS CTRL_CHARS_STR TEXT("\"*+,/:;<=>?[\\]|") HRESULT CUserInfo::check_Identity(UINT uiIndex, VARIANT_BOOL* pfValid) { BSTR bstrVal; *pfValid = TRUE; // initalize outparam, assume ok if (SUCCEEDED(get_Identity(uiIndex, &bstrVal))) { // check length DWORD cchVal = lstrlen(bstrVal); if (cchVal > 0) // if cchVal == 0, user trying to delete or didn't define { check_Identity(bstrVal, pfValid); for (UINT i = 0; i < uiIndex; i++) // check not equal to other names { BSTR bstrValOther; if (SUCCEEDED(get_Identity(i, &bstrValOther))) { if (0 == StrCmpI(bstrVal, bstrValOther)) { *pfValid = FALSE; } SysFreeString(bstrValOther); } } } SysFreeString(bstrVal); } return S_OK; } HRESULT CUserInfo::check_Identity(WCHAR* pszVal, VARIANT_BOOL* pfValid) { *pfValid = TRUE; // initalize outparam, assume ok if (pszVal) { WCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 1]; DWORD cchComputerName = sizeof(szComputerName) / sizeof(WCHAR); DWORD cchVal = lstrlen(pszVal); if (cchVal > 0) // if cchVal == 0, user trying to delete or didn't define { if (cchVal > 20) { *pfValid = FALSE; } // check for trailing periods if (pszVal[cchVal - 1] == DOT_CHAR) { *pfValid = FALSE; } // check not all spaces and periods if (StrSpn(pszVal, DOT_AND_SPACE_STR) == (int)cchVal) { *pfValid = FALSE; } // check nothing from ILLEGAL_FAT_CHARS in name if (StrCSpn(pszVal, ILLEGAL_FAT_CHARS) < (int)cchVal) { *pfValid = FALSE; } for (int i = 0; i < RESERVED_IDENTITIES_MAX; i++) { if (!lstrcmpi(m_szReservedIdentities[i], pszVal)) { *pfValid = FALSE; break; } } if (GetComputerName(szComputerName, &cchComputerName)) { if (!lstrcmpi(szComputerName, pszVal)) { *pfValid = FALSE; } } } else { *pfValid = FALSE; } } else { *pfValid = FALSE; } return S_OK; } STDMETHODIMP CUserInfo::SuggestIdentity0() { if (lstrlen(m_rgIdentities[0].rgchIdentity) == 0) { LPWSTR Candidates[] = {m_szOwnerName, m_szFirstName, m_szLastName, NULL}; for (int i = 0; Candidates[i]; i++) { if (lstrlen(Candidates[i]) > 0) { VARIANT_BOOL b; check_Identity(Candidates[i], &b); if (b) { FixString(Candidates[i]); set_Identity(0, Candidates[i]); break; } } } } return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: FirstName //// HRESULT CUserInfo::set_FirstName(WCHAR* pszVal) { WriteUserInfo(m_szFirstName, USERINFO_REG_KEY_FIRSTNAME, pszVal); return S_OK; } HRESULT CUserInfo::get_FirstName(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szFirstName); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: MiddleInitial //// HRESULT CUserInfo::set_MiddleInitial(WCHAR* pszVal) { WriteUserInfo(m_szMiddleInitial, USERINFO_REG_KEY_MIDDLEINITIAL, pszVal); return S_OK; } HRESULT CUserInfo::get_MiddleInitial(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szMiddleInitial); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: LastName //// HRESULT CUserInfo::set_LastName(WCHAR* pszVal) { WriteUserInfo(m_szLastName, USERINFO_REG_KEY_LASTNAME, pszVal); return S_OK; } HRESULT CUserInfo::get_LastName(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szLastName); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: FuriganaName //// HRESULT CUserInfo::set_FuriganaName(WCHAR* pszVal) { WriteUserInfo(m_szFuriganaName, USERINFO_REG_KEY_FURIGANANAME, pszVal); return S_OK; } HRESULT CUserInfo::get_FuriganaName(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szFuriganaName); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: CompanyName //// HRESULT CUserInfo::set_CompanyName(WCHAR* pszVal) { WriteUserInfo(m_szCompanyName, USERINFO_REG_KEY_COMPANYNAME, pszVal); return S_OK; } HRESULT CUserInfo::get_CompanyName(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szCompanyName); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: Address1 //// HRESULT CUserInfo::set_Address1(WCHAR* pszVal) { WriteUserInfo(m_szAddress1, USERINFO_REG_KEY_ADDRESS1, pszVal); return S_OK; } HRESULT CUserInfo::get_Address1(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szAddress1); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: Address2 //// HRESULT CUserInfo::set_Address2(WCHAR* pszVal) { WriteUserInfo(m_szAddress2, USERINFO_REG_KEY_ADDRESS2, pszVal); return S_OK; } HRESULT CUserInfo::get_Address2(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szAddress2); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: City //// HRESULT CUserInfo::set_City(WCHAR* pszVal) { WriteUserInfo(m_szCity, USERINFO_REG_KEY_CITY, pszVal); return S_OK; } HRESULT CUserInfo::get_City(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szCity); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: State //// HRESULT CUserInfo::set_State(WCHAR* pszVal) { WriteUserInfo(m_szState, USERINFO_REG_KEY_STATE, pszVal); return S_OK; } HRESULT CUserInfo::get_State(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szState); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: Zip //// HRESULT CUserInfo::set_Zip(WCHAR* pszVal) { WriteUserInfo(m_szZip, USERINFO_REG_KEY_ZIP, pszVal); return S_OK; } HRESULT CUserInfo::get_Zip(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szZip); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: Country //// HRESULT CUserInfo::set_Country(WCHAR* pszVal) { WriteUserInfo(m_szCountry, USERINFO_REG_KEY_COUNTRY, pszVal); return S_OK; } HRESULT CUserInfo::get_Country(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szCountry); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: PrimaryEmail //// HRESULT CUserInfo::set_PrimaryEmail(WCHAR* pszVal) { WriteUserInfo(m_szPrimaryEmail, USERINFO_REG_KEY_PRIMARYEMAIL, pszVal); return S_OK; } HRESULT CUserInfo::get_PrimaryEmail(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szPrimaryEmail); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: SecondaryEmail //// HRESULT CUserInfo::set_SecondaryEmail(WCHAR* pszVal) { WriteUserInfo(m_szSecondaryEmail, USERINFO_REG_KEY_SECONDARYEMAIL, pszVal); return S_OK; } HRESULT CUserInfo::get_SecondaryEmail(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szSecondaryEmail); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: AreaCode //// HRESULT CUserInfo::set_AreaCode(WCHAR* pszVal) { WriteUserInfo(m_szAreaCode, USERINFO_REG_KEY_AREACODE, pszVal); return S_OK; } HRESULT CUserInfo::get_AreaCode(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szAreaCode); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: Number //// HRESULT CUserInfo::set_PhoneNumber(WCHAR* pszVal) { WriteUserInfo(m_szPhoneNumber, USERINFO_REG_KEY_PHONENUMBER, pszVal); return S_OK; } HRESULT CUserInfo::get_PhoneNumber(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szPhoneNumber); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: OwnerName //// HRESULT CUserInfo::set_OwnerName(WCHAR* pszVal) { WriteUserInfo(m_szOwnerName, USERINFO_REG_KEY_OWNERNAME, pszVal); return S_OK; } HRESULT CUserInfo::get_OwnerName(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szOwnerName); return S_OK; } //////////////////////////////////////////////// //////////////////////////////////////////////// //// GET / SET :: DefaultNewUser //// HRESULT CUserInfo::set_DefaultNewUser(WCHAR* pszVal) { WriteUserInfo(m_szDefaultNewUser, USERINFO_REG_KEY_DEFAULTNEWUSER, pszVal); return S_OK; } HRESULT CUserInfo::get_DefaultNewUser(BSTR* pbstrVal) { *pbstrVal = SysAllocString(m_szDefaultNewUser); return S_OK; } ///////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////// /////// IUnknown implementation /////// /////// ///////////////////////////////////////////////////////////// // CObMain::QueryInterface STDMETHODIMP CUserInfo::QueryInterface(REFIID riid, LPVOID* ppvObj) { // must set out pointer parameters to NULL *ppvObj = NULL; if ( riid == IID_IUnknown) { AddRef(); *ppvObj = (IUnknown*)this; return ResultFromScode(S_OK); } if (riid == IID_IDispatch) { AddRef(); *ppvObj = (IDispatch*)this; return ResultFromScode(S_OK); } // Not a supported interface return ResultFromScode(E_NOINTERFACE); } ///////////////////////////////////////////////////////////// // CUserInfo::AddRef STDMETHODIMP_(ULONG) CUserInfo::AddRef() { return ++m_cRef; } ///////////////////////////////////////////////////////////// // CUserInfo::Release STDMETHODIMP_(ULONG) CUserInfo::Release() { return --m_cRef; } ///////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////// /////// IDispatch implementation /////// /////// ///////////////////////////////////////////////////////////// // CUserInfo::GetTypeInfo STDMETHODIMP CUserInfo::GetTypeInfo(UINT, LCID, ITypeInfo**) { return E_NOTIMPL; } ///////////////////////////////////////////////////////////// // CUserInfo::GetTypeInfoCount STDMETHODIMP CUserInfo::GetTypeInfoCount(UINT* pcInfo) { return E_NOTIMPL; } ///////////////////////////////////////////////////////////// // CUserInfo::GetIDsOfNames STDMETHODIMP CUserInfo::GetIDsOfNames(REFIID riid, OLECHAR** rgszNames, UINT cNames, LCID lcid, DISPID* rgDispId) { HRESULT hr = DISP_E_UNKNOWNNAME; rgDispId[0] = DISPID_UNKNOWN; for (int iX = 0; iX < sizeof(UserInfoExternalInterface)/sizeof(DISPATCHLIST); iX ++) { if(lstrcmp(UserInfoExternalInterface[iX].szName, rgszNames[0]) == 0) { rgDispId[0] = UserInfoExternalInterface[iX].dwDispID; hr = NOERROR; break; } } // Set the disid's for the parameters if (cNames > 1) { // Set a DISPID for function parameters for (UINT i = 1; i < cNames ; i++) rgDispId[i] = DISPID_UNKNOWN; } return hr; } ///////////////////////////////////////////////////////////// // CUserInfo::Invoke HRESULT CUserInfo::Invoke ( DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult, EXCEPINFO* pexcepinfo, UINT* puArgErr ) { HRESULT hr = S_OK; switch(dispidMember) { case DISPID_USERINFO_CHECK_IDENTITY: { TRACE(L"DISPID_USERINFO_CHECK_IDENTITY\n"); if(pdispparams && &pdispparams[0].rgvarg[0] && pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BOOL; if (pdispparams[0].rgvarg[0].vt == VT_BSTR) { check_Identity(pdispparams[0].rgvarg[0].bstrVal, &pvarResult->boolVal); } else { check_Identity(pdispparams[0].rgvarg[0].uintVal, &pvarResult->boolVal); } } break; } case DISPID_USERINFO_GET_FIRSTNAME: { TRACE(L"DISPID_USERINFO_GET_FIRSTNAME\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_FirstName(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_FIRSTNAME: { TRACE(L"DISPID_USERINFO_SET_FIRSTNAME\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_FirstName(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_MIDDLEINITIAL: { TRACE(L"DISPID_USERINFO_GET_MIDDLEINITIAL\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_MiddleInitial(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_MIDDLEINITIAL: { TRACE(L"DISPID_USERINFO_SET_MIDDLEINITIAL\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_MiddleInitial(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_LASTNAME: { TRACE(L"DISPID_USERINFO_GET_LASTNAME\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_LastName(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_LASTNAME: { TRACE(L"DISPID_USERINFO_SET_LASTNAME\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_LastName(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_FURIGANANAME: { TRACE(L"DISPID_USERINFO_GET_FURIGANANAME\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_FuriganaName(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_FURIGANANAME: { TRACE(L"DISPID_USERINFO_SET_FURIGANANAME\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_FuriganaName(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_OWNERNAME: { TRACE(L"DISPID_USERINFO_GET_OWNERNAME\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_OwnerName(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_OWNERNAME: { TRACE(L"DISPID_USERINFO_SET_OWNERNAME\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_OwnerName(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_COMPANYNAME: { TRACE(L"DISPID_USERINFO_GET_COMPANYNAME\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_CompanyName(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_COMPANYNAME: { TRACE(L"DISPID_USERINFO_SET_COMPANYNAME\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_CompanyName(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_ADDRESS1: { TRACE(L"DISPID_USERINFO_GET_ADDRESS1\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_Address1(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_ADDRESS1: { TRACE(L"DISPID_USERINFO_SET_ADDRESS1\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_Address1(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_ADDRESS2: { TRACE(L"DISPID_USERINFO_GET_ADDRESS2\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_Address2(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_ADDRESS2: { TRACE(L"DISPID_USERINFO_SET_ADDRESS2\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_Address2(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_CITY: { TRACE(L"DISPID_USERINFO_GET_CITY\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_City(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_CITY: { TRACE(L"DISPID_USERINFO_SET_CITY\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_City(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_STATE: { TRACE(L"DISPID_USERINFO_GET_STATE\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_State(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_STATE: { TRACE(L"DISPID_USERINFO_SET_STATE\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_State(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_ZIP: { TRACE(L"DISPID_USERINFO_GET_ZIP\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_Zip(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_ZIP: { TRACE(L"DISPID_USERINFO_SET_ZIP\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_Zip(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_COUNTRY: { TRACE(L"DISPID_USERINFO_GET_COUNTRY\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_Country(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_COUNTRY: { TRACE(L"DISPID_USERINFO_SET_COUNTRY\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_Country(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_PRIMARYEMAIL: { TRACE(L"DISPID_USERINFO_GET_PRIMARYEMAIL\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_PrimaryEmail(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_PRIMARYEMAIL: { TRACE(L"DISPID_USERINFO_SET_PRIMARYEMAIL\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_PrimaryEmail(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_SECONDARYEMAIL: { TRACE(L"DISPID_USERINFO_GET_SECONDARYEMAIL\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_SecondaryEmail(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_SECONDARYEMAIL: { TRACE(L"DISPID_USERINFO_SET_SECONDARYEMAIL\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_SecondaryEmail(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_AREACODE: { TRACE(L"DISPID_USERINFO_GET_AREACODE\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_AreaCode(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_AREACODE: { TRACE(L"DISPID_USERINFO_SET_AREACODE\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_AreaCode(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_PHONENUMBER: { TRACE(L"DISPID_USERINFO_GET_PHONENUMBER\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_PhoneNumber(&pvarResult->bstrVal); } break; } case DISPID_USERINFO_SET_PHONENUMBER: { TRACE(L"DISPID_USERINFO_SET_PHONENUMBER\n"); if(pdispparams && &pdispparams[0].rgvarg[0]) set_PhoneNumber(pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_MSUPDATE: { TRACE(L"DISPID_USERINFO_GET_MSUPDATE"); if (NULL != pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BOOL; get_MSUpdate(&(pvarResult->boolVal)); } break; } case DISPID_USERINFO_SET_MSUPDATE: { TRACE(L"DISPID_USERINFO_SET_MSUPDATE"); if (pdispparams && 0 < pdispparams->cArgs) set_MSUpdate(pdispparams[0].rgvarg[0].boolVal); break; } case DISPID_USERINFO_GET_MSOFFER: { TRACE(L"DISPID_USERINFO_GET_MSOFFER"); if (NULL != pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BOOL; get_MSOffer(&(pvarResult->boolVal)); } break; } case DISPID_USERINFO_SET_MSOFFER: { TRACE(L"DISPID_USERINFO_SET_MSOFFER"); if (pdispparams && 0 < pdispparams->cArgs) set_MSOffer(pdispparams[0].rgvarg[0].boolVal); break; } case DISPID_USERINFO_GET_OTHEROFFER: { TRACE(L"DISPID_USERINFO_GET_OTHEROFFER"); if (NULL != pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BOOL; get_OtherOffer(&(pvarResult->boolVal)); } break; } case DISPID_USERINFO_SET_OTHEROFFER: { TRACE(L"DISPID_USERINFO_SET_OTHEROFFER"); if (pdispparams && 0 < pdispparams->cArgs) set_OtherOffer(pdispparams[0].rgvarg[0].boolVal); break; } case DISPID_USERINFO_GET_COUNTRYID: { TRACE(L"DISPID_USERINFO_GET_COUNTRYID"); if (NULL != pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_I4; get_CountryID((PDWORD)&(pvarResult->lVal)); } break; } case DISPID_USERINFO_SET_COUNTRYID: { TRACE(L"DISPID_USERINFO_SET_COUNTRYID"); if (pdispparams && 0 < pdispparams->cArgs) set_CountryID(pdispparams[0].rgvarg[0].lVal); break; } case DISPID_USERINFO_GET_IDENTITIESMAX: { TRACE(L"DISPID_USERINFO_GET_IDENTITIESMAX\n"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_I2; get_IdentitiesMax(&pvarResult->iVal); } break; } case DISPID_USERINFO_GET_IDENTITY: { TRACE(L"DISPID_USERINFO_GET_IDENTITY\n"); if ( NULL != pdispparams && 0 < pdispparams->cArgs && NULL != pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_Identity(pdispparams[0].rgvarg[0].uintVal, &pvarResult->bstrVal ); } break; } case DISPID_USERINFO_SET_IDENTITY: { TRACE(L"DISPID_USERINFO_SET_IDENTITY\n"); if(pdispparams && 1 < pdispparams->cArgs) set_Identity(pdispparams[0].rgvarg[1].uintVal, pdispparams[0].rgvarg[0].bstrVal); break; } case DISPID_USERINFO_GET_USEIDENTITIES: { TRACE(L"DISPID_USERINFO_GET_USEIDENTITIES"); if (NULL != pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BOOL; get_UseIdentities(&(pvarResult->boolVal)); } break; } case DISPID_USERINFO_SET_USEIDENTITIES: { TRACE(L"DISPID_USERINFO_SET_USEIDENTITIES"); if (pdispparams && 0 < pdispparams->cArgs) set_UseIdentities(pdispparams[0].rgvarg[0].boolVal); break; } case DISPID_USERINFO_GET_OEMIDENTITIES: { TRACE(L"DISPID_USERINFO_GET_OEMIDENTITIES"); if (NULL != pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BOOL; get_OEMIdentities(&(pvarResult->boolVal)); } break; } case DISPID_USERINFO_SUGGESTIDENTITY0: { OutputDebugString(L"DISPID_USERINFO_SUGGESTIDENTITY0\n"); SuggestIdentity0(); break; } case DISPID_USERINFO_GET_DEFAULTNEWUSER: { TRACE(L"DISPID_USERINFO_GET_DEFAULTNEWUSER"); if(pvarResult) { VariantInit(pvarResult); V_VT(pvarResult) = VT_BSTR; get_DefaultNewUser(&pvarResult->bstrVal); } break; } default: { hr = DISP_E_MEMBERNOTFOUND; break; } } return hr; } // HRESULT CUserInfo::set_CountryCode(DWORD dwCountryCd) { m_dwCountryCode = dwCountryCd; return S_OK; } // This funtion will form the query string to be sent to the ISP signup server // HRESULT CUserInfo::GetQueryString ( BSTR bstrBaseURL, BSTR *lpReturnURL ) { LPWSTR lpWorkingURL; WORD cchBuffer = 0; LPREGDATAELEMENT lpElement; LPWSTR lpszBaseURL = bstrBaseURL; int i; BSTR pbstrVal = NULL; CProductID PidObj; PidObj.get_PID(&pbstrVal); m_RegDataElements[INDEX_PID].lpQueryElementValue = (LPWSTR) pbstrVal; WCHAR buffer[8]; _itow( m_dwCountryCode, buffer, 8 ); m_RegDataElements[INDEX_COUNTRYCODE].lpQueryElementValue = (LPWSTR)buffer; m_RegDataElements[INDEX_PRODUCT].lpQueryElementValue = REG_VAL_OOBE; // Now read the INI file. WCHAR szOemInfoFile[MAX_PATH] = L"\0"; WCHAR szComputerManf[MAX_PATH] = L"\0"; GetSystemDirectory(szOemInfoFile, MAX_CHARS_IN_BUFFER(szOemInfoFile)); lstrcat(szOemInfoFile, OEMINFO_INI_FILENAME); GetPrivateProfileString(USER_COMP_MANF_SEC, USER_COMP_MANF_KEY, L"\0", szComputerManf, MAX_CHARS_IN_BUFFER(szComputerManf), szOemInfoFile); m_RegDataElements[INDEX_COMPUTERMANF].lpQueryElementValue = szComputerManf; //ASSERT(lpReturnURL); if (!lpReturnURL) return E_FAIL; // Calculate how big of a buffer we will need cchBuffer += (WORD)lstrlen(lpszBaseURL) + 1; for (i = 0; i < REGDATAELEMENTS_LEN; i ++) { lpElement = &m_RegDataElements[i]; //ASSERT(lpElement); if (lpElement->lpQueryElementName) { cchBuffer += (WORD)( lstrlen(lpElement->lpQueryElementName) + (lstrlen(lpElement->lpQueryElementValue) * 3) // *3 for encoding + 3 // For the = and & and the terminator // (because we copy lpQueryElementValue // into a new buffer for encoding) ); } else { // extra character is for the trailing & cchBuffer += (WORD)(lstrlen(lpElement->lpQueryElementValue) + 1); } } cchBuffer++; // Terminator // Allocate a buffer large enough if (NULL == (lpWorkingURL = (LPWSTR)GlobalAllocPtr(GPTR, BYTES_REQUIRED_BY_CCH(cchBuffer)))) return E_FAIL; lstrcpy(lpWorkingURL, lpszBaseURL); // See if this ISP provided URL is already a Query String. if (*lpWorkingURL) { if (NULL != wcschr(lpWorkingURL, L'?')) lstrcat(lpWorkingURL, cszAmpersand); // Append our params else lstrcat(lpWorkingURL, cszQuestion); // Start with our params } for (i = 0; i < REGDATAELEMENTS_LEN; i ++) { lpElement = &m_RegDataElements[i]; //ASSERT(lpElement); if (lpElement->lpQueryElementName) { // If there is a query value, then encode it if (lpElement->lpQueryElementValue) { // Allocate a buffer to encode into size_t cch = (lstrlen(lpElement->lpQueryElementValue) + 1) * 3; LPWSTR lpszVal = (LPWSTR) malloc(BYTES_REQUIRED_BY_CCH(cch)); lstrcpy(lpszVal, lpElement->lpQueryElementValue); URLEncode(lpszVal, cch); URLAppendQueryPair(lpWorkingURL, (LPWSTR)lpElement->lpQueryElementName, lpszVal); free(lpszVal); } else { URLAppendQueryPair(lpWorkingURL, (LPWSTR)lpElement->lpQueryElementName, NULL); } } else { if (lpElement->lpQueryElementValue) { lstrcat(lpWorkingURL, lpElement->lpQueryElementValue); lstrcat(lpWorkingURL, cszAmpersand); } } } // Terminate the working URL properly, by removing the trailing ampersand lpWorkingURL[lstrlen(lpWorkingURL)-1] = L'\0'; // Set the return VALUE. We must allocate here, since the caller will free // this returned string, and A2W only puts the string in the stack *lpReturnURL = SysAllocString(lpWorkingURL); // Free the buffer GlobalFreePtr(lpWorkingURL); return (S_OK); } void CUserInfo::FixString(BSTR bstrVal) { if (bstrVal != NULL) { // StrTrim removes both leading and trailing spaces StrTrim(bstrVal, TEXT(" ")); } }