Example #1
0
void setnames(const char *fname, const char *cname = 0)
{
    if(!cname) cname = fname;
    string name, pakname, mapname, cfgname;
    s_strncpy(name, cname, 100);
    char *slash = strpbrk(name, "/\\");
    if(slash)
    {
        s_strncpy(pakname, name, slash-name+1);
        s_strcpy(cfgname, slash+1);
    }
    else
    {
        s_strcpy(pakname, "base");
        s_strcpy(cfgname, name);
    };
    if(strpbrk(fname, "/\\")) s_strcpy(mapname, fname);
    else s_sprintf(mapname)("base/%s", fname);

    s_sprintf(cgzname)("packages/%s.tmf", mapname);
    if(savebak==1) s_sprintf(bakname)("packages/%s.BAK", mapname);
    else s_sprintf(bakname)("packages/%s_%d.BAK", mapname, lastmillis);
    s_sprintf(pcfname)("packages/%s/package.cfg", pakname);
    s_sprintf(mcfname)("packages/%s/%s.cfg",      pakname, cfgname);

    path(cgzname);
    path(bakname);
};
Example #2
0
/*
 * Perform an string compare as part of a diagnostic test
 */
NVM_BOOL diag_check_str(const struct diagnostic *p_diagnostic,
		const NVM_UINT32 indicator, const char *actual,
		char *expected)
{
	COMMON_LOG_ENTRY();
	NVM_BOOL result = 0;

	// is check excluded by caller
	if (p_diagnostic->excludes & indicator)
	{
		result = 1;
	}
	else
	{
		// is threshold value specified by caller?
		for (int i = 0; i < p_diagnostic->overrides_len; i++)
		{
			if (p_diagnostic->p_overrides[i].type == indicator)
			{
				s_strcpy(expected, p_diagnostic->p_overrides[i].threshold_str,
						NVM_THRESHOLD_STR_LEN);
				break;
			}
		}

		// perform check
		result = (strncmp(expected, actual, NVM_THRESHOLD_STR_LEN) == 0);
	}
	return result;
}
Example #3
0
static char* filterPosTag(const char *posTagStr, s_erc *error)
{
	S_CLR_ERR(error);
	char *filteredPosTagStr = malloc(sizeof(char) * 10);
	s_strcpy( filteredPosTagStr, posTagStr, error);

	s_bool end = FALSE;
	s_bool firstUpper = FALSE;
	int i=0;

	while( !end )
	{
		if( !firstUpper )
		{
			if( isASCIIUpper(filteredPosTagStr[i]) )
				firstUpper = TRUE;
		}
		else
		{
			if( !isASCIIUpper(filteredPosTagStr[i]) )
			{
				filteredPosTagStr[i] = '\0';
				end = TRUE;
			}
		}
		i++;
		if( filteredPosTagStr[i] == '\0' )
			end = TRUE;
	}

	return filteredPosTagStr;
}
Example #4
0
bool_t pack_fill_filename(resentry_t *re)
{
	s_strcpy(&(re->filename), re->name);
	if (re->filename == NULL)
		return FALSE;
	return TRUE;
}
Example #5
0
int s_snprintf(char *str, size_t size, const char *format, ...)
{
	va_list ap;
	char *formatted = NULL;
	int formatted_len;

	errno = 0;
	va_start(ap, format);
	formatted = make_message(&formatted_len, format, ap);
	va_end(ap);
	if (NULL == formatted)
	{
		return (-1);
	}
	s_strcpy(str, formatted, size);

	free(formatted);
	formatted = NULL;

	if (formatted_len >= size)
	{
		errno = EINVAL;
	}
	return (formatted_len);
}
Example #6
0
CStringBuffer CConsoleClipboard::GetClipboardText()
{
	CStringBuffer tmp;

#ifdef OK_SYS_WINDOWS
	if (!IsClipboardFormatAvailable(_CLIPBOARDTEXTFORMAT))
		return tmp;

	HWND hwnd = GetConsoleWindow();

	if ( !hwnd )
		return tmp;
    if (!OpenClipboard(hwnd)) 
		return tmp;
 
    HGLOBAL hglb = GetClipboardData(_CLIPBOARDTEXTFORMAT); 
    if (hglb != NULL) 
    { 
        LPTSTR  lptstr = (LPTSTR)GlobalLock(hglb); 
        if (lptstr != NULL) 
        {
			dword tlen = s_strlen(lptstr, INT_MAX);
			tmp.SetSize(__FILE__LINE__ tlen + 1);
			s_strcpy(CastMutable(CPointer, tmp.GetString()), tlen + 1, lptstr);
            GlobalUnlock(hglb); 
        } 
    } 
    CloseClipboard();
#endif
#ifdef OK_SYS_UNIX
	tmp = _clipboardtext;
#endif
	return tmp;
 }
Example #7
0
void mmodel(char *name, int *tex)
{
    mapmodelinfo &mmi = mapmodels.add();
    s_strcpy(mmi.name, name);
    mmi.tex = *tex;
    mmi.m = NULL;
};
Example #8
0
bool_t grp_fill_name(resentry_t *re)
{
	s_strcpy(&(re->name), re->filename);
	s_strupper(re->name);
	if (is_dos_filename(re->name) == FALSE)
	{
		fprintf(stderr, "grp_fill_name: \"%s\" is not DOS filename.\n", re->name);
		return FALSE;
	}
	return TRUE;
}
Example #9
0
bool_t gob_fill_name(resentry_t *re)
{
	s_strcpy(&(re->name), re->filename);
	s_strupper(re->name);
	if (strlen(re->name) + 1 > GOB_ENTRY_NAME_SIZE)
	{
		fprintf(stderr, "gob_fill_name: Too long name \"%s\".\n", re->name);
		return FALSE;
	}
	return TRUE;
}
Example #10
0
bool_t pack_fill_name(resentry_t *re)
{
	s_strcpy(&(re->name), re->filename);
	if (strlen(re->name) > PACK_ENTRY_NAME_SIZE)
	{
		fprintf(stderr, "pack_fill_name: Too long name \"%s\".\n", re->name);
		return FALSE;
	}
	if (re->name == NULL)
		return FALSE;
	return TRUE;
}
Example #11
0
/* Ищет в таблице такой-же путь и если находит, то возвращает его номер,
 * а если не находит, то добавляет и возвращает номер добавленного пути.
 * В случае неудачи добавления возвращает -1. */
int32_t dat_add_path(dat_t *dat, const char *path)
{
	uint32_t i;

	for(i = 0; i < dat->numpaths; i++)
	{
		if (strcmp(dat->paths[i].name, path) == 0)
			return i;
	}
	if (dat_set_numpaths(dat, dat->numpaths + 1) == FALSE)
		return -1;
	s_strcpy(&(dat->paths[dat->numpaths - 1].name), path);
	return dat->numpaths - 1;
}
Example #12
0
void NvmLibrary::examineDeviceFw(const std::string &deviceUid, const std::string path,
	std::string imageVersion)
{
	LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
	int rc;

	NVM_UID lib_deviceUid;
	core::Helper::stringToUid(deviceUid, lib_deviceUid);

	char lib_path[path.size()];
	s_strcpy(lib_path, path.c_str(), path.size());

	char lib_imageVersion[imageVersion.size()];
	s_strcpy(lib_imageVersion, imageVersion.c_str(), imageVersion.size());

	rc = m_lib.examineDeviceFw(lib_deviceUid, lib_path, path.size(), lib_imageVersion,
		imageVersion.size());
	if (rc < 0)
	{
		throw core::LibraryException(rc);
	}

}
Example #13
0
void NvmLibrary::setPassphrase(const std::string &deviceUid, const std::string oldPassphrase,
	const std::string newPassphrase)
{
	LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
	int rc;

	NVM_UID lib_deviceUid;
	core::Helper::stringToUid(deviceUid, lib_deviceUid);

	char lib_oldPassphrase[oldPassphrase.size()];
	s_strcpy(lib_oldPassphrase, oldPassphrase.c_str(), oldPassphrase.size());

	char lib_newPassphrase[newPassphrase.size()];
	s_strcpy(lib_newPassphrase, newPassphrase.c_str(), newPassphrase.size());

	rc = m_lib.setPassphrase(lib_deviceUid, lib_oldPassphrase, oldPassphrase.size(),
		lib_newPassphrase, newPassphrase.size());
	if (rc < 0)
	{
		throw core::LibraryException(rc);
	}

}
Example #14
0
void NvmLibrary::saveState(const std::string name)
{
	LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
	int rc;

	char lib_name[name.size()];
	s_strcpy(lib_name, name.c_str(), name.size());

	rc = m_lib.saveState(lib_name, name.size());
	if (rc < 0)
	{
		throw core::LibraryException(rc);
	}

}
Example #15
0
void NvmLibrary::gatherSupport(const std::string supportFile)
{
	LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
	int rc;

	char lib_supportFile[supportFile.size()];
	s_strcpy(lib_supportFile, supportFile.c_str(), supportFile.size());

	rc = m_lib.gatherSupport(lib_supportFile, supportFile.size());
	if (rc < 0)
	{
		throw core::LibraryException(rc);
	}

}
Example #16
0
void NvmLibrary::addSimulator(const std::string simulator)
{
	LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
	int rc;

	char lib_simulator[simulator.size()];
	s_strcpy(lib_simulator, simulator.c_str(), simulator.size());

	rc = m_lib.addSimulator(lib_simulator, simulator.size());
	if (rc < 0)
	{
		throw core::LibraryException(rc);
	}

}
Example #17
0
bool_t dat_fill_name(resentry_t *re)
{
	char *s;
	s_strcpy(&(re->name), re->filename);
	if (re->name == NULL)
		return FALSE;
	s = re->name;
	while (*s != '\0')
	{
		if (*s == SYS_PATH_DELIM)
			*s = DAT_PATH_DELIM;
		s++;
	}
	/*strupper(re->name);*/
	return TRUE;
}
Example #18
0
/*
 * This gets called from int main() when the SCM is starting the service
 */
bool serviceInit(std::string serviceName)
{
	s_strcpy(g_serviceName, serviceName.c_str(), MAX_SERVICE_NAME);
	bool result = true;

	SERVICE_TABLE_ENTRY service_table[] = {
			{g_serviceName, (LPSERVICE_MAIN_FUNCTION) ServiceMain},
			{NULL, NULL}
	};

	if (StartServiceCtrlDispatcher(service_table) == 0)
	{
		logStartError("StartServiceCtrlDispatcher start failed.");
		result = false;
	}
	return result;
}
Example #19
0
void NvmLibrary::loadConfig(const std::string &deviceUid, const std::string file)
{
	LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
	int rc;

	NVM_UID lib_deviceUid;
	core::Helper::stringToUid(deviceUid, lib_deviceUid);

	char lib_file[file.size()];
	s_strcpy(lib_file, file.c_str(), file.size());

	rc = m_lib.loadConfig(lib_deviceUid, lib_file, file.size());
	if (rc < 0)
	{
		throw core::LibraryException(rc);
	}

}
Example #20
0
void NvmLibrary::unlockDevice(const std::string &deviceUid, const std::string passphrase)
{
	LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
	int rc;

	NVM_UID lib_deviceUid;
	core::Helper::stringToUid(deviceUid, lib_deviceUid);

	char lib_passphrase[passphrase.size()];
	s_strcpy(lib_passphrase, passphrase.c_str(), passphrase.size());

	rc = m_lib.unlockDevice(lib_deviceUid, lib_passphrase, passphrase.size());
	if (rc < 0)
	{
		throw core::LibraryException(rc);
	}

}
Example #21
0
void NvmLibrary::updateDeviceFw(const std::string &deviceUid, const std::string path,
	const bool activate, const bool force)
{
	LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
	int rc;

	NVM_UID lib_deviceUid;
	core::Helper::stringToUid(deviceUid, lib_deviceUid);

	char lib_path[path.size()];
	s_strcpy(lib_path, path.c_str(), path.size());

	rc = m_lib.updateDeviceFw(lib_deviceUid, lib_path, path.size(), activate, force);
	if (rc < 0)
	{
		throw core::LibraryException(rc);
	}

}
Example #22
0
bool_t dat_extract_resource(restable_t *rt, uint32_t i)
{
	char *filename;

	filename = NULL;
	s_strcpy(&filename, rt->basepath);
	s_strcat(&filename, rt->entries[i].filename);
	fseek(rt->file, rt->entries[i].offset, SEEK_SET);
	if (c_fextract(filename, rt->file, rt->entries[i].size,
                rt->entries[i].compression == 0x40 ? rt->entries[i].compressed : 0,
                &comdec_dat) == FALSE)
	{
		fprintf(stderr, "dat_unpack_files: Can't extract entry #%u.\n", i);
		s_free(&filename);
	   	return FALSE;
	}
	s_free(&filename);
	return TRUE;
}
Example #23
0
bool_t dat_to_rt(restable_t *rt, dat_t *dat)
{
	uint32_t i;

	if (rt_set_number(rt, dat->numfiles) == FALSE)
		return FALSE;
	for(i = 0; i < dat->numfiles; i++)
	{
		s_strcpy(&(rt->entries[i].name),
			dat->paths[dat->files[i].path].name);
		s_strcat(&(rt->entries[i].name), DAT_PATH_SDELIM);
		s_strcat(&(rt->entries[i].name), dat->files[i].name);
		rt->entries[i].compression = dat->files[i].compression;
		rt->entries[i].offset = dat->files[i].offset;
		rt->entries[i].size = dat->files[i].size;
		rt->entries[i].compressed = dat->files[i].compressed;
		if (rt->entries[i].compression == 0x20)
			rt->entries[i].compressed = rt->entries[i].size;
	}
	return TRUE;
}
Example #24
0
/*
 * Retrieve the operating system version as a string.
 */
int get_os_version(char *os_version, const COMMON_SIZE os_version_len)
{
	int rc = COMMON_SUCCESS;
	if (os_version == NULL || os_version_len == 0)
	{
		rc = COMMON_ERR_INVALIDPARAMETER;
	}
	else
	{
		// get the OS info
		struct utsname name;
		if (uname(&name) == -1)
		{
			rc = COMMON_ERR_UNKNOWN;
		}
		else
		{
			s_strcpy(os_version, name.release, os_version_len);
		}
	}
	return rc;
}
Example #25
0
bool_t dat_add_resource(restable_t *rt, uint32_t i)
{
	char *filename;

	filename = NULL;
	rt->entries[i].offset = ftell(rt->file);
	s_strcpy(&filename, rt->basepath);
	s_strcat(&filename, rt->entries[i].filename);
	if (c_fadd(rt->file, filename, &(rt->entries[i].size),
                &(rt->entries[i].compressed),
                &comdec_dat, 9) == FALSE)
	{
		fprintf(stderr, "dat_add_resource: Can't add entry #%u.\n", i);
		s_free(&filename);
		return FALSE;
	}
	if (rt->entries[i].compressed != 0)
                rt->entries[i].compression = 0x40;
        else
                rt->entries[i].compression = 0x20;
	s_free(&filename);
	return TRUE;
}
Example #26
0
bool_t dat_from_rt(restable_t *rt, dat_t *dat)
{
	uint32_t i;
	int32_t j;
	char *path;
	
	if (dat_set_numfiles(dat, rt->number) == FALSE)
		return FALSE;
		
	path = NULL;
	for(i = 0; i < rt->number; i++)
	{
		/* Добавление пути */
		s_path(&path, rt->entries[i].name, DAT_PATH_DELIM);
		s_cut_suffix(&path, path, DAT_PATH_SDELIM);
		if (strlen(path) == 0)
			s_strcpy(&path, ".");
		j = dat_add_path(dat, path);
		s_free(&path);
		if (j == -1)
			return FALSE;
		dat->paths[j].numfiles++;
		
		/* Добавление файла */
		s_nameext(&(dat->files[i].name), rt->entries[i].name,
			DAT_PATH_DELIM);
		dat->files[i].path = j;
		dat->files[i].compression = rt->entries[i].compression;
		dat->files[i].offset = rt->entries[i].offset;
		dat->files[i].size = rt->entries[i].size;
		if (dat->files[i].compression == 0x40)
			dat->files[i].compressed = rt->entries[i].compressed;
		else
			dat->files[i].compressed = 0;
	}
	return TRUE;
}
Example #27
0
int ns__getClientUpdate(struct soap *soap, struct clientUpdateInfoRequest sClientUpdateInfo, struct clientUpdateResponse* lpsResponse)
{
	unsigned int er = erSuccess;
	ClientVersion sCurrentVersion = {0};
	ClientVersion sLatestVersion;
	unsigned int ulLicenseResponse = 0;
	unsigned char *lpLicenseResponse = NULL;
	ECLicenseClient *lpLicenseClient = NULL;
	std::string strClientMSIName;
	std::string strPath;
	FILE *fd = NULL;
	int res;
	unsigned int ulUserID = 0;
	ECSession *lpecSession = NULL;
	ECDatabase *lpDatabase = NULL;
	std::string strCurVersion;
	std::string strLatestVersion;
	std::string strQuery;
	time_t	tNow = 0;

	char *lpszClientUpdatePath = g_lpConfig->GetSetting("client_update_path");
	unsigned int ulLogLevel = atoui(g_lpConfig->GetSetting("client_update_log_level"));

	if (!parseBool(g_lpConfig->GetSetting("client_update_enabled"))) {
		// do not set on high loglevel, since by default the client updater is installed, and this will be quite often in your log
		g_lpLogger->Log(EC_LOGLEVEL_NOTICE, "Client update: trackid: 0x%08X, Config option 'client_update_enabled' has disabled this feature.", sClientUpdateInfo.ulTrackId);
		er = ZARAFA_E_NO_SUPPORT;
		goto exit;
	}

	// setup soap
	soap_set_imode(soap, SOAP_IO_KEEPALIVE | SOAP_C_UTFSTRING | SOAP_ENC_ZLIB | SOAP_ENC_MTOM);
	soap_set_omode(soap, SOAP_IO_KEEPALIVE | SOAP_C_UTFSTRING | SOAP_ENC_ZLIB | SOAP_ENC_MTOM | SOAP_IO_CHUNK);

	if (!lpszClientUpdatePath || lpszClientUpdatePath[0] == 0) {
		g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, The configuration field 'client_update_path' is empty.", sClientUpdateInfo.ulTrackId);
		er = ZARAFA_E_NO_ACCESS;
		goto exit;
	}

	er = g_lpSessionManager->CreateSessionInternal(&lpecSession);
	if(er != erSuccess)
		goto exit;

	// Lock the session
	lpecSession->Lock();

	er = lpecSession->GetDatabase(&lpDatabase);
	if (er != erSuccess)
		goto exit;

//@TODO change loglevel?
	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, computername: %s, username: %s, clientversion: %s, windowsversion: %s, iplist: %s, soapip: %s", 
		sClientUpdateInfo.ulTrackId,
		(sClientUpdateInfo.szComputerName) ? sClientUpdateInfo.szComputerName : "-",
		(sClientUpdateInfo.szUsername) ? sClientUpdateInfo.szUsername : "******",
		(sClientUpdateInfo.szClientVersion) ? sClientUpdateInfo.szClientVersion : "-",
		(sClientUpdateInfo.szWindowsVersion) ? sClientUpdateInfo.szWindowsVersion : "-",
		(sClientUpdateInfo.szClientIPList) ? sClientUpdateInfo.szClientIPList : "-",
		PrettyIP(soap->ip).c_str() );

	if (!sClientUpdateInfo.szComputerName)
		sClientUpdateInfo.szComputerName = ""; //Client has no name?

	if(!sClientUpdateInfo.szUsername) {
		er = ZARAFA_E_NO_ACCESS;
		g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, Client did not send a username", sClientUpdateInfo.ulTrackId);
	}

	// validate user name
	er = lpecSession->GetUserManagement()->SearchObjectAndSync(sClientUpdateInfo.szUsername, 0x01/*EMS_AB_ADDRESS_LOOKUP*/, &ulUserID);
	if (er != erSuccess) {
		er = ZARAFA_E_NO_ACCESS;
		g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, unknown username '%s'", sClientUpdateInfo.ulTrackId, sClientUpdateInfo.szUsername);
	}


	if(lpecSession->GetUserManagement()->IsInternalObject(ulUserID)) {
		er = ZARAFA_E_NO_ACCESS;
		g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, Wrong user data. User name '%s' is a reserved user", sClientUpdateInfo.ulTrackId, sClientUpdateInfo.szUsername);
		goto exit;
	}

	// Check if the user connect to the right server, else redirect
	if (lpecSession->GetSessionManager()->IsDistributedSupported() ) 
	{
		objectdetails_t sUserDetails;

		er = lpecSession->GetUserManagement()->GetObjectDetails(ulUserID, &sUserDetails);
		if (er != erSuccess)
			goto exit;

		/* Check if this is the correct server */
		string strServerName = sUserDetails.GetPropString(OB_PROP_S_SERVERNAME);
		if (strServerName.empty()) {
			g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, User '%s' has no default server", sClientUpdateInfo.ulTrackId, sClientUpdateInfo.szUsername);
			er = ZARAFA_E_NO_ACCESS;
			goto exit;
		}

		if (stricmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) != 0) {
			string	strServerPath;

			er = GetBestServerPath(soap, lpecSession, strServerName, &strServerPath);
			if (er != erSuccess)
				goto exit;

			lpsResponse->lpszServerPath = s_strcpy(soap, strServerPath.c_str());// Server Path must always utf8 (also in 6.40.x)
			g_lpSessionManager->GetLogger()->Log(EC_LOGLEVEL_INFO, "Client update: trackid: 0x%08X, User '%s' is redirected to '%s'", sClientUpdateInfo.ulTrackId, sClientUpdateInfo.szUsername, lpsResponse->lpszServerPath);
			g_lpStatsCollector->Increment(SCN_REDIRECT_COUNT, 1);
			er = ZARAFA_E_UNABLE_TO_COMPLETE;
			goto exit;
		}
	}

	lpLicenseClient = new ECLicenseClient(g_lpConfig->GetSetting("license_socket"),  atoui(g_lpConfig->GetSetting("license_timeout")));
	er = lpLicenseClient->Auth(sClientUpdateInfo.sLicenseReq.__ptr, sClientUpdateInfo.sLicenseReq.__size, &lpLicenseResponse, &ulLicenseResponse);
	if (er != erSuccess) {
		g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, Invalid license request, error: 0x%08X.", sClientUpdateInfo.ulTrackId, er);
		goto exit;
	}

	if (sClientUpdateInfo.szClientVersion == NULL || sClientUpdateInfo.szClientVersion[0] == '\0') {
		g_lpLogger->Log(EC_LOGLEVEL_INFO, "Client update: trackid: 0x%08X, The client did not sent the current version number.", sClientUpdateInfo.ulTrackId);
	} else if (!GetVersionFromString(sClientUpdateInfo.szClientVersion, &sCurrentVersion)) {
		g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, Failed in getting version from input data.", sClientUpdateInfo.ulTrackId);
		goto exit; //@fixme can we give the latest?
	}

	if (!GetLatestVersionAtServer(lpszClientUpdatePath, sClientUpdateInfo.ulTrackId, &sLatestVersion)) {
		g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, No updates found on server.", sClientUpdateInfo.ulTrackId);
		er = ZARAFA_E_NO_ACCESS;
		goto exit;
	}

	res = CompareVersions(sCurrentVersion, sLatestVersion);
	if (res == 0) {
		g_lpLogger->Log(EC_LOGLEVEL_INFO, "Client update: trackid: 0x%08X, Client already has the latest version.", sClientUpdateInfo.ulTrackId);
		goto ok;
	} else if (res > 0) {
		g_lpLogger->Log(EC_LOGLEVEL_INFO, "Client update: trackid: 0x%08X, Client has newer version than server.", sClientUpdateInfo.ulTrackId);
		goto ok;
	}

	if (!GetClientMSINameFromVersion(sLatestVersion, &strClientMSIName)) {
		g_lpLogger->Log(EC_LOGLEVEL_INFO, "Client update: trackid: 0x%08X, No suitable version available.", sClientUpdateInfo.ulTrackId);
		er = ZARAFA_E_NO_ACCESS;
		goto exit;
	}

	if (ConvertAndValidatePath(lpszClientUpdatePath, strClientMSIName, &strPath) != true) {
		g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, Error in path conversion and validation.", sClientUpdateInfo.ulTrackId);
		er = ZARAFA_E_NO_ACCESS;
		goto exit;
	}

	fd = fopen(strPath.c_str(), "rb");
	if (!fd) {
		g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, Path not found %s.", sClientUpdateInfo.ulTrackId, strPath.c_str());
		er = ZARAFA_E_NO_ACCESS;
		goto exit;
	}

	// Update auto update client status
	VersionToString(sCurrentVersion, &strCurVersion);
	VersionToString(sLatestVersion, &strLatestVersion);

	tNow = time(NULL); // Get current time

	strQuery = "REPLACE INTO clientupdatestatus(userid, trackid, updatetime, currentversion, latestversion, computername, status) VALUES ("+
				stringify(ulUserID)+", "+stringify(sClientUpdateInfo.ulTrackId)+", FROM_UNIXTIME("+
				stringify(tNow) + "), \"" + strCurVersion + "\", \"" + strLatestVersion + "\", \"" +
				lpDatabase->Escape(sClientUpdateInfo.szComputerName).c_str()+"\", "+ stringify(UPDATE_STATUS_PENDING) + ")";

	// ignore error in database tracking, SQL error logged in server, still send new client
	lpDatabase->DoUpdate(strQuery);

	soap->fmimereadopen = &mime_file_read_open;
	soap->fmimeread = &mime_file_read;
	soap->fmimereadclose = &mime_file_read_close;

	// Setup the MTOM Attachments
	lpsResponse->sStreamData.xop__Include.__ptr = (unsigned char*)fd;
	lpsResponse->sStreamData.xop__Include.__size = 0;
	lpsResponse->sStreamData.xop__Include.type = s_strcpy(soap, "application/binary");
	lpsResponse->sStreamData.xop__Include.id = s_strcpy(soap, "zarafaclient");

	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, Sending new installer %s", sClientUpdateInfo.ulTrackId, strClientMSIName.c_str());

ok: // Client is already up to date
	lpsResponse->sLicenseResponse.__size = ulLicenseResponse;
	lpsResponse->sLicenseResponse.__ptr = (unsigned char *)s_memcpy(soap, (const char *)lpLicenseResponse, ulLicenseResponse);
	
	lpsResponse->ulLogLevel = ulLogLevel; // 0 = none, 1 = on errors, 2 = always
	
exit:
	if(lpecSession) {
		lpecSession->Unlock(); 
		g_lpSessionManager->RemoveSessionInternal(lpecSession);
	}

	lpsResponse->er = er;

	if (lpLicenseResponse)
		delete [] lpLicenseResponse;

	if (lpLicenseClient)
		delete lpLicenseClient;

	if (er && fd)
		fclose(fd);

	return SOAP_OK;
}
Example #28
0
/*
 * Check for namespace health transitions
 */
void monitor::EventMonitor::monitorNamespaces(PersistentStore *pStore)
{
	LogEnterExit logging(__FUNCTION__, __FILE__, __LINE__);
	if (pStore)
	{
		// get namespaces
		int nsCount = nvm_get_namespace_count();
		if (nsCount < 0)
		{
			COMMON_LOG_ERROR_F("nvm_get_namespace_count failed with error %d", nsCount);
		}
		else if (nsCount > 0)
		{
			struct namespace_discovery namespaces[nsCount];
			memset(namespaces, 0, sizeof (struct namespace_discovery) * nsCount);
			nsCount = nvm_get_namespaces(namespaces, nsCount);
			if (nsCount < 0)
			{
				COMMON_LOG_ERROR_F("nvm_get_namespaces failed with error %d", nsCount);
			}
			else if (nsCount > 0)
			{
				// for each namespace
				for (int i = 0; i < nsCount; i++)
				{
					struct namespace_details details;
					memset(&details, 0, sizeof (details));
					NVM_UID uidStr;
					uid_copy(namespaces[i].namespace_uid, uidStr);
					int rc = nvm_get_namespace_details(namespaces[i].namespace_uid, &details);
					if (rc != NVM_SUCCESS)
					{
						COMMON_LOG_ERROR_F("nvm_get_namespace_details for namespace %s failed with error %d",
								uidStr, rc);
					}
					else
					{
						// get the stored state for this namespace
						bool storedStateChanged = false;

						struct db_namespace_state storedState;
						memset(&storedState, 0, sizeof (storedState));
						if (db_get_namespace_state_by_namespace_uid(pStore,
								uidStr, &storedState) != DB_SUCCESS)
						{
							// initial state, just store current state
							s_strcpy(storedState.namespace_uid, uidStr,
									NAMESPACE_STATE_NAMESPACE_UID_LEN);
							storedState.health_state = details.health;
							storedStateChanged = true;
						}
						// log health transition event
						else if (details.health != storedState.health_state)
						{
							enum event_severity severity = EVENT_SEVERITY_INFO;
							bool actionRequired = false;
							// namespace is failed
							if (details.health == NAMESPACE_HEALTH_CRITICAL ||
								details.health == NAMESPACE_HEALTH_BROKENMIRROR)
							{
								severity = EVENT_SEVERITY_CRITICAL;
								actionRequired = true;
							}
							// namespace is not failed
							else
							{
								// auto-acknowledge any old namespace health failed events
								acknowledgeEvent(EVENT_CODE_HEALTH_NAMESPACE_HEALTH_STATE_CHANGED,
										namespaces[i].namespace_uid);
							}

							std::string oldState = namespaceHealthToStr(
									(enum namespace_health)storedState.health_state);
							std::string newState = namespaceHealthToStr(details.health);
							store_event_by_parts(
									EVENT_TYPE_HEALTH,
									severity,
									EVENT_CODE_HEALTH_NAMESPACE_HEALTH_STATE_CHANGED,
									namespaces[i].namespace_uid,
									actionRequired,
									uidStr,
									oldState.c_str(),
									newState.c_str(),
									DIAGNOSTIC_RESULT_UNKNOWN);

							storedStateChanged = true;
							storedState.health_state = details.health;
							if (db_delete_namespace_state_by_namespace_uid(pStore,
									uidStr) != DB_SUCCESS)
							{
								COMMON_LOG_ERROR_F(
									"Failed to clean up the stored health state for namespace %s",
									uidStr);
							}
						}

						if (storedStateChanged)
						{
							if (db_add_namespace_state(pStore, &storedState) != DB_SUCCESS)
							{
								COMMON_LOG_ERROR_F(
									"Failed to update the stored health state for namespace %s",
									uidStr);
							}
						}
					} // end nvm_get_namespace_details
				} // end for each namespace
			} // end nvm_get_namespaces
		} // end nvm_get_namespace_count
	} // end get peristent store
}
Example #29
0
ECRESULT ECUserStoreTable::QueryRowData(ECGenericObjectTable *lpThis, struct soap *soap, ECSession *lpSession, ECObjectTableList* lpRowList, struct propTagArray *lpsPropTagArray, void* lpObjectData, struct rowSet **lppRowSet, bool bCacheTableData, bool bTableLimit)
{
	ECRESULT er = erSuccess;
	ECUserStoreTable *pThis = dynamic_cast<ECUserStoreTable*>(lpThis);
	struct rowSet *lpsRowSet = NULL;
	ECObjectTableList::iterator iterRowList;
	int i, k;
	GUID sZeroGuid = {0};

	if (!lpThis) {
		er = ZARAFA_E_INVALID_PARAMETER;
		goto exit;
	}

	lpsRowSet = s_alloc<rowSet>(soap);
	lpsRowSet->__size = 0;
	lpsRowSet->__ptr = NULL;

	if(lpRowList->empty()) {
		*lppRowSet = lpsRowSet;
		goto exit; // success
	}

	// We return a square array with all the values
	lpsRowSet->__size = lpRowList->size();
	lpsRowSet->__ptr = s_alloc<propValArray>(soap, lpsRowSet->__size);
	memset(lpsRowSet->__ptr, 0, sizeof(propValArray) * lpsRowSet->__size);

	// Allocate memory for all rows
	for (i = 0; i < lpsRowSet->__size; i++) {
		lpsRowSet->__ptr[i].__size = lpsPropTagArray->__size;
		lpsRowSet->__ptr[i].__ptr = s_alloc<propVal>(soap, lpsPropTagArray->__size);
		memset(lpsRowSet->__ptr[i].__ptr, 0, sizeof(propVal) * lpsPropTagArray->__size);
	}

	for (i = 0, iterRowList = lpRowList->begin(); iterRowList != lpRowList->end(); iterRowList++, i++) {
		for (k = 0; k < lpsPropTagArray->__size; k++) {

			lpsRowSet->__ptr[i].__ptr[k].ulPropTag = PROP_TAG(PT_ERROR, lpsPropTagArray->__ptr[k]);
			lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_ul;
			lpsRowSet->__ptr[i].__ptr[k].Value.ul = ZARAFA_E_NOT_FOUND;

			switch (PROP_ID(lpsPropTagArray->__ptr[k])) {
			case PROP_ID(PR_INSTANCE_KEY):
				// generate key 
				lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_bin;
				lpsRowSet->__ptr[i].__ptr[k].ulPropTag = PR_INSTANCE_KEY;
				lpsRowSet->__ptr[i].__ptr[k].Value.bin = s_alloc<xsd__base64Binary>(soap);
				lpsRowSet->__ptr[i].__ptr[k].Value.bin->__size = sizeof(sObjectTableKey);
				lpsRowSet->__ptr[i].__ptr[k].Value.bin->__ptr = s_alloc<unsigned char>(soap, sizeof(sObjectTableKey));
				memcpy(lpsRowSet->__ptr[i].__ptr[k].Value.bin->__ptr, (void*)&(*iterRowList), sizeof(sObjectTableKey));
				break;

			case PROP_ID(PR_EC_USERNAME):
				if (!pThis->m_mapUserStoreData[iterRowList->ulObjId].strUsername.empty()) {
					lpsRowSet->__ptr[i].__ptr[k].ulPropTag = lpsPropTagArray->__ptr[k];

					lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_lpszA;
					lpsRowSet->__ptr[i].__ptr[k].Value.lpszA = s_strcpy(soap, (char*)pThis->m_mapUserStoreData[iterRowList->ulObjId].strUsername.c_str());
				}
				break;
			case PROP_ID(PR_DISPLAY_NAME):
				if (!pThis->m_mapUserStoreData[iterRowList->ulObjId].strGuessname.empty()) {
					lpsRowSet->__ptr[i].__ptr[k].ulPropTag = lpsPropTagArray->__ptr[k];

					lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_lpszA;
					lpsRowSet->__ptr[i].__ptr[k].Value.lpszA = s_strcpy(soap, (char*)pThis->m_mapUserStoreData[iterRowList->ulObjId].strGuessname.c_str());
				}
				break;
			case PROP_ID(PR_EC_STOREGUID):
				if (pThis->m_mapUserStoreData[iterRowList->ulObjId].sGuid != sZeroGuid) {
					lpsRowSet->__ptr[i].__ptr[k].ulPropTag = lpsPropTagArray->__ptr[k];

					lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_bin;
					lpsRowSet->__ptr[i].__ptr[k].Value.bin = s_alloc<xsd__base64Binary>(soap);
					lpsRowSet->__ptr[i].__ptr[k].Value.bin->__size = sizeof(GUID);
					lpsRowSet->__ptr[i].__ptr[k].Value.bin->__ptr = s_alloc<unsigned char>(soap, sizeof(GUID));
					memcpy(lpsRowSet->__ptr[i].__ptr[k].Value.bin->__ptr, (unsigned char*)&pThis->m_mapUserStoreData[iterRowList->ulObjId].sGuid, sizeof(GUID));
				}
				break;
			case PROP_ID(PR_EC_STORETYPE):
				lpsRowSet->__ptr[i].__ptr[k].ulPropTag = lpsPropTagArray->__ptr[k];

				lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_ul;
				lpsRowSet->__ptr[i].__ptr[k].Value.ul = pThis->m_mapUserStoreData[iterRowList->ulObjId].ulStoreType;
				break;
			case PROP_ID(PR_EC_COMPANYID):
				if (pThis->m_mapUserStoreData[iterRowList->ulObjId].ulCompanyId != 0) {
					lpsRowSet->__ptr[i].__ptr[k].ulPropTag = lpsPropTagArray->__ptr[k];

					lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_ul;
					lpsRowSet->__ptr[i].__ptr[k].Value.ul = pThis->m_mapUserStoreData[iterRowList->ulObjId].ulCompanyId;
				}
				break;
			case PROP_ID(PR_EC_COMPANY_NAME):
				if (!pThis->m_mapUserStoreData[iterRowList->ulObjId].strCompanyName.empty()) {
					lpsRowSet->__ptr[i].__ptr[k].ulPropTag = lpsPropTagArray->__ptr[k];

					lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_lpszA;
					lpsRowSet->__ptr[i].__ptr[k].Value.lpszA = s_strcpy(soap, (char*)pThis->m_mapUserStoreData[iterRowList->ulObjId].strCompanyName.c_str());
				}
				break;
			case PROP_ID(PR_STORE_ENTRYID):
				// ignore errors
				ECGenProps::GetPropComputedUncached(soap, NULL ,lpSession, PR_STORE_ENTRYID, pThis->m_mapUserStoreData[iterRowList->ulObjId].ulObjId, 0,
							   				pThis->m_mapUserStoreData[iterRowList->ulObjId].ulObjId, 0, MAPI_STORE, &lpsRowSet->__ptr[i].__ptr[k]);
				break;
			case PROP_ID(PR_LAST_MODIFICATION_TIME):
				if (pThis->m_mapUserStoreData[iterRowList->ulObjId].tModTime != 0) {
					FILETIME ftTmp;
					UnixTimeToFileTime(pThis->m_mapUserStoreData[iterRowList->ulObjId].tModTime, &ftTmp);

					lpsRowSet->__ptr[i].__ptr[k].ulPropTag = lpsPropTagArray->__ptr[k];
					lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_hilo;
					lpsRowSet->__ptr[i].__ptr[k].Value.hilo = s_alloc<struct hiloLong>(soap);
					lpsRowSet->__ptr[i].__ptr[k].Value.hilo->hi = ftTmp.dwHighDateTime;
					lpsRowSet->__ptr[i].__ptr[k].Value.hilo->lo = ftTmp.dwLowDateTime;
				}
				break;
			case PROP_ID(PR_MESSAGE_SIZE_EXTENDED):
				lpsRowSet->__ptr[i].__ptr[k].ulPropTag = lpsPropTagArray->__ptr[k];
				lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_li;
				lpsRowSet->__ptr[i].__ptr[k].Value.li = pThis->m_mapUserStoreData[iterRowList->ulObjId].ullStoreSize;
				break;
			default:
				lpsRowSet->__ptr[i].__ptr[k].ulPropTag = PROP_TAG(PT_ERROR, lpsPropTagArray->__ptr[k]);

				lpsRowSet->__ptr[i].__ptr[k].__union = SOAP_UNION_propValData_ul;
				lpsRowSet->__ptr[i].__ptr[k].Value.ul = ZARAFA_E_NOT_FOUND;
				break;
			};
		}
	}

	*lppRowSet = lpsRowSet;

exit:
	return er;
}
Example #30
0
/* wrapper for dlopen */
S_API void *s_win32_dll_open(const char *filename, s_erc *error)
{
	HMODULE dso_handle;
	UINT em;
	DWORD last_error;
	char errstr[65535];
	char buf[S_MAX_PATH_LENGTH];
	char *p;


	S_CLR_ERR(error);
	em = SetErrorMode(SEM_FAILCRITICALERRORS);
	SetLastError(0);

	if (filename == NULL)
	{
		dso_handle = GetModuleHandle( NULL );

		if (dso_handle == NULL)
		{
			last_error = GetLastError();
			FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
						  last_error, 0,
						  errstr, sizeof(errstr), NULL);

			S_CTX_ERR(error, S_FAILURE,
					  "s_win32_dll_open",
					  "Failed to open dso \"NULL\". Reported error \"%s\"",
					  errstr);
			SetLastError(0);
			SetErrorMode(em);

			return NULL;
		}

		SetLastError(0);
		SetErrorMode(em);
		return dso_handle;
	}

	s_strcpy(buf, filename, error);
	if (S_CHK_ERR(error, S_CONTERR,
				  "s_win32_dll_open",
				  "Call to \"s_strcpy\" failed"))
	{
		SetLastError(0);
		SetErrorMode(em);
		return NULL;
	}

	for (p = buf; *p != '\0'; p++)
	{
		if (*p == '/')
		{
			*p = '\\';
		}
	}

	dso_handle = LoadLibraryEx((LPSTR)buf, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);

	if (dso_handle == NULL)
	{
		last_error = GetLastError();
		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL,
					  last_error, 0,
					  errstr, sizeof(errstr), NULL);

		S_CTX_ERR(error, S_FAILURE,
				  "s_win32_dll_open",
				  "Failed to open dso at \'%s\'. Reported error \"%s\"",
				  filename, errstr);
	}

	SetLastError(0);
	SetErrorMode(em);

	return (void*)dso_handle;
}