Commit 42c676684387db567c692a0384f9eebb28335857 - kopanocore

+5

-19

.gitignore less more

61	61
62	62	# /common/
63	63	/common/config.h*
	64	/common/cov-scope
64	65	/common/ecversion.h
65	66	/common/include/kopano/ecversion.h
66	67	/common/include/kopano/zconfig.h

81	82	# /installer/linux/
82	83	/installer/linux/ldap.openldap.cfg
83	84	/installer/linux/ldap.active-directory.cfg
	85	/installer/linux/ldapms.openldap.cfg
	86	/installer/linux/ldapms.active-directory.cfg
84	87
85	88	# /installer/userscripts/
86	89	/installer/userscripts/creategroup

90	93	/installer/userscripts/createcompany
91	94	/installer/userscripts/deletecompany
92	95
93		# /php-webclient-ajax/
94		/php-webclient-ajax/debug.txt
95		/php-webclient-ajax/errors.txt
96		/php-webclient-ajax/debug_xml
97		/php-webclient-ajax/tmp
98		/php-webclient-ajax/config.php
99
100		## /provider/ECProps/
101		#/provider/ECProps/Debug
102		#
103		## /provider/client/
104		#/provider/client/Debug
105		#/provider/client/Release
106		#
107		## /provider/plugins/
108		#/provider/plugins/plugintest
109		#
110		# /provider/server/
111		/provider/server/kopano-server
	96	/provider/kopano-server
112	97
113	98	# /provider/soap/
114	99	/provider/soap/*res.xml

151	136	/swig/python/RecurrenceState.py
152	137	/swig/python/RecurrenceState_wrap.cxx
153	138	/swig/python/kopano/build/
	139	/swig/python/zarafa/build/
154	140
155	141	# Ignore Python compiled files
156	142	*.pyc

+45

-0

Code_structure.md less more

	0	A quick overview of the Kopano code structure
	1	=============================================
	2
	3	Overview
	4	========
	5
	6	The codebase has a lot of libraries, components and for example scripts.
	7	Each top level directory is listed below with a clear description of what it does.
	8
	9
	10	autoconf - helpers for autoconf: php, boost and swig
	11	caldav - Ical server implementation which uses kopano-server as backend
	12	common - commonly used libraries for everything except server/client. There are three different "common" utils: util, ssl and mapi.
	13	doc - Kopano documentation and manpages
	14	ECtools - ECtools consists of a lot of seperate tools which use the MAPI library.
	15	gateway - POP3/IMAP gateway for Kopano
	16	inetmapi - VMIME to MAPI and MAPI to VMIME library (should be called libinetmapi)
	17	libfreebusy - Freebusy library from windows and from Linux
	18	libicalmapi - Ical to MAPI and MAPI to Ical library
	19	mapi4linux - Source compatbile Windows MAPI library
	20	php-ext - PHP-MAPI module
	21	php7-ext - PHP-MAPI module (PHP 7)
	22	po - Translations
	23	provider - Directory where the kopano-server and client is located
	24	spooler - Kopano-dagent/spooler
	25	swig - Python bindings for MAPI
	26	tools - Collection of PHP and Python tools
	27	libsync - Shared library that is used by the synchronisation agent in Windows for offline synchronisation
	28
	29	MAPI Properties
	30	===============
	31
	32	All initial MAPI properties can be found in mapi4linux/include/mapi.h, later added property definitions are found in common/mapiext.h.
	33	Kopano defined properties (all properties which start with PR_EC_*) can be found in common/ECTags.h.
	34
	35	Provider
	36	========
	37
	38	Provider consists of a few directories:
	39	client - Generates mapi client exposes MAPI interface. (Providers GAB, all your stores, private and delegate)
	40	libserver - Splitted for historical reasons from server
	41	server - the kopano-server
	42	common - soap ulitlities for provider / client (ECSearchClient <-> Server and Indexer)
	43	contacts - addressbookprovier, displays one or multiple addressbooks in for example webapp as contacts.
	44	plugins - Userplugins: ldap, ad, db and unix.

+176

-0

Database_structure.md less more

	0	A quick overview of the Kopano Core database structure
	1	=======================================================
	2
	3	Overview
	4	========
	5
	6	The Datbase has the following tables:
	7	+--------------------+
	8	\| Tables_in_kopano \|
	9	+--------------------+
	10	\| abchanges \|
	11	\| acl \|
	12	\| changes \|
	13	\| clientupdatestatus \|
	14	\| deferredupdate \|
	15	\| hierarchy \|
	16	\| indexedproperties \|
	17	\| lob \|
	18	\| mvproperties \|
	19	\| names \|
	20	\| object \|
	21	\| objectmvproperty \|
	22	\| objectproperty \|
	23	\| objectrelation \|
	24	\| outgoingqueue \|
	25	\| properties \|
	26	\| receivefolder \|
	27	\| searchresults \|
	28	\| settings \|
	29	\| singleinstances \|
	30	\| stores \|
	31	\| syncedmessages \|
	32	\| syncs \|
	33	\| tproperties \|
	34	\| users \|
	35	\| versions \|
	36	+--------------------+
	37
	38	abchanges
	39	=========
	40
	41	Has a journal of all GAB changes -> every change (add/delete/modify) is in this
	42	table.
	43
	44	acl
	45	===
	46
	47	List of all acls - each record is an ACE (access control entry) userx has
	48	permissiony on folderz (With a pair record for rights for grant and deny, but
	49	deny was never implemented in the Kopano server) Columns:
	50
	51	* id:
	52	* hierarchy_id:
	53	* type: 2=grant,1=deny
	54	* rights: bitmask of the rights (owner, etc.) - same in mapi defined permissions
	55
	56	changes
	57	=======
	58
	59	Has a journal of all mailbox changes -> messages in folders added, deleted,
	60	modified - exposed via ICA.
	61
	62	clientupdatestatus
	63	==================
	64
	65	Has a list of all the reported statuses of client updates
	66
	67	deferredupdate
	68	==============
	69
	70	Is a per-folder list of changes to tproperties that haven't been written to
	71	tproperties yet (for performance reasons)
	72
	73	hierarchy
	74	=========
	75
	76	Is the parent-child relationship table for the mailbox (IPM_SUBTREE_ROOT -> ...)
	77
	78	Columns
	79	* id:
	80	* parent:
	81	* type: 1=mailbox, 3=folder, 5=message, 6=recipient, 7=attachment
	82	* flags: folders:0=root folder,1=normal folder,2=search folder;
	83	messages:0=normal message, 64=associative message, 1024=deleted
	84	* owner:
	85
	86	indexedproperties
	87	=================
	88
	89	Mapping between from certain properties to their hierarchyid example:
	90	PR_ENTRY_ID abcdef match to hierarchy.id 12345
	91
	92	lob
	93	===
	94
	95	Attachments chunked into 256K blocks (only in mysql-stored format)
	96
	97	Names
	98	=====
	99
	100	Nothing but named properties mapping to property id's - property ids are
	101	subtracted by 0x8500
	102
	103	outgoingqueue
	104	=============
	105
	106	Two things: 1. queue that outlook polls for messages that it wants to send, 2.
	107	queue of spooler, of messages that it wants to send
	108
	109	Columns:
	110	* flags: if even then outlook queue, if odd spooler queue
	111	* properties - the list of properties for each hierarchy.id - each value is put
	112	into its corresponding column type (binary, double, etc.)
	113	* mvproperties - looks exactly the same, but it also has orderid, so there can
	114	* be multiple records for the same property for the same hierarchy.id (done for
	115	performance reasons)
	116
	117	receivefolder
	118	=============
	119	It points at which folder is your actual receivefolder in your hierarchy
	120
	121	searchresults
	122	=============
	123
	124	When you do a search all of the results are saved and updated forever until you
	125	delete the search folder settings - random server-wide settings
	126
	127	singleinstances
	128	===============
	129
	130	Record of attachment-deduplication (single instance store)
	131
	132	stores
	133	======
	134
	135	links stores to users (hierarchy.id to users.id)
	136
	137	syncedmessages
	138	==============
	139
	140	Is used in restricted ICS (when we can't use the journal) - sync only the last 4
	141	weeks is an example. This represents the messages that have been sent to a
	142	mobile. only for z-push
	143
	144	syncs
	145	=====
	146
	147	A list of all folders that are being tracked for ICS - we do not really use it,
	148	we only write to it (investigation, maybe?)
	149
	150	tproperties
	151	===========
	152
	153	The list of properties for each hierarchy.id - each value is put into its
	154	corresponding column type (binary, double, etc.) BUT It only contains the
	155	properties that can be seen in tables therefore excludes attachments and
	156	recipients everything is truncated to 255 bytes or characters.
	157
	158	users
	159	======
	160
	161	Users table with the relation column (externid)
	162
	163	Versions
	164	========
	165
	166	List of all zarafa versions ever installed on the system
	167
	168	=============================
	169	Tables specific for DB plugin
	170	=============================
	171
	172	object - everything normally in ldap
	173	objectmvproperty - everything normally in ldap
	174	objectproperty - everything normally in ldap
	175	objectrelation - everything normally in ldap

+3

-2

ECtools/Makefile.am less more

20	20	libkcarchiver.ldd libkcarchivercore.ldd \
21	21	kopano-archiver.ldx kopano-cfgchecker.ldx \
22	22	kopano-monitor.ldx kopano-passwd.ldx kopano-stats.ldx
	23	CLEANFILES = ${noinst_DATA}
23	24
24	25
25	26	kopano_admin_SOURCES = \

37	38	archiver/main.cpp
38	39	kopano_archiver_CPPFLAGS = \
39	40	${AM_CPPFLAGS} -I${top_srcdir}/provider/client \
40		-I${top_srcdir}/provider/include -I${top_srcdir}/provider/soap \
	41	-I${top_srcdir}/provider/include \
41	42	-I${top_builddir}/provider/soap -I${top_srcdir}/ECtools/archiver \
42	43	${GSOAP_CFLAGS} ${MYSQL_INCLUDES}
43	44	kopano_archiver_LDADD = \

196	197	EXTRA_libkcarchivercore_la_DEPENDENCIES = \
197	198	${top_builddir}/default.sym
198	199
199		mapitime_SOURCES = mapitime.cpp hx-time.c
	200	mapitime_SOURCES = mapitime.cpp
200	201	mapitime_LDADD = -lrt ${top_builddir}/mapi4linux/src/libmapi.la \
201	202	${top_builddir}/common/libkcmapi.la \
202	203	${top_builddir}/common/libkcutil.la

+21

-29

ECtools/admin/admin.cpp less more

46	46	#include <kopano/mapiext.h>
47	47	#include <kopano/Util.h>
48	48	#include <kopano/ECRestriction.h>
49		#include <kopano/ECABEntryID.h>
50	49	#include <kopano/charset/convert.h>
51	50	#include "ConsoleTable.h"
52	51	#include <kopano/mapi_ptr.h>

328	327	cout << endl;
329	328	cout << "Global options: [-h\|--host path]" << endl;
330	329	ct.Resize(4,2);
	330	ct.AddColumn(0, "--config file"); ct.AddColumn(1, "Use a configuration file");
331	331	ct.AddColumn(0, "-h path"); ct.AddColumn(1, "Connect through <path>, e.g. file:///var/run/socket");
332	332	ct.AddColumn(0, "--node name"); ct.AddColumn(1, "Execute the command on cluster node <name>");
	333	ct.AddColumn(0, "--utf8"); ct.AddColumn(1, "Force the current locale to UTF-8");
333	334	ct.AddColumn(0, "-v"); ct.AddColumn(1, "Increase verbosity. A maximum of 7 is possible where 1=fatal errors only, 6=debug and 7=everything.");
334	335	ct.AddColumn(0, "--verbosity x"); ct.AddColumn(1, "Set verbosity to value 'x': 0...7 (0 = disable)");
335	336	ct.AddColumn(0, "-V"); ct.AddColumn(1, "Print version info.");

845	846	if (lpECUser->lpszServername != NULL && *reinterpret_cast<LPSTR>(lpECUser->lpszServername) != '\0')
846	847	cout << "Home server:\t\t" << (LPSTR)lpECUser->lpszServername << endl;
847	848
848		adm_oof_status(lpProps);
849
850	849	if (lpProps) {
851	850	time_t logon = 0, logoff = 0;
852	851	char d[64];
853	852
	853	adm_oof_status(lpProps);
854	854	if(lpProps[0].ulPropTag == PR_LAST_LOGON_TIME)
855	855	FileTimeToUnixTime(lpProps[0].Value.ft, &logon);
856	856	if(lpProps[1].ulPropTag == PR_LAST_LOGOFF_TIME)

2290	2290	{
2291	2291	bool operator()(const string &t1, const string &t2) const
2292	2292	{
2293		return stricmp((char)t1.c_str(), (char)t2.c_str()) < 0;
	2293	return strcasecmp((char)t1.c_str(), (char)t2.c_str()) < 0;
2294	2294	}
2295	2295	};
2296	2296

2433	2433	unsigned int loglevel = EC_LOGLEVEL_NONE;
2434	2434
2435	2435	ECLogger *lpLogger = NULL;
2436
2437		InputValidator validateInput;
2438
2439	2436	const configsetting_t lpDefaults[] = {
2440	2437	{ "server_socket", "default:" },
2441	2438	{ "sslkey_file", "" },

2445	2442	ECConfig *lpsConfig = ECConfig::Create(lpDefaults);
2446	2443	bool bExplicitConfig = false;
2447	2444	ConsoleTable ct(0,0);
2448
2449		#ifdef LINUX
2450	2445	const char *szConfig = ECConfig::GetDefaultPath("admin.cfg");
2451		#else
2452		char *szConfig = "admin.cfg";
2453		#endif
2454
2455	2446
2456	2447	// Set locale to system variables
2457	2448	setlocale(LC_MESSAGES, "");

2465	2456
2466	2457	int c;
2467	2458	while (1) {
	2459	InputValidator validateInput;
2468	2460	c = getopt_long(argc, argv, "VlLsc:u:d:U:Pp:f:e:a:h:g:G:b:B:i:I:n:v", long_options, NULL);
2469	2461	if (c == -1)
2470	2462	break;

2590	2582	break;
2591	2583	// Make values from Mb to bytes which the server wants
2592	2584	case OPT_USER_QUOTA_HARD:
2593		quotahard = _atoi64(optarg) 10241024;
	2585	quotahard = atoll(optarg) 10241024;
2594	2586	break;
2595	2587	case OPT_USER_QUOTA_SOFT:
2596		quotasoft = _atoi64(optarg) 10241024;
	2588	quotasoft = atoll(optarg) 10241024;
2597	2589	break;
2598	2590	case OPT_USER_QUOTA_WARN:
2599		quotawarn = _atoi64(optarg) 10241024;
	2591	quotawarn = atoll(optarg) 10241024;
2600	2592	break;
2601	2593	case OPT_USER_QUOTA_OVERRIDE:
2602	2594	quota = parse_yesno(optarg);
2603	2595	break;
2604	2596	case OPT_USER_DEFAULT_QUOTA_HARD:
2605		ud_quotahard = _atoi64(optarg) * 1024 * 1024;
	2597	ud_quotahard = atoll(optarg) * 1024 * 1024;
2606	2598	break;
2607	2599	case OPT_USER_DEFAULT_QUOTA_SOFT:
2608		ud_quotasoft = _atoi64(optarg) * 1024 * 1024;
	2600	ud_quotasoft = atoll(optarg) * 1024 * 1024;
2609	2601	break;
2610	2602	case OPT_USER_DEFAULT_QUOTA_WARN:
2611		ud_quotawarn = _atoi64(optarg) * 1024 * 1024;
	2603	ud_quotawarn = atoll(optarg) * 1024 * 1024;
2612	2604	break;
2613	2605	case OPT_USER_DEFAULT_QUOTA_OVERRIDE:
2614	2606	ud_quota = parse_yesno(optarg);

2779	2771	cerr << "Username (-u) cannot be empty" << endl;
2780	2772	return 1;
2781	2773	}
2782		if (username && stricmp(username, "SYSTEM")==0) {
	2774	if (username && strcasecmp(username, "SYSTEM")==0) {
2783	2775	cerr << "Username (-u) cannot be SYSTEM" << endl;
2784	2776	return 1;
2785	2777	}

3063	3055	cout << "force a resync of all offline profiles for all users? [y/N]: ";
3064	3056
3065	3057	cin >> response;
3066		if (response.empty() \|\| stricmp(response.c_str(), "n") == 0 \|\| stricmp(response.c_str(), "no") == 0)
	3058	if (response.empty() \|\| strcasecmp(response.c_str(), "n") == 0 \|\| strcasecmp(response.c_str(), "no") == 0)
3067	3059	return 0;
3068		if (stricmp(response.c_str(), "y") != 0 && stricmp(response.c_str(), "yes") != 0) {
	3060	if (strcasecmp(response.c_str(), "y") != 0 && strcasecmp(response.c_str(), "yes") != 0) {
3069	3061	cout << "Invalid response." << endl;
3070	3062	return 1;
3071	3063	}

3221	3213	break;
3222	3214
3223	3215	case MODE_DETAILS:
3224		if (detailstype == NULL \|\| stricmp(detailstype, "user") == 0)
	3216	if (detailstype == NULL \|\| strcasecmp(detailstype, "user") == 0)
3225	3217	ulClass = ACTIVE_USER;
3226		else if (stricmp(detailstype, "group") == 0)
	3218	else if (strcasecmp(detailstype, "group") == 0)
3227	3219	ulClass = DISTLIST_GROUP;
3228		else if (stricmp(detailstype, "company") == 0)
	3220	else if (strcasecmp(detailstype, "company") == 0)
3229	3221	ulClass = CONTAINER_COMPANY;
3230		else if (stricmp(detailstype, "archive") != 0) {
	3222	else if (strcasecmp(detailstype, "archive") != 0) {
3231	3223	hr = MAPI_E_INVALID_TYPE;
3232	3224	cerr << "Unknown userobject type \"" << detailstype << "\"" << endl;
3233	3225	goto exit;
3234	3226	}
3235	3227
3236		if (detailstype && stricmp(detailstype, "archive") == 0)
	3228	if (detailstype && strcasecmp(detailstype, "archive") == 0)
3237	3229	hr = print_archive_details(lpSession, lpECMsgStore, username);
3238	3230	else
3239	3231	hr = print_details(lpSession, lpECMsgStore, ulClass, username);

4295	4287	break;
4296	4288	case MODE_LIST_SENDAS:
4297	4289
4298		if (detailstype == NULL \|\| stricmp(detailstype, "user") == 0) {
	4290	if (detailstype == NULL \|\| strcasecmp(detailstype, "user") == 0) {
4299	4291	hr = lpServiceAdmin->ResolveUserName((LPTSTR)username, 0, &cbUserId, &lpUserId);
4300	4292	detailstype = "user";
4301		} else if (stricmp(detailstype, "group") == 0) {
	4293	} else if (strcasecmp(detailstype, "group") == 0) {
4302	4294	hr = lpServiceAdmin->ResolveGroupName((LPTSTR)username, 0, &cbUserId, &lpUserId);
4303	4295	} else {
4304	4296	hr = MAPI_E_INVALID_TYPE;

+4

-26

ECtools/archiver/ArchiveControlImpl.cpp less more

53	53	* if the settings aren't safe.
54	54	* @param[out] lpptrArchiver
55	55	* Pointer to a ArchivePtr that will be assigned the address of the returned object.
56		*
57		* @return HRESULT
58	56	*/
59	57	HRESULT ArchiveControlImpl::Create(ArchiverSessionPtr ptrSession, ECConfig lpConfig, ECLogger lpLogger, bool bForceCleanup, ArchiveControlPtr *lpptrArchiveControl)
60	58	{

78	76	}
79	77
80	78	/**
81		* Constructor
82		*
83	79	* @param[in] lpSession
84	80	* Pointer to the Session.
85	81	* @param[in] lpConfig

88	84	* Pointer to an ECLogger object that's used for logging.
89	85	* @param[in] bForceCleanup Force a cleanup operation to continue, even
90	86	* if the settings aren't safe.
91		*
92		* @return HRESULT
93	87	*/
94	88	ArchiveControlImpl::ArchiveControlImpl(ArchiverSessionPtr ptrSession, ECConfig lpConfig, ECLogger lpLogger, bool bForceCleanup)
95	89	: m_ptrSession(ptrSession)

110	104	, m_bForceCleanup(bForceCleanup)
111	105	{ }
112	106
113		/**
114		* Destructor
115		*/
116	107	ArchiveControlImpl::~ArchiveControlImpl()
117	108	{
118	109	m_lpLogger->Release();

143	134	return MAPI_E_INVALID_PARAMETER;
144	135	}
145	136
146		if (stricmp(lpszCleanupAction, "delete") == 0)
	137	if (strcasecmp(lpszCleanupAction, "delete") == 0)
147	138	m_cleanupAction = caDelete;
148		else if (stricmp(lpszCleanupAction, "store") == 0)
	139	else if (strcasecmp(lpszCleanupAction, "store") == 0)
149	140	m_cleanupAction = caStore;
150		else if (stricmp(lpszCleanupAction, "none") == 0)
	141	else if (strcasecmp(lpszCleanupAction, "none") == 0)
151	142	m_cleanupAction = caNone;
152	143	else {
153	144	m_lpLogger->Log(EC_LOGLEVEL_FATAL, "Unknown cleanup_action specified in config: '%s'", lpszCleanupAction);

166	157	* @param[in] bLocalOnly
167	158	* If set to true only messsages for users that have their store on the local server
168	159	* will be archived.
169		*
170		* @return HRESULT
171	160	*/
172	161	eResult ArchiveControlImpl::ArchiveAll(bool bLocalOnly, bool bAutoAttach, unsigned int ulFlags)
173	162	{

209	198	*
210	199	* @param[in] strUser
211	200	* The username for which to archive the messages.
212		*
213		* @return HRESULT
214	201	*/
215	202	eResult ArchiveControlImpl::Archive(const tstring &strUser, bool bAutoAttach, unsigned int ulFlags)
216	203	{

266	253	* @param[in] bLocalOnly
267	254	* If set to true only messsages for users that have their store on the local server
268	255	* will be archived.
269		*
270		* @return HRESULT
271	256	*/
272	257	eResult ArchiveControlImpl::CleanupAll(bool bLocalOnly)
273	258	{

289	274	*
290	275	* @param[in] strUser
291	276	* The username for which to archive the messages.
292		*
293		* @return HRESULT
294	277	*/
295	278	eResult ArchiveControlImpl::Cleanup(const tstring &strUser)
296	279	{

304	287
305	288	return MAPIErrorToArchiveError(hr);
306	289	}
307
308	290
309	291	/**
310	292	* Process all users.

340	322	m_lpLogger->Log(EC_LOGLEVEL_ERROR, "Failed to process user '" TSTRING_PRINTF "'. (hr=0x%08x)", iUser->c_str(), hrTmp);
341	323	bHaveErrors = true;
342	324	} else if (hrTmp == MAPI_W_PARTIAL_COMPLETION) {
343		m_lpLogger->Log(EC_LOGLEVEL_ERROR, "Errors occured while processing user '" TSTRING_PRINTF "'.", iUser->c_str());
	325	m_lpLogger->Log(EC_LOGLEVEL_ERROR, "Errors occurred while processing user '" TSTRING_PRINTF "'.", iUser->c_str());
344	326	bHaveErrors = true;
345	327	}
346	328	}

559	541	m_lpLogger->Log(EC_LOGLEVEL_INFO, "Done archiving messages");
560	542	}
561	543
562
563	544	if (ptrDeleteOp) {
564	545	// First delete all messages that are elegible for deletion, so we don't unneccesary stub them first
565	546	m_lpLogger->Log(EC_LOGLEVEL_INFO, "Deleting old messages");

575	556	m_lpLogger->Log(EC_LOGLEVEL_INFO, "Done deleting messages");
576	557	}
577	558
578
579	559	if (ptrStubOp) {
580	560	// Now stub the remaing messages (if they're old enough)
581	561	m_lpLogger->Log(EC_LOGLEVEL_INFO, "Stubbing messages");

711	691	* @param[in] bProcessUnread
712	692	* If set to true, unread messages will also be processed. Otherwise unread message
713	693	* will be left untouched.
714		*
715		* @return HRESULT
716	694	*/
717	695	HRESULT ArchiveControlImpl::ProcessFolder(MAPIFolderPtr &ptrFolder, ArchiveOperationPtr ptrArchiveOperation)
718	696	{

+0

-15

ECtools/archiver/ArchiveManageImpl.cpp less more

52	52	* Pointer to an ECLogger object to which message will be logged.
53	53	* @param[out] lpptrArchiveManager
54	54	* Pointer to an ArchiveManagePtr that will be assigned the address of the returned object.
55		*
56		* @return HRESULT
57	55	*/
58	56	HRESULT ArchiveManageImpl::Create(ArchiverSessionPtr ptrSession, ECConfig lpConfig, const TCHAR lpszUser, ECLogger lpLogger, ArchiveManagePtr lpptrArchiveManage)
59	57	{

91	89	}
92	90
93	91	/**
94		* Constructor
95		*
96	92	* @param[in] ptrSession
97	93	* Pointer to a Session object.
98	94	* @param[in] lpConfig

120	116	}
121	117	}
122	118
123		/**
124		* Destructor
125		*/
126	119	ArchiveManageImpl::~ArchiveManageImpl()
127	120	{
128	121	m_lpLogger->Release();

156	149	* the user is used as the root foldername.
157	150	* @param[in] ulFlags
158	151	* @ref flags specifying the options used for attaching the archive.
159		* @return HRESULT
160	152	*
161	153	* @section flags Flags
162	154	* @li \b ATT_USE_IPM_SUBTREE Use the IPM subtree of the archive store as the root of the archive.

379	371	* in the archive store, the exact folder need to be specified.
380	372	* If the archive root was placed in the IPM subtree of the archive store, this parameter
381	373	* must be set to NULL.
382		*
383		* @return HRESULT
384	374	*/
385	375	eResult ArchiveManageImpl::DetachFrom(const char lpszArchiveServer, const TCHAR lpszArchive, const TCHAR *lpszFolder)
386	376	{

506	496	*
507	497	* @param[in] ulArchive
508	498	* The index of the archive in the list of archives.
509		*
510		* @return HRESULT
511	499	*/
512	500	eResult ArchiveManageImpl::DetachFrom(unsigned int ulArchive)
513	501	{

559	547	*
560	548	* @param[in] ostr
561	549	* The std::ostream to which the list will be outputted.
562		*
563		* @return HRESULT
564	550	*/
565	551	eResult ArchiveManageImpl::ListArchives(std::ostream &ostr)
566	552	{

681	667	}
682	668	}
683	669
684
685	670	hrTmp = ptrArchiveStore->OpenEntry(iArchive->sItemEntryId.size(), iArchive->sItemEntryId, &ptrArchiveFolder.iid, fMapiDeferredErrors, &ulType, &ptrArchiveFolder);
686	671	if (hrTmp != hrSuccess) {
687	672	m_lpLogger->Log(EC_LOGLEVEL_ERROR, "Failed to open folder (hr=%s)", stringify(hrTmp, true).c_str());

+1

-3

ECtools/archiver/ArchiveStateCollector.cpp less more

101	101
102	102	for (unsigned j = 0; bComplete && j < IDX_MAX; ++j) {
103	103	if (PROP_TYPE(ptrRows[i].lpProps[j].ulPropTag) == PT_ERROR) {
104		m_lpLogger->Log(EC_LOGLEVEL_WARNING, "Got uncomplete row, row %u, column %u contains error 0x%08x", i, j, ptrRows[i].lpProps[j].Value.err);
	104	m_lpLogger->Log(EC_LOGLEVEL_WARNING, "Got incomplete row, row %u, column %u contains error 0x%08x", i, j, ptrRows[i].lpProps[j].Value.err);
105	105	bComplete = false;
106	106	}
107	107	}

139	139
140	140	}
141	141
142
143	142	/**
144	143	* Create an ArchiveStateCollector instance.
145	144	* @param[in] ArchiverSessionPtr The archive session

161	160	}
162	161
163	162	/**
164		* Constructor
165	163	* @param[in] ArchiverSessionPtr The archive session
166	164	* @param[in] lpLogger The logger.
167	165	*/

+0

-4

ECtools/archiver/ArchiveStateUpdater.cpp less more

38	38	const SObjectEntry &m_objEntry;
39	39	};
40	40
41
42	41	/**
43	42	* Compare two SObjectEntry instances.
44	43	* This method uses CompareEntryIDs to do the comparison.

62	61	const SObjectEntry &m_objEntry;
63	62	};
64	63
65
66	64	/**
67	65	* Compare a store entryid with the store entryid from an SObjectEntry instance.
68	66	* This method uses CompareEntryIDs to do the comparison.

93	91
94	92	} // namespace Predicates
95	93
96
97	94	/**
98	95	* Create an ArchiveStateUpdater instance.
99	96	* @param[in] ptrSession The archiver session.

118	115	}
119	116
120	117	/**
121		* Constructor
122	118	* @param[in] ptrSession The archiver session.
123	119	* @param[in] lpLogger The logger.
124	120	* @param[in] mapArchiveInfo The map containing the users that have and/or

+0

-70

ECtools/archiver/ArchiverSession.cpp less more

38	38	* @param[out] lppSession
39	39	* Pointer to a Session pointer that will be assigned the address of the returned
40	40	* ArchiverSession object.
41		* @return HRESULT
42	41	*/
43	42	HRESULT ArchiverSession::Create(ECConfig lpConfig, ECLogger lpLogger, ArchiverSessionPtr *lpptrSession)
44	43	{

70	69	* @param[out] lppSession
71	70	* Pointer to a Session pointer that will be assigned the address of the returned
72	71	* Session object.
73		*
74		* @return HRESULT
75	72	*/
76	73	HRESULT ArchiverSession::Create(const MAPISessionPtr &ptrSession, ECLogger lpLogger, ArchiverSessionPtr lpptrSession)
77	74	{

91	88	* @param[out] lppSession
92	89	* Pointer to a ArchiverSession pointer that will be assigned the address of the returned
93	90	* ArchiverSession object.
94		*
95		* @return HRESULT
96	91	*/
97	92	HRESULT ArchiverSession::Create(const MAPISessionPtr &ptrSession, ECConfig lpConfig, ECLogger lpLogger, ArchiverSessionPtr *lpptrSession)
98	93	{

126	121	return hr;
127	122	}
128	123
129		/**
130		* Destructor
131		*/
132	124	ArchiverSession::~ArchiverSession()
133	125	{
134	126	m_lpLogger->Release();
135	127	}
136	128
137		/**
138		* Constructor
139		*/
140	129	ArchiverSession::ArchiverSession(ECLogger *lpLogger): m_lpLogger(lpLogger)
141	130	{
142	131	m_lpLogger->AddRef();

148	137	* @param[in] lpConfig
149	138	* The configuration used for creating the ArchiverSession. The values extracted from the
150	139	* configuration are server_path, sslkey_file and sslkey_path.
151		*
152		* @return HRESULT
153	140	*/
154	141	HRESULT ArchiverSession::Init(ECConfig *lpConfig)
155	142	{

168	155	* @param[in]
169	156	* lpszSslPass
170	157	* The password for the certificate.
171
172		* @return HRESULT
173	158	*/
174	159	HRESULT ArchiverSession::Init(const char lpszServerPath, const char lpszSslPath, const char *lpszSslPass)
175	160	{

214	199	* @param[in] ptrSession
215	200	* MAPISessionPtr that points to the MAPISession to contruct this
216	201	* ArchiverSession object for.
217		*
218		* @return HRESULT
219	202	*/
220	203	HRESULT ArchiverSession::Init(const MAPISessionPtr &ptrSession, const char lpszSslPath, const char lpszSslPass)
221	204	{

244	227	* @param[out] lppMsgStore
245	228	* Pointer to a IMsgStore pointer that will be assigned the
246	229	* address of the returned message store.
247		*
248		* @return HRESULT
249	230	*/
250	231	HRESULT ArchiverSession::OpenStoreByName(const tstring &strUser, LPMDB *lppMsgStore)
251	232	{

287	268	* @param[out] lppMsgStore
288	269	* Pointer to a IMsgStore pointer that will be assigned the
289	270	* address of the returned message store.
290		*
291		* @return HRESULT
292	271	*/
293	272	HRESULT ArchiverSession::OpenStore(const entryid_t &sEntryId, ULONG ulFlags, LPMDB *lppMsgStore)
294	273	{

331	310	* @param[out] lppMsgStore
332	311	* Pointer to a IMsgStore pointer that will be assigned the
333	312	* address of the returned message store.
334		*
335		* @return HRESULT
336	313	*/
337	314	HRESULT ArchiverSession::OpenStore(const entryid_t &sEntryId, LPMDB *lppMsgStore)
338	315	{

347	324	* @param[out] lppMsgStore
348	325	* Pointer to a IMsgStore pointer that will be assigned the
349	326	* address of the returned message store.
350		*
351		* @return HRESULT
352	327	*/
353	328	HRESULT ArchiverSession::OpenReadOnlyStore(const entryid_t &sEntryId, LPMDB *lppMsgStore)
354	329	{

372	347	* Pointer to a boolean that will be set to true if the user is ACL capable.
373	348	* This argument can be set to NULL if the active/non-active
374	349	* information is not required.
375		*
376		* @return HRESULT
377	350	*/
378	351	HRESULT ArchiverSession::GetUserInfo(const tstring &strUser, abentryid_t lpsEntryId, tstring lpstrFullname, bool *lpbAclCapable)
379	352	{

488	461	* @param[out] lppAbContainer
489	462	* Pointer to a IABContainer pointer that will be assigned the
490	463	* address of the returned addressbook container.
491		*
492		* @return HRESULT
493	464	*/
494	465	HRESULT ArchiverSession::GetGAL(LPABCONT *lppAbContainer)
495	466	{

556	527	* @param[out] lpbResult
557	528	* Pointer to a boolean that will be set to true if the two stores
558	529	* reference the same store.
559		*
560		* @return HRESULT
561	530	*/
562	531	HRESULT ArchiverSession::CompareStoreIds(LPMDB lpUserStore, LPMDB lpArchiveStore, bool *lpbResult)
563	532	{

593	562	* @param[out] lpbResult
594	563	* Pointer to a boolean that will be set to true if the two ids
595	564	* reference the same store.
596		*
597		* @return HRESULT
598	565	*/
599	566	HRESULT ArchiverSession::CompareStoreIds(const entryid_t &sEntryId1, const entryid_t &sEntryId2, bool *lpbResult)
600	567	{

608	575	return hr;
609	576
610	577	*lpbResult = (ulResult == TRUE);
611		return hrSuccess;
612		}
613
614		/**
615		* Check if the server specified by strServername is the server we're currently connected with.
616		*
617		* @param[in] strServername
618		* The name of the server to check.
619		* @param[out] lpbResult
620		* Pointer to a boolean that will be set to true if the server is the
621		* same server we're currently connected with.
622		*
623		* @return HRESULT
624		*/
625		HRESULT ArchiverSession::ServerIsLocal(const std::string &strServername, bool *lpbResult)
626		{
627		HRESULT hr;
628		char *lpszServername = NULL;
629		ECSVRNAMELIST sSvrNameList = {0};
630		ECServiceAdminPtr ptrServiceAdmin;
631		ECServerListPtr ptrServerList;
632
633		hr = m_ptrAdminStore->QueryInterface(ptrServiceAdmin.iid, &ptrServiceAdmin);
634		if (hr != hrSuccess)
635		return hr;
636
637		lpszServername = (char*)strServername.c_str();
638
639		sSvrNameList.cServers = 1;
640		sSvrNameList.lpszaServer = (LPTSTR*)&lpszServername;
641
642		hr = ptrServiceAdmin->GetServerDetails(&sSvrNameList, EC_SERVERDETAIL_NO_NAME, &ptrServerList); // No MAPI_UNICODE
643		if (hr != hrSuccess)
644		return hr;
645
646		*lpbResult = (ptrServerList->lpsaServer[0].ulFlags & EC_SDFLAG_IS_PEER) == EC_SDFLAG_IS_PEER;
647	578	return hrSuccess;
648	579	}
649	580

668	599	lpptrSession->reset(lpSession);
669	600	return hr;
670	601	}
671
672	602
673	603	HRESULT ArchiverSession::OpenMAPIProp(ULONG cbEntryID, LPENTRYID lpEntryID, LPMAPIPROP *lppProp)
674	604	{

+0

-1

ECtools/archiver/ArchiverSession.h less more

47	47	HRESULT GetGAL(LPABCONT *lppAbContainer);
48	48	HRESULT CompareStoreIds(LPMDB lpUserStore, LPMDB lpArchiveStore, bool *lpbResult);
49	49	HRESULT CompareStoreIds(const entryid_t &sEntryId1, const entryid_t &sEntryId2, bool *lpbResult);
50		HRESULT ServerIsLocal(const std::string &strServername, bool *lpbResult);
51	50
52	51	HRESULT CreateRemote(const char lpszServerPath, ECLogger lpLogger, ArchiverSessionPtr *lpptrSession);
53	52

+0

-2

ECtools/archiver/ECArchiverLogger.cpp less more

111	111	return strEscaped;
112	112	}
113	113
114
115	114	ScopedUserLogging::ScopedUserLogging(ECArchiverLogger *lpLogger, const tstring &strUser)
116	115	: m_lpLogger(lpLogger)
117	116	, m_strPrevUser(lpLogger->SetUser(strUser))

122	121	m_lpLogger->SetUser(m_strPrevUser);
123	122	}
124	123
125
126	124	ScopedFolderLogging::ScopedFolderLogging(ECArchiverLogger *lpLogger, const tstring &strFolder)
127	125	: m_lpLogger(lpLogger)
128	126	, m_strPrevFolder(lpLogger->SetFolder(strFolder))

+0

-28

ECtools/archiver/helpers/ArchiveHelper.cpp less more

30	30	#define CbNewROWLIST(_centries) \
31	31	(offsetof(ROWLIST,aEntries) + (_centries)*sizeof(ROWENTRY))
32	32	#endif
33
34	33
35	34	/**
36	35	* Create an ArchiveHelper object based on a message store and a folder name.

45	44	* implies that the archive is remote (other server/cluster).
46	45	* @param[out] lpptrArchiveHelper
47	46	* Pointer to a ArchiveHelperPtr that assigned the address of the returned ArchiveHelper.
48		*
49		* @return HRESULT
50	47	*/
51	48	HRESULT ArchiveHelper::Create(LPMDB lpArchiveStore, const tstring &strFolder, const char lpszServerPath, ArchiveHelperPtr lpptrArchiveHelper)
52	49	{

79	76	* implies that the archive is remote (other server/cluster).
80	77	* @param[out] lpptrArchiveHelper
81	78	* Pointer to a ArchiveHelperPtr that assigned the address of the returned ArchiveHelper.
82		*
83		* @return HRESULT
84	79	*/
85	80	HRESULT ArchiveHelper::Create(LPMDB lpArchiveStore, LPMAPIFOLDER lpArchiveFolder, const char lpszServerPath, ArchiveHelperPtr lpptrArchiveHelper)
86	81	{

141	136	return hrSuccess;
142	137	}
143	138
144		/**
145		* Constructor
146		*/
147	139	ArchiveHelper::ArchiveHelper(LPMDB lpArchiveStore, const tstring &strFolder, const std::string &strServerPath)
148	140	: m_ptrArchiveStore(lpArchiveStore, true)
149	141	, m_strFolder(strFolder)
150	142	, m_strServerPath(strServerPath)
151	143	{ }
152	144
153		/**
154		* Constructor
155		*/
156	145	ArchiveHelper::ArchiveHelper(LPMDB lpArchiveStore, LPMAPIFOLDER lpArchiveFolder, const std::string &strServerPath)
157	146	: m_ptrArchiveStore(lpArchiveStore, true)
158	147	, m_ptrArchiveFolder(lpArchiveFolder, true)

161	150
162	151	/**
163	152	* Initialize an ArchiveHelper object.
164		* @return HRESULT
165	153	*/
166	154	HRESULT ArchiveHelper::Init()
167	155	{

183	171	* @param[out] lpsUserEntryId
184	172	* Pointer to a entryid_t that will be populated with the entryid of the user
185	173	* who's store is attached to this archive.
186		*
187		* @return HRESULT
188	174	*/
189	175	HRESULT ArchiveHelper::GetAttachedUser(abentryid_t *lpsUserEntryId)
190	176	{

209	195	* @param[in] sUserEntryId
210	196	* The entryid of the user who's store is attached to this
211	197	* archive.
212		*
213		* @return HRESULT
214	198	*/
215	199	HRESULT ArchiveHelper::SetAttachedUser(const abentryid_t &sUserEntryId)
216	200	{

236	220	* @param[out] lpSObjectEntry
237	221	* Pointer to a SObjectEntry structure that will be populated with the unique
238	222	* reference to this archive.
239		*
240		* @return HRESULT
241	223	*/
242	224	HRESULT ArchiveHelper::GetArchiveEntry(bool bCreate, SObjectEntry *lpsObjectEntry)
243	225	{

341	323	*
342	324	* @param[in] aType
343	325	* The ArchiveType type of this archive.
344		*
345		* @return HRESULT
346	326	*/
347	327	HRESULT ArchiveHelper::SetArchiveType(ArchiveType archType, AttachType attachType)
348	328	{

374	354	* The entryid of the user for who permissions are being set.
375	355	* @param[in] bWriteable.
376	356	* If set to true, the archive will be writable by the user.
377		*
378		* @return HRESULT
379	357	*/
380	358	HRESULT ArchiveHelper::SetPermissions(const abentryid_t &sUserEntryId, bool bWritable)
381	359	{

467	445	* The Session pointer that's used to open folders with.
468	446	* @param[out] lppDestinationFolder
469	447	* Pointer to a MAPIFolder pointer that's assigned the address of the returned folder.
470		*
471		* @return HRESULT
472	448	*/
473	449	HRESULT ArchiveHelper::GetArchiveFolderFor(MAPIFolderPtr &ptrSourceFolder, ArchiverSessionPtr ptrSession, LPMAPIFOLDER *lppDestinationFolder)
474	450	{

663	639	* @param[out] lppArchiveFolder
664	640	* Pointer to the MAPIFolder pointer that will be assigned the address of the
665	641	* returned folder.
666		*
667		* @return HRESULT
668	642	*/
669	643	HRESULT ArchiveHelper::GetArchiveFolder(bool bCreate, LPMAPIFOLDER *lppArchiveFolder)
670	644	{

695	669	* Pointer to the MAPIFolder to check.
696	670	* @param[out] lpbResult
697	671	* True if the folder is the same as would be returned by GetArchiveFolder.
698		*
699		* @return HRESULT
700	672	*/
701	673	HRESULT ArchiveHelper::IsArchiveFolder(LPMAPIFOLDER lpFolder, bool *lpbResult)
702	674	{

+0

-115

ECtools/archiver/helpers/MAPIPropHelper.cpp less more

39	39	* @param[out] lppptrMAPIPropHelper
40	40	* Pointer to a MAPIPropHelperPtr that will be assigned the returned
41	41	* MAPIPropHelper object.
42		*
43		* @return HRESULT
44	42	*/
45	43	HRESULT MAPIPropHelper::Create(MAPIPropPtr ptrMapiProp, MAPIPropHelperPtr *lpptrMAPIPropHelper)
46	44	{

61	59	return hrSuccess;
62	60	}
63	61
64		/**
65		* Constructor
66		*/
67	62	MAPIPropHelper::MAPIPropHelper(MAPIPropPtr ptrMapiProp)
68	63	: m_ptrMapiProp(ptrMapiProp)
69	64	{ }

132	127	return ptrMessageProps[IDX_HIERARCHYID].Value.err;
133	128	hr = hrSuccess;
134	129
135
136	130	// Determine stubbed / dirty state.
137	131	if (PROP_TYPE(ptrMessageProps[IDX_STUBBED].ulPropTag) != PT_ERROR && ptrMessageProps[IDX_STUBBED].Value.b == TRUE)
138	132	ulState \|= MessageState::msStubbed;

144	138	if ((ulState & MessageState::msStubbed) == 0)
145	139	ulState \|= MessageState::msDirty;
146	140	}
147
148	141
149	142	// Determine copy / move state.
150	143	if (PROP_TYPE(ptrMessageProps[IDX_ORIGINAL_SOURCEKEY].ulPropTag) == PT_ERROR) {

255	248	*
256	249	* @param[in] bIgnoreSourceKey
257	250	* Don't try to detect a copy/move and return an empty list in that case.
258		*
259		* @return HRESULT
260	251	*/
261	252	HRESULT MAPIPropHelper::GetArchiveList(ObjectEntryList *lplstArchives, bool bIgnoreSourceKey)
262	253	{

342	333	* The list of archive references that should be stored in the object.
343	334	* @param[in] bExplicitCommit
344	335	* If set to true, the changes are committed before this function returns.
345		*
346		* @return HRESULT
347	336	*/
348	337	HRESULT MAPIPropHelper::SetArchiveList(const ObjectEntryList &lstArchives, bool bExplicitCommit)
349	338	{

417	406	* The id of the referenced object.
418	407	* @param[in] bExplicitCommit
419	408	* If set to true, the changes are committed before this function returns.
420		*
421		* @return HRESULT
422	409	*/
423	410	HRESULT MAPIPropHelper::SetReference(const SObjectEntry &sEntry, bool bExplicitCommit)
424	411	{

443	430	return hr;
444	431	}
445	432
446
447	433	HRESULT MAPIPropHelper::ClearReference(bool bExplicitCommit)
448	434	{
449	435	HRESULT hr;

458	444
459	445	return hr;
460	446	}
461
462	447
463	448	HRESULT MAPIPropHelper::GetReference(SObjectEntry *lpEntry)
464	449	{

484	469	lpEntry->sItemEntryId.assign(ptrMessageProps[IDX_REF_ITEM_ENTRYID].Value.bin);
485	470	return hr;
486	471	}
487
488	472
489	473	HRESULT MAPIPropHelper::ReferencePrevious(const SObjectEntry &sEntry)
490	474	{

536	520	* return true if the message class is not updated properly. However, this is done in the caller
537	521	* of this function, which has no notion of the set of named properies that are needed to remove this
538	522	* property.
539		*
540		* @return HRESULT.
541	523	*/
542	524	HRESULT MAPIPropHelper::RemoveStub()
543	525	{

551	533	return m_ptrMapiProp->DeleteProps((LPSPropTagArray)&sptaDirtyProps, NULL);
552	534	}
553	535
554
555	536	/**
556	537	* Detach an object from its archived version.
557	538	* This does not cause the reference in the archived version to be removed.
558		*
559		* @return HRESULT
560	539	*/
561	540	HRESULT MAPIPropHelper::DetachFromArchives()
562	541	{

572	551	* @param[in] lppFolder
573	552	* Pointer to a IMAPIFolder pointer that will be assigned the address
574	553	* of the returned folder.
575		*
576		* @return HRESULT
577	554	*/
578	555	HRESULT MAPIPropHelper::GetParentFolder(ArchiverSessionPtr ptrSession, LPMAPIFOLDER *lppFolder)
579	556	{

602	579
603	580	return ptrFolder->QueryInterface(IID_IMAPIFolder,
604	581	reinterpret_cast<LPVOID *>(lppFolder));
605		}
606
607		/**
608		* Get the list of properties needed to be able to determine if the message from which
609		* the properties are obtained is stubbed and if so to get a list of archived versions.
610		*
611		* @param[in] ptrMapiProp An IMAPIProp that lives on the same server as the the
612		* message from which the properties will be obtained. This
613		* is needed to properly resolve the named properties.
614		* @param[in] lpExtra Optional pointer to a PropTagArray containing additional
615		* properties that will also be placed in the resulting
616		* PropTagArray. This is for convenience when building a list
617		* of properties where not only the archive properties are
618		* required.
619		* @param[out] lppProps The resulting PropTagArray.
620		*/
621		HRESULT MAPIPropHelper::GetArchiverProps(MAPIPropPtr ptrMapiProp, LPSPropTagArray lpExtra, LPSPropTagArray *lppProps)
622		{
623		HRESULT hr = hrSuccess;
624
625		SizedSPropTagArray(2, sptaFixedProps) = {2, {PR_MESSAGE_CLASS, PR_SOURCE_KEY}};
626
627		PROPMAP_START
628		PROPMAP_NAMED_ID(STUBBED, PT_BOOLEAN, PSETID_Archive, dispidStubbed)
629		PROPMAP_NAMED_ID(ARCHIVE_STORE_ENTRYIDS, PT_MV_BINARY, PSETID_Archive, dispidStoreEntryIds)
630		PROPMAP_NAMED_ID(ARCHIVE_ITEM_ENTRYIDS, PT_MV_BINARY, PSETID_Archive, dispidItemEntryIds)
631		PROPMAP_NAMED_ID(ORIGINAL_SOURCEKEY, PT_BINARY, PSETID_Archive, dispidOrigSourceKey)
632		PROPMAP_INIT(ptrMapiProp)
633
634		hr = MAPIAllocateBuffer(CbNewSPropTagArray(sptaFixedProps.cValues + 4 + (lpExtra ? lpExtra->cValues : 0)), (LPVOID*)lppProps);
635		if (hr != hrSuccess)
636		goto exit;
637
638		for (ULONG i = 0; i < sptaFixedProps.cValues; ++i)
639		(*lppProps)->aulPropTag[i] = sptaFixedProps.aulPropTag[i];
640
641		(*lppProps)->cValues = sptaFixedProps.cValues;
642		(lppProps)->aulPropTag[(lppProps)->cValues++] = PROP_STUBBED;
643		(lppProps)->aulPropTag[(lppProps)->cValues++] = PROP_ARCHIVE_STORE_ENTRYIDS;
644		(lppProps)->aulPropTag[(lppProps)->cValues++] = PROP_ARCHIVE_ITEM_ENTRYIDS;
645		(lppProps)->aulPropTag[(lppProps)->cValues++] = PROP_ORIGINAL_SOURCEKEY;
646
647		for (ULONG i = 0; lpExtra && i < lpExtra->cValues; ++i)
648		(lppProps)->aulPropTag[(lppProps)->cValues++] = lpExtra->aulPropTag[i];
649
650		exit:
651		return hr;
652		}
653
654		/**
655		* Check if a message is stubbed.
656		* This is accomplished by checking if the named property {72e98ebc-57d2-4ab5-b0aad50a7b531cb9}/stubbed is set to true or false.
657		* If that property is absent the PR_MESSAGE_CLASS is compared to "IPM.Zarafa.Stub". If that matches the message is
658		* considered stubbed as well.
659		*
660		* @param[in] ptrMapiProp An IMAPIProp that lives on the same server as the the
661		* message from which the properties were obtained. This
662		* is needed to properly resolve the named properties.
663		* @param[in] lpProps The list of properties to use to determine if the message
664		* from which they were obtained is stubbed.
665		* @param[in] cbProps The amount of properties in lpProps.
666		* @param[out] lpbResult Pointer to a boolean that will be set to true if the
667		* message is stubbed, and false otherwise.
668		*
669		* @return HRESULT
670		*/
671		HRESULT MAPIPropHelper::IsStubbed(MAPIPropPtr ptrMapiProp, LPSPropValue lpProps, ULONG cbProps, bool *lpbResult)
672		{
673		HRESULT hr = hrSuccess;
674		LPSPropValue lpPropStubbed = NULL;
675		LPSPropValue lpPropMessageClass = NULL;
676
677		PROPMAP_START
678		PROPMAP_NAMED_ID(STUBBED, PT_BOOLEAN, PSETID_Archive, dispidStubbed)
679		PROPMAP_INIT(ptrMapiProp)
680
681		lpPropStubbed = PpropFindProp(lpProps, cbProps, PROP_STUBBED);
682
683		if (!lpPropStubbed) {
684		// PROP_STUBBED doesn't exist, check the message class to be sure
685		lpPropMessageClass = PpropFindProp(lpProps, cbProps, PR_MESSAGE_CLASS);
686		if (lpPropMessageClass)
687		*lpbResult = (_tcsicmp(lpPropMessageClass->Value.LPSZ, _T("IPM.Zarafa.Stub")) == 0);
688		else
689		*lpbResult = false;
690		} else
691		*lpbResult = (lpPropStubbed->Value.b != 0);
692
693		exit:
694		return hr;
695	582	}
696	583
697	584	/**

708	595	* for the message from which they were obtained.
709	596	* @param[in] cbProps The amount of properties in lpProps.
710	597	* @param[out] lplstArchives Pointer to a list that will be populated with the archive references.
711		*
712		* @return HRESULT
713	598	*/
714	599	HRESULT MAPIPropHelper::GetArchiveList(MAPIPropPtr ptrMapiProp, LPSPropValue lpProps, ULONG cbProps, ObjectEntryList *lplstArchives)
715	600	{

+0

-3

ECtools/archiver/helpers/MAPIPropHelper.h less more

56	56	HRESULT SetClean();
57	57	HRESULT DetachFromArchives();
58	58	virtual HRESULT GetParentFolder(ArchiverSessionPtr ptrSession, LPMAPIFOLDER *lppFolder);
59
60		static HRESULT GetArchiverProps(MAPIPropPtr ptrMapiProp, LPSPropTagArray lpExtra, LPSPropTagArray *lppProps);
61		static HRESULT IsStubbed(MAPIPropPtr ptrMapiProp, LPSPropValue lpProps, ULONG cbProps, bool *lpbResult);
62	59	static HRESULT GetArchiveList(MAPIPropPtr ptrMapiProp, LPSPropValue lpProps, ULONG cbProps, ObjectEntryList *lplstArchives);
63	60
64	61	protected:

+0

-16

ECtools/archiver/helpers/StoreHelper.cpp less more

56	56	* @param[out] lpptrStoreHelper
57	57	* Pointer to a StoreHelperPtr that will be assigned the address
58	58	* of the new StoreHelper object.
59		*
60		* @return HRESULT
61	59	*/
62	60	HRESULT StoreHelper::Create(MsgStorePtr &ptrMsgStore, StoreHelperPtr *lpptrStoreHelper)
63	61	{

77	75	*lpptrStoreHelper = std::move(ptrStoreHelper);
78	76	return hrSuccess;
79	77	}
80
81	78
82	79	/**
83	80	* Constructor.

122	119	* @param[out] lppFolder
123	120	* Pointer to a IMapiFolder pointer that will be assigned the address
124	121	* of the returned folderd.
125		*
126		* @return HRESULT
127	122	*/
128	123	HRESULT StoreHelper::GetFolder(const tstring &strFolder, bool bCreate, LPMAPIFOLDER *lppFolder)
129	124	{

145	140	/**
146	141	* Create or reinitialize the searchfolders used by the archiver. The search folders
147	142	* need to be updated whenever the set of attached archives for a store change.
148		*
149		* @return HRESULT
150	143	*/
151	144	HRESULT StoreHelper::UpdateSearchFolders()
152	145	{

206	199	* @param[out] lppFolder
207	200	* Pointer to an IMAPIFolder pointer that will be assigned the
208	201	* address of the returned folder.
209		*
210		* @return HRESULT
211	202	*/
212	203	HRESULT StoreHelper::GetIpmSubtree(LPMAPIFOLDER *lppFolder)
213	204	{

246	237	* address of the searcholder containing the messages that are eligible
247	238	* for stubbing. These are basically all non-stubbed, archived messages that
248	239	* are not flagged to be never stubbed.
249		*
250		* @return HRESULT
251	240	*/
252	241	HRESULT StoreHelper::GetSearchFolders(LPMAPIFOLDER lppSearchArchiveFolder, LPMAPIFOLDER lppSearchDeleteFolder, LPMAPIFOLDER *lppSearchStubFolder)
253	242	{

365	354	* @param[out] lppFolder
366	355	* Pointer to an IMAPIFolder pointer that will be assigned the
367	356	* address of the returned folder.
368		*
369		* @return HRESULT
370	357	*/
371	358	HRESULT StoreHelper::GetSubFolder(MAPIFolderPtr &ptrFolder, const tstring &strFolder, bool bCreate, LPMAPIFOLDER *lppFolder)
372	359	{

552	539	return hr;
553	540	ptrEntryList->lpbin[0].cb = ptrPropEntryId->Value.bin.cb;
554	541	ptrEntryList->lpbin[0].lpb = ptrPropEntryId->Value.bin.lpb;
555
556	542
557	543	sPropStubbed.ulPropTag = PROP_STUBBED; sPropStubbed.Value.b = 1;
558	544

637	623	ptrEntryList->lpbin[0].cb = ptrPropEntryId->Value.bin.cb;
638	624	ptrEntryList->lpbin[0].lpb = ptrPropEntryId->Value.bin.lpb;
639	625
640
641	626	// Create/Update the search folder that tracks all archived message that are not flagged to be never deleted or never stubbed
642	627	resDeleteFolder.append(
643	628	*lpresClassCheck +

702	687	return hr;
703	688	ptrEntryList->lpbin[0].cb = ptrPropEntryId->Value.bin.cb;
704	689	ptrEntryList->lpbin[0].lpb = ptrPropEntryId->Value.bin.lpb;
705
706	690
707	691	sPropStubbed.ulPropTag = PROP_STUBBED;
708	692	sPropStubbed.Value.b = 1;

+0

-8

ECtools/archiver/include/kopano/archiver-common.h less more

89	89	{ }
90	90
91	91	/**
92		* Copy constructor.
93		*
94	92	* @param[in] other
95	93	* The entryid to copy.
96	94	*/

320	318	{ }
321	319
322	320	/**
323		* Copy constructor.
324		*
325	321	* @param[in] other
326	322	* The entryid to copy.
327	323	*/

535	531	{
536	532	public:
537	533	/**
538		* Constructor
539		*
540	534	* This constructor takes the store entryid from an SObjectEntry.
541	535	*
542	536	* @param[in] sEntry The SObjectEntry from which the store entryid will be used

545	539	StoreCompare(const SObjectEntry &sEntry): m_sEntryId(sEntry.sStoreEntryId.getUnwrapped()) {}
546	540
547	541	/**
548		* Constructor
549		*
550	542	* This constructor takes an explicit entryid.
551	543	*
552	544	* @param[in] sEntryId The entryid the will be used

+0

-8

ECtools/archiver/main.cpp less more

25	25	#include <kopano/ECLogger.h>
26	26	#include <kopano/ecversion.h>
27	27	#include "Archiver.h"
28
29		#ifdef LINUX
30	28	#include "UnixUtil.cpp"
31		#endif
32	29
33	30	enum modes
34	31	{

244	241	const char *lpszConfig = Archiver::GetConfigPath();
245	242
246	243	static const configsetting_t lpDefaults[] = {
247		#ifdef LINUX
248	244	{ "pid_file", "/var/run/kopano/archiver.pid" },
249		#endif
250	245	{ NULL, NULL }
251	246	};
252	247

451	446	cerr << "--force-cleanup is only valid in cleanup mode." << endl;
452	447	return 1;
453	448	}
454
455	449
456	450	r = Archiver::Create(&ptrArchiver);
457	451	if (r != Success) {

483	477	filelogger->Log(EC_LOGLEVEL_FATAL, "* %s = '%s'", i->szName, i->szValue);
484	478	}
485	479
486		#ifdef LINUX
487	480	if (mode == MODE_ARCHIVE \|\| mode == MODE_CLEANUP)
488	481	if (unix_create_pidfile(argv[0], ptrArchiver->GetConfig(), ptrArchiver->GetLogger(), false) != 0)
489	482	return 1;
490		#endif
491	483
492	484	ptrArchiver->GetLogger()->Log(EC_LOGLEVEL_DEBUG, "Archiver mode: %d: (%s)", mode, modename(mode));
493	485	switch (mode) {

+0

-4

ECtools/archiver/operations/copier.cpp less more

386	386	}
387	387
388	388	/**
389		* Constructor
390		*
391	389	* @param[in] lpSession
392	390	* Pointer to the session.
393	391	* @param[in] lpLogger

396	394	* The list of attached archives for this store.
397	395	* @param[in] lpExcludeProps
398	396	* The list of properties that will not be copied during the archive operation.
399		*
400		* @return HRESULT
401	397	*/
402	398	Copier::Copier(ArchiverSessionPtr ptrSession, ECConfig lpConfig, ECArchiverLogger lpLogger, const ObjectEntryList &lstArchives, LPSPropTagArray lpExcludeProps, int ulAge, bool bProcessUnread)
403	399	: ArchiveOperationBaseEx(lpLogger, ulAge, bProcessUnread, ARCH_NEVER_ARCHIVE)

+0

-8

ECtools/archiver/operations/deleter.cpp less more

23	23	namespace za { namespace operations {
24	24
25	25	/**
26		* Constructor
27		*
28	26	* @param[in] lpLogger
29	27	* Pointer to the logger.
30		*
31		* @return HRESULT
32	28	*/
33	29	Deleter::Deleter(ECArchiverLogger *lpLogger, int ulAge, bool bProcessUnread)
34	30	: ArchiveOperationBaseEx(lpLogger, ulAge, bProcessUnread, ARCH_NEVER_DELETE)
35	31	{ }
36	32
37		/**
38		* Destructor
39		*/
40	33	Deleter::~Deleter()
41	34	{
42	35	PurgeQueuedMessages();

69	62
70	63	/**
71	64	* Delete the messages that are queued for deletion.
72		* @return HRESULT
73	65	*/
74	66	HRESULT Deleter::PurgeQueuedMessages()
75	67	{

+0

-5

ECtools/archiver/operations/operations.cpp less more

50	50	{
51	51	GetSystemTimeAsFileTime(&m_ftCurrent);
52	52	}
53
54
55	53
56	54	HRESULT ArchiveOperationBase::GetRestriction(LPMAPIPROP lpMapiProp, LPSRestriction *lppRestriction)
57	55	{

106	104	)
107	105	);
108	106
109
110	107	hr = resResult.CreateMAPIRestriction(lppRestriction);
111	108
112	109	exit:

145	142	* The number op properties pointed to by lpProps.
146	143	* @param[in] lpProps
147	144	* Pointer to an array of properties that are used by the Operation object.
148		*
149		* @return HRESULT
150	145	*/
151	146	HRESULT ArchiveOperationBaseEx::ProcessEntry(LPMAPIFOLDER lpFolder, ULONG cProps, const LPSPropValue lpProps)
152	147	{

+0

-7

ECtools/archiver/operations/operations.h less more

47	47	* The number op properties pointed to by lpProps.
48	48	* @param[in] lpProps
49	49	* Pointer to an array of properties that are used by the Operation object.
50		*
51		* @return HRESULT
52	50	*/
53	51	virtual HRESULT ProcessEntry(LPMAPIFOLDER lpFolder, ULONG cProps, const LPSPropValue lpProps) = 0;
54	52

126	124	* the source folder is switched.
127	125	*
128	126	* @param[in] lpFolder The just opened folder.
129		* @return HRESULT
130	127	*/
131	128	virtual HRESULT EnterFolder(LPMAPIFOLDER lpFolder) = 0;
132	129

134	131	* Called by ProcessEntry before switching source folders. Derived classes will need to
135	132	* implement this method. It can be used to perform operations that only need to be done when
136	133	* the source folder is switched.
137		*
138		* @return HRESULT
139	134	*/
140	135	virtual HRESULT LeaveFolder() = 0;
141	136

146	141	* The number op properties pointed to by lpProps.
147	142	* @param[in] lpProps
148	143	* Pointer to an array of properties that are used by the Operation object.
149		*
150		* @return HRESULT
151	144	*/
152	145	virtual HRESULT DoProcessEntry(ULONG cProps, const LPSPropValue &lpProps) = 0;
153	146

+0

-4

ECtools/archiver/operations/stubber.cpp less more

26	26	namespace za { namespace operations {
27	27
28	28	/**
29		* Constructor
30		*
31	29	* @param[in] lpLogger
32	30	* Pointer to the logger.
33	31	* @param[in] ulptStubbed
34	32	* The proptag of the stubbed property {72e98ebc-57d2-4ab5-b0aad50a7b531cb9}/stubbed
35		*
36		* @return HRESULT
37	33	*/
38	34	Stubber::Stubber(ECArchiverLogger *lpLogger, ULONG ulptStubbed, int ulAge, bool bProcessUnread)
39	35	: ArchiveOperationBase(lpLogger, ulAge, bProcessUnread, ARCH_NEVER_STUB)

+7

-2

ECtools/backup/Makefile.am less more

5	5	kopano_backup/__init__.py
6	6
7	7	install-exec-local:
8		cd ${srcdir} && ${PYTHON} setup.py install -f \
9		$${DESTDIR+--root=${DESTDIR}} \
	8	cd ${srcdir} && ${PYTHON} setup.py \
	9	build --build-base="${abs_builddir}/build" \
	10	install -f $${DESTDIR+--root=${DESTDIR}} \
10	11	--prefix ${prefix} --install-purelib ${pythondir}
11	12	rm -Rf build
	13
	14	uninstall-local:
	15	rm -Rf ${DESTDIR}${pythondir}/kopano_backup \
	16	${DESTDIR}${pythondir}/kopano_backup-0*.egg-info

+41

-25

ECtools/backup/kopano_backup/__init__.py less more

236	236
237	237	# determine stored and specified folders
238	238	path_folder = folder_struct(self.data_path, self.options)
239		paths = self.options.folders or sorted(path_folder.keys())
	239	paths = [_decode(f) for f in self.options.folders] or sorted(path_folder.keys())
240	240	if self.options.recursive:
241		paths = [path2 for path2 in path_folder for path in paths if path2.startswith(path+'/')]
	241	paths = [path2 for path2 in path_folder for path in paths if (path2+'//').startswith(path+'/')]
242	242
243	243	# restore specified folders
244	244	for path in paths:

247	247	stats['errors'] += 1
248	248	else:
249	249	# handle --restore-root, filter and start restore
250		restore_path = self.options.restore_root+'/'+path if self.options.restore_root else path
	250	restore_path = _decode(self.options.restore_root)+'/'+path if self.options.restore_root else path
251	251	folder = store.subtree.folder(restore_path, create=True)
252	252	if (not store.public and \
253	253	((self.options.skip_junk and folder == store.junk) or \

261	261	def create_jobs(self):
262	262	""" check command-line options and determine which stores should be backed up """
263	263
264		output_dir = self.options.output_dir or ''
	264	output_dir = _decode(self.options.output_dir) if self.options.output_dir else ''
265	265	jobs = []
266	266
267	267	# specified companies/all users

378	378	if mapper is None:
379	379	mapper = {}
380	380	if os.path.exists(data_path+'/path'):
381		path = file(data_path+'/path').read()
	381	path = file(data_path+'/path').read().decode('utf8')
382	382	mapper[path] = data_path
383	383	if os.path.exists(data_path+'/folders'):
384	384	for f in os.listdir(data_path+'/folders'):

403	403	# setup CSV writer, perform basic checks
404	404	writer = csv.writer(sys.stdout)
405	405	path_folder = folder_struct(data_path, options)
406		paths = options.folders or sorted(path_folder)
	406	paths = [_decode(f) for f in options.folders] or sorted(path_folder)
407	407	for path in paths:
408	408	if path not in path_folder:
409	409	print 'no such folder:', path

428	428
429	429	# --stats: one entry per folder
430	430	if options.stats:
431		writer.writerow([path, len(items)])
	431	writer.writerow([path.encode(sys.stdout.encoding or 'utf8'), len(items)])
432	432
433	433	# --index: one entry per item
434	434	elif options.index:
435	435	items.sort(key=lambda (k, d): d['last_modified'])
436	436	for key, d in items:
437		writer.writerow([key, path, d['last_modified'], d['subject'].encode(sys.stdout.encoding or 'utf8')])
	437	writer.writerow([key, path.encode(sys.stdout.encoding or 'utf8'), d['last_modified'], d['subject'].encode(sys.stdout.encoding or 'utf8')])
438	438
439	439	def dump_props(props):
440	440	""" dump given MAPI properties """

473	473	entryid = server.group(value).groupid
474	474	row[1].Value = entryid.decode('hex')
475	475	rows.append(row)
476		except kopano.ZNotFoundException:
	476	except kopano.NotFoundError:
477	477	log.warning("skipping access control entry for unknown user/group '%s'" % row[1].Value)
478	478	acltab = folder.mapiobj.OpenProperty(PR_ACL_TABLE, IID_IExchangeModifyTable, 0, MAPI_MODIFY)
479	479	acltab.ModifyTable(0, [ROWENTRY(ROW_ADD, row) for row in rows])

501	501	f = movecopy.findall('folder')[0]
502	502	path = store.folder(entryid=f.text.decode('base64').encode('hex')).path
503	503	f.text = path
504		except kopano.ZNotFoundException:
	504	except kopano.NotFoundError:
505	505	log.warning("skipping rule for unknown store/folder")
506	506	ruledata = ElementTree.tostring(etxml)
507	507	return pickle.dumps(ruledata)

523	523	s.text = store.entryid.decode('hex').encode('base64').strip()
524	524	f = movecopy.findall('folder')[0]
525	525	f.text = store.folder(f.text).entryid.decode('hex').encode('base64').strip()
526		except kopano.ZNotFoundException:
	526	except kopano.NotFoundError:
527	527	log.warning("skipping rule for unknown store/folder")
528	528	etxml = ElementTree.tostring(etxml)
529	529	folder.create_prop(PR_RULES_DATA, etxml)
530	530
	531	def _get_fbf(user, flags, log):
	532	try:
	533	fbeid = user.root.prop(PR_FREEBUSY_ENTRYIDS).value[1]
	534	return user.store.mapiobj.OpenEntry(fbeid, None, flags)
	535	except MAPIErrorNotFound:
	536	log.warning("skipping delegation because of missing freebusy data")
	537
531	538	def dump_delegates(user, server, log):
532	539	""" dump delegate users for given user """
533	540
534		# XXX more freebusy stuff?
535		fbeid = user.root.prop(PR_FREEBUSY_ENTRYIDS).value[1]
536		fbf = user.store.mapiobj.OpenEntry(fbeid, None, 0)
	541	fbf = _get_fbf(user, 0, log)
	542	delegate_uids = []
537	543	try:
538		delegate_uids = HrGetOneProp(fbf, PR_SCHDINFO_DELEGATE_ENTRYIDS).Value
	544	if fbf:
	545	delegate_uids = HrGetOneProp(fbf, PR_SCHDINFO_DELEGATE_ENTRYIDS).Value
539	546	except MAPIErrorNotFound:
540		delegate_uids = []
541		usernames = [server.sa.GetUser(uid, MAPI_UNICODE).Username for uid in delegate_uids]
	547	pass
	548
	549	usernames = []
	550	for uid in delegate_uids:
	551	try:
	552	usernames.append(server.sa.GetUser(uid, MAPI_UNICODE).Username)
	553	except MAPIErrorNotFound:
	554	log.warning("skipping delegate user for unknown userid")
542	555	return pickle.dumps(usernames)
543	556
544	557	def load_delegates(user, server, data, log):
545	558	""" load delegate users for given user """
546	559
547		data = pickle.loads(data)
548		fbeid = user.root.prop(PR_FREEBUSY_ENTRYIDS).value[1]
549		fbf = user.store.mapiobj.OpenEntry(fbeid, None, MAPI_MODIFY)
550		try:
551		fbf.SetProps([SPropValue(PR_SCHDINFO_DELEGATE_ENTRYIDS, [server.user(name).userid.decode('hex') for name in data])])
	560	userids = []
	561	for name in pickle.loads(data):
	562	try:
	563	userids.append(server.user(name).userid.decode('hex'))
	564	except kopano.NotFoundError:
	565	log.warning("skipping delegation for unknown user '%s'" % name)
	566
	567	fbf = _get_fbf(user, MAPI_MODIFY, log)
	568	if fbf:
	569	fbf.SetProps([SPropValue(PR_SCHDINFO_DELEGATE_ENTRYIDS, userids)])
552	570	fbf.SaveChanges(0)
553		except kopano.ZNotFoundException:
554		log.warning("skipping delegation for unknown user '%s'" % name)
555	571
556	572	def main():
557	573	# select common options

573	589
574	590	# parse and check command-line options
575	591	options, args = parser.parse_args()
576		options.foreground = True
	592	options.service = False
577	593	if options.restore or options.stats or options.index:
578	594	assert len(args) == 1 and os.path.isdir(args[0]), 'please specify path to backup data'
579	595	else:

+0

-1

ECtools/cfgchecker/LDAPConfigCheck.cpp less more

42	42	addCheck("ldap_user_search_filter", 0, &testLdapQuery);
43	43	addCheck("ldap_group_search_filter", 0, &testLdapQuery);
44	44	addCheck("ldap_company_search_filter", 0, &testLdapQuery);
45
46	45
47	46	addCheck("ldap_user_unique_attribute", CONFIG_MANDATORY);
48	47	addCheck("ldap_user_unique_attribute_type", 0, &testLdapType);

+0

-1

ECtools/cfgchecker/ServerConfigCheck.cpp less more

54	54	addCheck("enable_distributed_kopano", 0, &testBoolean);
55	55	addCheck("server_name", CONFIG_MULTI_USED);
56	56	// addCheck("thread_stacksize", 0, &testMinInt, 25);
57
58	57
59	58	addCheck("enable_gab", 0, &testBoolean);
60	59	addCheck("enable_sso_ntlmauth", 0, &testBoolean);

+0

-1

ECtools/fsck/fsck-calendar.cpp less more

591	591	return ValidateRecursiveDuplicateRecipients(lpMessage, bChanged);
592	592	}
593	593
594

+3

-4

ECtools/fsck/fsck-contact.cpp less more

173	173	HRESULT FsckContact::ValidateItem(LPMESSAGE lpMessage,
174	174	const std::string &strClass)
175	175	{
176		HRESULT hr;
	176	HRESULT hr = hrSuccess;
177	177
178	178	if (strClass != "IPM.Contact" && strClass != "IPM.DistList") {
179	179	std::cout << "Illegal class: \"" << strClass << "\"" << std::endl;

183	183	if (strClass == "IPM.Contact")
184	184	hr = ValidateContactNames(lpMessage);
185	185	// else: @todo distlist validation
186		if (hr != hrSuccess)
187		return hr;
188		return hrSuccess;
	186
	187	return hr;
189	188	}

+0

-3

ECtools/fsck/fsck-main.cpp less more

461	461	pRows = NULL;
462	462	}
463	463
464
465	464	message:
466	465	lpTable->Release();
467	466	lpTable = NULL;

512	511	if (hr != hrSuccess)
513	512	goto exit;
514	513
515
516	514	if (cRows < 1) {
517	515	// 0 or 1 row not needed to check
518	516	goto exit;

565	563	if (!mapiReciptDel.empty()) {
566	564	hr = DeleteRecipientList(lpMessage, mapiReciptDel, bChanged);
567	565	}
568
569	566
570	567
571	568	exit:

+0

-69

~~ECtools/hx-time.c~~ less more

0		/*
1		* Copyright Jan Engelhardt, 2012
2		*
3		* This file is taken from libHX. libHX is free software; you can
4		* redistribute it and/or modify it under the terms of the GNU Lesser
5		* General Public License as published by the Free Software Foundation;
6		* either version 2.1 or (at your option) any later version.
7		*/
8		#include <time.h>
9		#include "hx-time.h"
10		#define NANOSECOND 1000000000
11
12		struct timespec *
13		HX_timespec_neg(struct timespec r, const struct timespec a)
14		{
15		if (a->tv_sec != 0) {
16		r->tv_sec = -a->tv_sec;
17		r->tv_nsec = a->tv_nsec;
18		} else {
19		r->tv_sec = 0;
20		r->tv_nsec = -a->tv_nsec;
21		}
22		return r;
23		}
24
25		struct timespec HX_timespec_add(struct timespec r,
26		const struct timespec a, const struct timespec b)
27		{
28		/*
29		* Split the value represented by the struct into two
30		* independent values that can be added individually.
31		*/
32		long nsec[2];
33		nsec[0] = (a->tv_sec < 0) ? -a->tv_nsec : a->tv_nsec;
34		nsec[1] = (b->tv_sec < 0) ? -b->tv_nsec : b->tv_nsec;
35
36		r->tv_sec = a->tv_sec + b->tv_sec;
37		r->tv_nsec = nsec[0] + nsec[1];
38		if (r->tv_nsec >= NANOSECOND) {
39		++r->tv_sec;
40		r->tv_nsec -= NANOSECOND;
41		} else if (r->tv_nsec <= -NANOSECOND) {
42		--r->tv_sec;
43		r->tv_nsec += NANOSECOND;
44		}
45
46		/* Combine again */
47		if (r->tv_sec < 0) {
48		if (r->tv_nsec < 0) {
49		r->tv_nsec = -r->tv_nsec;
50		} else if (r->tv_nsec > 0) {
51		if (++r->tv_sec == 0)
52		r->tv_nsec = -NANOSECOND + r->tv_nsec;
53		else
54		r->tv_nsec = NANOSECOND - r->tv_nsec;
55		}
56		} else if (r->tv_sec > 0 && r->tv_nsec < 0) {
57		--r->tv_sec;
58		r->tv_nsec = NANOSECOND + r->tv_nsec;
59		}
60		return r;
61		}
62
63		struct timespec HX_timespec_sub(struct timespec r,
64		const struct timespec a, const struct timespec b)
65		{
66		struct timespec b2;
67		return HX_timespec_add(r, a, HX_timespec_neg(&b2, b));
68		}

+0

-16

~~ECtools/hx-time.h~~ less more

0		#ifndef LOCAL_HXTIME_H
1		#define LOCAL_HXTIME_H 1
2
3		#ifdef __cplusplus
4		extern "C" {
5		#endif
6
7		extern struct timespec HX_timespec_neg(struct timespec , const struct timespec *);
8		extern struct timespec HX_timespec_add(struct timespec , const struct timespec , const struct timespec );
9		extern struct timespec HX_timespec_sub(struct timespec , const struct timespec , const struct timespec );
10
11		#ifdef __cplusplus
12		} /* extern "C" */
13		#endif
14
15		#endif /* LOCAL_HXTIME_H */

+9

-6

ECtools/mapitime.cpp less more

	0	#include <chrono>
0	1	#include <cerrno>
1	2	#include <csignal>
2	3	#include <cstdio>

7	8	#include <kopano/ECLogger.h>
8	9	#include <kopano/MAPIErrors.h>
9	10	#include <kopano/charset/convert.h>
10		#include "hx-time.h"
11	11
12	12	struct mpt_stat_entry {
13	13	struct timespec start, stop;

26	26	return;
27	27	const struct mpt_stat_entry &first = *mpt_stat_list.begin();
28	28	const struct mpt_stat_entry &last = *mpt_stat_list.rbegin();
29		struct timespec delta;
30		HX_timespec_sub(&delta, &last.stop, &first.start);
31		double dt = delta.tv_sec + delta.tv_nsec / 1000000000.0;
32		if (dt == 0)
	29	typedef std::chrono::seconds sec;
	30	typedef std::chrono::nanoseconds nsec;
	31	auto dt = std::chrono::duration<double>(
	32	sec(last.stop.tv_sec) + nsec(last.stop.tv_nsec) -
	33	(sec(first.start.tv_sec) + nsec(first.start.tv_nsec)));
	34	if (dt.count() == 0)
33	35	return;
34		printf("\r\e[2K%.1f per second", z / dt);
	36	printf("\r\e[2K%.1f per second", z / dt.count());
35	37	fflush(stdout);
36	38	}
37	39

47	49	struct sigaction sa;
48	50	sa.sa_handler = mpt_stat_dump;
49	51	sa.sa_flags = SA_RESTART;
	52	sigemptyset(&sa.sa_mask);
50	53	if (sigaction(SIGALRM, &sa, NULL) < 0) {
51	54	perror("sigaction");
52	55	return -errno;

+3

-6

ECtools/monitor/ECQuotaMonitor.cpp less more

56	56	#define QUOTA_CONFIG_MSG "Kopano.Quota"
57	57
58	58	/**
59		* ECQuotaMonitor constructor
60	59	* Takes an extra reference to the passed MAPI objects which have refcounting.
61	60	*/
62	61	ECQuotaMonitor::ECQuotaMonitor(ECTHREADMONITOR *lpThreadMonitor,

77	76	}
78	77
79	78	/**
80		* ECQuotaMonitor destructor
81	79	* Releases references to passed MAPI objects.
82	80	*/
83	81	ECQuotaMonitor::~ECQuotaMonitor()

297	295
298	296	set<string> setServers;
299	297	const char *lpszServersConfig;
300		std::set<string, stricmp_comparison> setServersConfig;
	298	std::set<string, strcasecmp_comparison> setServersConfig;
301	299	set<string>::const_iterator iServers;
302	300	char *lpszConnection = NULL;
303	301	bool bIsPeer = false;

700	698	* @retval MAPI_E_NOT_ENOUGH_MEMORY unable to allocate more memory
701	699	*/
702	700	HRESULT ECQuotaMonitor::CreateMessageProperties(ECUSER *lpecToUser,
703		ECUSER *lpecFromUser, std::string strSubject, std::string strBody,
704		ULONG lpcPropSize, LPSPropValue lppPropArray)
	701	ECUSER *lpecFromUser, const std::string &strSubject,
	702	const std::string &strBody, ULONG lpcPropSize, LPSPropValue lppPropArray)
705	703	{
706	704	HRESULT hr = hrSuccess;
707	705	LPSPropValue lpPropArray = NULL;

801	799	lpPropArray[ulPropArrayCur].ulPropTag = PR_RCVD_REPRESENTING_EMAIL_ADDRESS_A;
802	800	lpPropArray[ulPropArrayCur++].Value.lpszA = (lpecToUser->lpszMailAddress ? (LPSTR)lpecToUser->lpszMailAddress : (LPSTR)"");
803	801
804
805	802	hr = MAPIAllocateMore(cbToEntryid, lpPropArray,
806	803	(void**)&lpPropArray[ulPropArrayCur].Value.bin.lpb);
807	804	if (hr != hrSuccess)

+1

-1

ECtools/monitor/ECQuotaMonitor.h less more

48	48
49	49	private:
50	50	HRESULT CreateMailFromTemplate(TemplateVariables lpVars, std::string lpstrSubject, std::string *lpstrBody);
51		HRESULT CreateMessageProperties(ECUSER lpecToUser, ECUSER lpecFromUser, std::string strSubject, std::string strBody, ULONG lpcPropSize, LPSPropValue lppPropArray);
	51	HRESULT CreateMessageProperties(ECUSER touesr, ECUSER fromuser, const std::string &subj, const std::string &body, ULONG lpcPropSize, LPSPropValue lppPropArray);
52	52	HRESULT CreateRecipientList(ULONG cToUsers, ECUSER lpToUsers, LPADRLIST lppAddrList);
53	53
54	54	HRESULT SendQuotaWarningMail(IMsgStore* lpMDB, ULONG cPropSize, LPSPropValue lpPropArray, LPADRLIST lpAddrList);

+1

-22

ECtools/monitor/monitor.cpp less more

35	35	#include "ECQuotaMonitor.h"
36	36
37	37	#include <kopano/CommonUtil.h>
38		#ifdef LINUX
39	38	#include <kopano/UnixUtil.h>
40		#endif
41	39	#include <kopano/ecversion.h>
42	40	#include "charset/localeutil.h"
43	41

83	81	{
84	82	// In Win32, the signal is sent in a separate, special signal thread. So this test is
85	83	// not needed or required.
86		#ifdef LINUX
87	84	if (pthread_equal(pthread_self(), mainthread)==0)
88	85	return;
89		#endif
90	86	if (m_lpThreadMonitor) {
91	87	if (m_lpThreadMonitor->lpConfig) {
92	88	if (!m_lpThreadMonitor->lpConfig->ReloadSettings() && m_lpThreadMonitor->lpLogger)

106	102	}
107	103	}
108	104
109		#ifdef LINUX
110	105	// SIGSEGV catcher
111	106	static void sigsegv(int signr, siginfo_t si, void uc)
112	107	{
113	108	generic_sigsegv_handler(m_lpThreadMonitor->lpLogger, "Monitor",
114	109	PROJECT_VERSION_MONITOR_STR, signr, si, uc);
115	110	}
116		#endif
117	111
118	112	static void print_help(const char *name)
119	113	{

128	122	int main(int argc, char *argv[]) {
129	123
130	124	HRESULT hr = hrSuccess;
131		#ifdef LINUX
132	125	const char *szConfig = ECConfig::GetDefaultPath("monitor.cfg");
133		#else
134		const char *szConfig = "monitor.cfg";
135		#endif
136	126	const char *szPath = NULL;
137	127	int c;
138	128	int daemonize = 1;

142	132	static const configsetting_t lpDefaults[] = {
143	133	{ "smtp_server","localhost" },
144	134	{ "server_socket", "default:" },
145		#ifdef LINUX
146	135	{ "run_as_user", "kopano" },
147	136	{ "run_as_group", "kopano" },
148	137	{ "pid_file", "/var/run/kopano/monitor.pid" },
149	138	{ "running_path", "/var/lib/kopano" },
150		#endif
151	139	{ "log_method","file" },
152		#ifdef LINUX
153	140	{ "log_file","/var/log/kopano/monitor.log" },
154		#else
155		{ "log_file","-" },
156		#endif
157	141	{ "log_level", "3", CONFIGSETTING_RELOADABLE },
158	142	{ "log_timestamp","1" },
159	143	{ "log_buffer_size", "0" },

247	231	if ((bIgnoreUnknownConfigOptions && m_lpThreadMonitor->lpConfig->HasErrors()) \|\| m_lpThreadMonitor->lpConfig->HasWarnings())
248	232	LogConfigErrors(m_lpThreadMonitor->lpConfig);
249	233
250
251	234	// set socket filename
252	235	if (!szPath)
253	236	szPath = m_lpThreadMonitor->lpConfig->GetSetting("server_socket");
254	237
255	238	signal(SIGTERM, sighandle);
256	239	signal(SIGINT, sighandle);
257		#ifdef LINUX
258	240	signal(SIGHUP, sighup);
259	241
260	242	// SIGSEGV backtrace support

275	257	sigaction(SIGSEGV, &act, NULL);
276	258	sigaction(SIGBUS, &act, NULL);
277	259	sigaction(SIGABRT, &act, NULL);
278		#endif
279
280		#ifdef LINUX
	260
281	261	// fork if needed and drop privileges as requested.
282	262	// this must be done before we do anything with pthreads
283	263	if (unix_runas(m_lpThreadMonitor->lpConfig, m_lpThreadMonitor->lpLogger))

288	268	setsid();
289	269	if (unix_create_pidfile(argv[0], m_lpThreadMonitor->lpConfig, m_lpThreadMonitor->lpLogger, false) < 0)
290	270	goto exit;
291		#endif
292	271
293	272	// Init exit threads
294	273	pthread_mutex_init(&m_hExitMutex, NULL);

+7

-2

ECtools/presence/Makefile.am less more

5	5	kopano_presence/plugin_xmpp.py kopano_presence/plugin_spreed.py
6	6
7	7	install-exec-local:
8		cd ${srcdir} && ${PYTHON} setup.py install -f \
9		$${DESTDIR+--root=${DESTDIR}} \
	8	cd ${srcdir} && ${PYTHON} setup.py \
	9	build --build-base="${abs_builddir}/build" \
	10	install -f $${DESTDIR+--root=${DESTDIR}} \
10	11	--prefix="${prefix}" --install-purelib ${pythondir}
11	12	rm -Rf build
	13
	14	uninstall-local:
	15	rm -Rf ${DESTDIR}${pythondir}/kopano_presence \
	16	${DESTDIR}${pythondir}/kopano_presence-0*.egg-info

+20

-0

ECtools/pst-import/Makefile.am less more

	0	# -- Makefile --
	1
	2	sbin_PROGRAMS = kopano-pst-import
	3
	4	PST_LIBS =${top_builddir}/common/libkcmapi.la \
	5	${top_builddir}/common/libkcutil.la \
	6	${top_builddir}/mapi4linux/src/libmapi.la \
	7	-lpff \
	8	${PROG_LIBS} ${SSL_LIBS} ${BOOST_FILESYSTEM_LIBS} ${BOOST_SYSTEM_LIBS}
	9
	10	PST_SOURCES = import.cpp
	11
	12	AM_CPPFLAGS = ${ZCPPFLAGS} ${DEBUGFLAGS} ${BOOST_CPPFLAGS} \
	13	-I${top_srcdir}/mapi4linux/include \
	14	${zcp_CFLAGS}
	15
	16	kopano_pst_import_LDADD = ${zcp_LIBS} ${PST_LIBS}
	17	kopano_pst_import_SOURCES = ${PST_SOURCES}
	18
	19	include ../../global.am

+566

-0

ECtools/pst-import/import.cpp less more

	0	/*
	1	* Copyright 2005 - 2016 Zarafa B.V. and its licensors
	2	*/
	3
	4	#include <kopano/platform.h>
	5
	6	#include <iostream>
	7	#include <kopano/ECLogger.h>
	8	#include <libpff/error.h>
	9	#include <libpff.h>
	10	#include <kopano/charset/convert.h>
	11
	12	#include <kopano/mapi_ptr.h>
	13	#include <mapiguid.h>
	14	#include <mapidefs.h>
	15	#include <mapitags.h>
	16	#include <mapiutil.h>
	17	#include <mapix.h>
	18
	19	#include <kopano/ecversion.h>
	20	#include <kopano/CommonUtil.h>
	21
	22	using namespace std;
	23
	24	std::wstring GetPropString(libpff_item_t *item, unsigned int ulPropTag);
	25	HRESULT value_to_spropval(uint32_t propid, uint32_t proptype, uint8_t data, size_t size, void base, LPSPropValue lpProp);
	26	HRESULT item_to_srowset(libpff_item_t item, LPSRowSet lppRowSet);
	27	HRESULT dump_message( libpff_item_t item, IMAPIFolder lpFolder);
	28	HRESULT dump_folder(libpff_file_t file, libpff_item_t item, IMAPIFolder *lpFolder);
	29	HRESULT dump_store(libpff_file_t file, libpff_item_t store, libpff_item_t item, IMAPIFolder lpFolder);
	30
	31
	32	std::wstring GetPropString(libpff_item_t *item, unsigned int ulPropTag)
	33	{
	34	libpff_error_t *error = NULL;
	35	uint32_t type = 0;
	36	uint8_t *data = NULL;
	37	size_t size;
	38
	39	if(libpff_item_get_entry_value(item, 0, PROP_ID(ulPropTag), &type, &data, &size, LIBPFF_ENTRY_VALUE_FLAG_MATCH_ANY_VALUE_TYPE, &error) != 1) {
	40	return std::wstring(L"");
	41	}
	42
	43	if(type == PT_STRING8)
	44	return convert_to<std::wstring>((char *)data, size, "windows-1252");
	45	else
	46	return convert_to<std::wstring>((char *)data, size, "UCS-2");
	47	}
	48
	49	HRESULT value_to_spropval(uint32_t propid, uint32_t proptype, uint8_t data, size_t size, void base, LPSPropValue lpProp)
	50	{
	51	HRESULT hr = hrSuccess;
	52
	53	lpProp->ulPropTag = PROP_TAG(proptype, propid);
	54
	55	switch(proptype) {
	56	case PT_STRING8: {
	57	std::string str = convert_to<std::string>("//FORCE", (char *)data, size, "windows-1252");
	58
	59	if ((hr = MAPIAllocateMore(str.size()+1, base, (void **)&lpProp->Value.lpszA)) != hrSuccess)
	60	goto exit;
	61	strcpy(lpProp->Value.lpszA, str.c_str());
	62	break;
	63	}
	64	case PT_UNICODE: {
	65	std::wstring wstr;
	66
	67	wstr = convert_to<std::wstring>("WCHAR_T//FORCE",(char *)data, size, "UCS-2LE");
	68
	69	if ((hr = MAPIAllocateMore((wstr.size()+1) * sizeof(wchar_t), base, (void **)&lpProp->Value.lpszW)) != hrSuccess)
	70	goto exit;
	71	wcscpy(lpProp->Value.lpszW, wstr.c_str());
	72	break;
	73	}
	74	case PT_BINARY:
	75	if ((hr = MAPIAllocateMore(size, base, (void **)&lpProp->Value.bin.lpb)) != hrSuccess)
	76	goto exit;
	77	memcpy(lpProp->Value.bin.lpb, data, size);
	78	lpProp->Value.bin.cb = size;
	79	break;
	80	case PT_LONG:
	81	if(size != sizeof(unsigned int)) {
	82	wcerr << "Unexpected data size " << size << " != " << sizeof(unsigned int) << std::endl;
	83	hr = MAPI_E_INVALID_PARAMETER;
	84	goto exit;
	85	}
	86	lpProp->Value.ul = (unsigned int )data;
	87	break;
	88	case PT_BOOLEAN:
	89	if(size != sizeof(unsigned char)) {
	90	wcerr << "Unexpected data size " << size << " != " << sizeof(unsigned char) << std::endl;
	91	hr = MAPI_E_INVALID_PARAMETER;
	92	goto exit;
	93	}
	94	lpProp->Value.b = (unsigned char )data;
	95	break;
	96	case PT_I2:
	97	if(size != sizeof(unsigned short)) {
	98	wcerr << "Unexpected data size " << size << " != " << sizeof(unsigned short) << std::endl;
	99	hr = MAPI_E_INVALID_PARAMETER;
	100	goto exit;
	101	}
	102	lpProp->Value.i = (unsigned short )data;
	103	break;
	104	case PT_SYSTIME:
	105	if(size != sizeof(FILETIME)) {
	106	wcerr << "Unexpected data size " << size << " != " << sizeof(FILETIME) << std::endl;
	107	hr = MAPI_E_INVALID_PARAMETER;
	108	goto exit;
	109	}
	110	lpProp->Value.ft = (FILETIME )data;
	111	break;
	112	default:
	113	hr = MAPI_E_INVALID_PARAMETER;
	114	}
	115
	116	exit:
	117	return hr;
	118	}
	119
	120	HRESULT item_to_srowset(libpff_item_t item, LPSRowSet lppRowSet) {
	121	HRESULT hr = hrSuccess;
	122	libpff_name_to_id_map_entry_t *name_to_id_map_entry = NULL;
	123	size_t size = 0;
	124	uint32_t entry_type = 0;
	125	uint32_t value_type = 0;
	126	uint8_t *value_data = NULL;
	127	uint32_t rows, columns;
	128	LPSRowSet rowset = NULL;
	129	libpff_error_t *error = NULL;
	130	int n = 0;
	131
	132	if(libpff_item_get_number_of_sets(item, &rows, &error) != 1) {
	133	wcerr << "Unable to get number of sets\n";
	134	hr = MAPI_E_NOT_FOUND;
	135	goto exit;
	136	}
	137
	138	if(libpff_item_get_number_of_entries(item, &columns, &error) != 1) {
	139	wcerr << "Unable to get number of entries\n";
	140	hr = MAPI_E_NOT_FOUND;
	141	goto exit;
	142	}
	143
	144	if ((hr = MAPIAllocateBuffer(CbNewSRowSet(rows), (void **)&rowset)) != hrSuccess)
	145	goto exit;
	146
	147	memset(rowset, 0, CbNewSRowSet(rows));
	148
	149	for(uint32_t i = 0; i < rows; i++) {
	150	if ((hr = MAPIAllocateBuffer(sizeof(SPropValue) * columns, (void **)&rowset->aRow[i].lpProps)) != hrSuccess)
	151	goto exit;
	152	memset(rowset->aRow[i].lpProps, 0, sizeof(SPropValue) * columns);
	153	n = 0;
	154	for(uint32_t j = 0; j < columns; j++) {
	155	if(libpff_item_get_entry_type(item, i, j, &entry_type, &value_type, &name_to_id_map_entry, &error) != 1) {
	156	wcerr << "Unable to get property tag " << j << endl;
	157	continue;
	158	}
	159
	160	if(libpff_item_get_entry_value(item, i, entry_type, &value_type, &value_data, &size, LIBPFF_ENTRY_VALUE_FLAG_MATCH_ANY_VALUE_TYPE \| LIBPFF_ENTRY_VALUE_FLAG_IGNORE_NAME_TO_ID_MAP, &error) == -1) {
	161	wcerr << "Unable to get property " << j << endl;
	162	continue;
	163	} else {
	164	if(!value_data)
	165	continue;
	166
	167	if(value_to_spropval(entry_type, value_type, value_data, size, rowset->aRow[i].lpProps, &rowset->aRow[i].lpProps[n]) != hrSuccess) {
	168	continue;
	169	}
	170	n++;
	171	}
	172	}
	173	rowset->aRow[i].cValues = n;
	174	}
	175
	176	rowset->cRows = rows;
	177
	178	*lppRowSet = rowset;
	179
	180	exit:
	181	return hr;
	182	}
	183
	184	HRESULT dump_message( libpff_item_t item, IMAPIFolder lpFolder) {
	185	HRESULT hr = hrSuccess;
	186	MessagePtr lpMessage;
	187
	188	IAttach *lpAttach = NULL;
	189	IStream *lpStream = NULL;
	190	ULONG ulAttachId = 0;
	191	int attachcount;
	192	libpff_error_t *error = NULL;
	193	libpff_item_t *recipients = NULL;
	194	mapi_rowset_ptr<SRow> props, recipprops, attachprops;
	195	libpff_item_t attachment = NULL, attachments = NULL;
	196
	197	hr = item_to_srowset(item, &props);
	198	if(hr != hrSuccess) {
	199	wcerr << "Unable to get properties\n";
	200	goto exit;
	201	}
	202
	203	if(props.size() != 1) {
	204	wcerr << "Number of sets is not 1\n";
	205	hr = MAPI_E_NOT_FOUND;
	206	goto exit;
	207	}
	208
	209	if(libpff_message_get_recipients(item, &recipients, &error) != 1) {
	210	wcerr << "Unable to get recipients\n";
	211	hr = MAPI_E_NOT_FOUND;
	212	goto exit;
	213	}
	214
	215	hr = item_to_srowset(recipients, &recipprops);
	216	if(hr != hrSuccess) {
	217	wcerr << "Unable to get recipient propers\n";
	218	goto exit;
	219	}
	220
	221	hr = lpFolder->CreateMessage(&IID_IMessage, 0, &lpMessage);
	222	if(hr != hrSuccess) {
	223	wcerr << "Unable to create MAPI message\n";
	224	goto exit;
	225	}
	226
	227	hr = lpMessage->SetProps(props[0].cValues, props[0].lpProps, NULL);
	228	if(hr != hrSuccess) {
	229	wcerr << "Unable to set properties\n";
	230	goto exit;
	231	}
	232
	233	hr = lpMessage->ModifyRecipients(0, (LPADRLIST)recipprops.get());
	234	if(hr != hrSuccess) {
	235	wcerr << "Unable to set recipients\n";
	236	goto exit;
	237	}
	238
	239	if(libpff_message_get_number_of_attachments(item, &attachcount, &error) != 1) {
	240	hr = MAPI_E_NOT_FOUND;
	241	wcerr << "Unable to get number of attachments\n";
	242	goto exit;
	243	}
	244
	245	if(attachcount > 0) {
	246	if(libpff_message_get_attachments(item, &attachments, &error) != 1) {
	247	hr = MAPI_E_NOT_FOUND;
	248	wcerr << "Unable to get attachments\n";
	249	goto exit;
	250	}
	251
	252	hr = item_to_srowset(attachments, &attachprops);
	253	if(hr != hrSuccess) {
	254	wcerr << "Unable to get attachment properties\n";
	255	goto exit;
	256	}
	257
	258	for(int i = 0; i < attachcount ; i++) {
	259	int attachment_type = 0;
	260	size64_t data_size;
	261
	262	if(libpff_message_get_attachment(item, i, &attachment, &error) != 1) {
	263	wcerr << "Unable to get attachment " << i << endl;
	264	continue;
	265	}
	266
	267	hr = lpMessage->CreateAttach(&IID_IAttachment, 0, &ulAttachId, &lpAttach);
	268	if(hr != hrSuccess) {
	269	wcerr << "Unable to create attachment " << i << endl;
	270	goto exit;
	271	}
	272
	273	hr = lpAttach->SetProps(attachprops[i].cValues, attachprops[i].lpProps, NULL);
	274	if(hr != hrSuccess) {
	275	wcerr << "Unable to set attachment properties";
	276	goto exit;
	277	}
	278
	279	if(libpff_attachment_get_type(attachment, &attachment_type, &error) != 1) {
	280	wcerr << "Unable to get attachment type\n";
	281	hr = MAPI_E_NOT_FOUND;
	282	goto exit;
	283	}
	284
	285	if(attachment_type == LIBPFF_ATTACHMENT_TYPE_DATA) {
	286	char buffer[65536];
	287	SPropValue sProp;
	288
	289	sProp.ulPropTag = PR_ATTACH_METHOD;
	290	sProp.Value.ul = ATTACH_BY_VALUE;
	291	HrSetOneProp(lpAttach, &sProp);
	292
	293
	294	hr = lpAttach->OpenProperty(PR_ATTACH_DATA_BIN, &IID_IStream, STGM_WRITE \| STGM_SHARE_EXCLUSIVE, MAPI_CREATE \| MAPI_MODIFY, (IUnknown **)&lpStream);
	295	if(hr != hrSuccess) {
	296	wcerr << "Unable to create attachment data stream\n";
	297	goto exit;
	298	}
	299
	300	if(libpff_attachment_get_data_size(attachment, &data_size, &error) != 1) {
	301	wcerr << "Unable to get attachment size\n";
	302	continue;
	303	}
	304
	305	if(data_size) {
	306	if(libpff_attachment_data_seek_offset(attachment, 0, SEEK_SET, &error) != 0) {
	307	wcerr << "Unable to seek to attachment data start\n";
	308	continue;
	309	}
	310
	311	while( data_size > 0 ) {
	312	int read = libpff_attachment_data_read_buffer(attachment, (uint8_t *)buffer, sizeof(buffer) > data_size ? data_size : sizeof(buffer), &error);
	313
	314	if(read < 0 ) {
	315	wcerr << "Read failed on data stream\n";
	316	continue;
	317	}
	318
	319	data_size -= read;
	320
	321	hr = lpStream->Write(buffer, read, NULL);
	322	if(hr != hrSuccess)
	323	goto exit;
	324	}
	325	}
	326
	327	lpStream->Commit(0);
	328	lpStream->Release();
	329	lpStream = NULL;
	330	}
	331
	332	hr = lpAttach->SaveChanges(0);
	333	if(hr != hrSuccess) {
	334	wcerr << "Unable to save attachment\n";
	335	goto exit;
	336	}
	337
	338	lpAttach->Release();
	339	lpAttach = NULL;
	340
	341	libpff_item_free(&attachment, &error);
	342	}
	343	}
	344
	345	hr = lpMessage->SaveChanges(0);
	346	if(hr != hrSuccess) {
	347	wcerr << "Unable to save MAPI message\n";
	348	goto exit;
	349	}
	350
	351	exit:
	352	if(attachments)
	353	libpff_item_free(&attachments, &error);
	354
	355	if(recipients)
	356	libpff_item_free(&recipients, &error);
	357
	358	return hr;
	359	}
	360
	361	HRESULT dump_folder(libpff_file_t file, libpff_item_t item, IMAPIFolder *lpFolder) {
	362	HRESULT hr = hrSuccess;
	363	int folders, messages;
	364	libpff_error_t *error = NULL;
	365	std::wstring wstrDisplay;
	366	libpff_item_t message = NULL, subfolder = NULL;
	367	IMAPIFolder *lpSubFolder = NULL;
	368
	369	wstrDisplay = GetPropString(item, PR_DISPLAY_NAME_A);
	370
	371	wcerr << "Processing folder " << wstrDisplay << endl;
	372
	373	hr = lpFolder->CreateFolder(FOLDER_GENERIC, (TCHAR )wstrDisplay.c_str(), (TCHAR )L"", &IID_IMAPIFolder, MAPI_UNICODE \| OPEN_IF_EXISTS, &lpSubFolder);
	374	if(hr != hrSuccess) {
	375	wcerr << "Unable to create folder '" << wstrDisplay << "'\n";
	376	goto exit;
	377	}
	378
	379	if(libpff_folder_get_number_of_sub_messages(item, &messages, &error) != 1) {
	380	wcerr << "Unable to get number of subfolders\n";
	381	hr = MAPI_E_NOT_FOUND;
	382	goto exit;
	383	}
	384
	385	for(int i = 0; i < messages; i++) {
	386	if(libpff_folder_get_sub_message(item, i, &message, &error) != 1) {
	387	wcerr << "Unable to get message number " << i << endl;
	388	continue;
	389	}
	390
	391	dump_message(message, lpSubFolder);
	392
	393	libpff_item_free(&message, &error);
	394	}
	395
	396
	397	if(libpff_folder_get_number_of_sub_folders(item, &folders, &error) != 1) {
	398	hr = MAPI_E_NOT_FOUND;
	399	wcerr << "Unable to get number of subfolders\n";
	400	goto exit;
	401	}
	402
	403	for(int i = 0; i < folders; i++) {
	404	if(libpff_folder_get_sub_folder(item, i, &subfolder, &error) != 1) {
	405	wcerr << "Unable to get folder number " << i << endl;
	406	continue;
	407	}
	408
	409	dump_folder(file, subfolder, lpSubFolder);
	410
	411	libpff_item_free(&subfolder, &error);
	412	}
	413
	414	exit:
	415	if (lpSubFolder)
	416	lpSubFolder->Release();
	417
	418	return hr;
	419	}
	420
	421	HRESULT dump_store(libpff_file_t file, libpff_item_t store, libpff_item_t item, IMAPIFolder lpFolder)
	422	{
	423	HRESULT hr = hrSuccess;
	424	libpff_item_t *subfolder = NULL;
	425	uint32_t type = PROP_TYPE(PR_IPM_SUBTREE_ENTRYID);
	426	libpff_error_t *error = NULL;
	427	uint8_t *data = NULL;
	428	size_t size;
	429	mapi_rowset_ptr<SRow> r;
	430
	431	std::wstring strStore = GetPropString(store, PR_DISPLAY_NAME_W);
	432
	433	wcerr << "Store name " << strStore << endl;
	434
	435	if(libpff_item_get_entry_value(store, 0, PROP_ID(PR_IPM_SUBTREE_ENTRYID), &type, &data, &size, 0, &error) != 1) {
	436	wcerr << "Unable to get ipm subtree\n";
	437	hr = MAPI_E_NOT_FOUND;
	438	goto exit;
	439	}
	440
	441	if(size != 4 + sizeof(GUID) + sizeof(unsigned int)) {
	442	wcerr << "Unexpected entryid size for IPM subtree:" << size << endl;
	443	hr = MAPI_E_NOT_FOUND;
	444	goto exit;
	445	}
	446
	447	if(libpff_file_get_item_by_identifier(file, (unsigned int )(data + 4 + sizeof(GUID)), &subfolder, &error) != 1) {
	448	wcerr << "Unable to get IPM subtree\n";
	449	hr = MAPI_E_NOT_FOUND;
	450	goto exit;
	451	}
	452
	453	dump_folder(file, subfolder, lpFolder);
	454
	455	libpff_item_free(&subfolder, &error);
	456
	457	exit:
	458	return hr;
	459	}
	460
	461	int main(int argc, char *argv[]) {
	462	libpff_file_t *file = NULL;
	463	libpff_error_t *error = NULL;
	464	libpff_item_t *pff_root_item = NULL;
	465	libpff_item_t *pff_store_item = NULL;
	466
	467	char *filename;
	468	char *username;
	469
	470	ULONG ulType = 0;
	471	HRESULT hr = hrSuccess;
	472
	473	setlocale(LC_CTYPE, "");
	474
	475	if(argc != 3) {
	476	wcerr << "Usage: pstexport <filename> <user>\n";
	477	return 1;
	478	}
	479
	480	filename = argv[1];
	481	username = argv[2];
	482
	483	hr = MAPIInitialize(NULL);
	484	if(hr != hrSuccess) {
	485	wcerr << "Unable to initialize MAPI\n";
	486	return 1;
	487	}
	488
	489	{
	490	MAPISessionPtr lpSession;
	491	MsgStorePtr lpStore;
	492	MAPIFolderPtr lpFolder;
	493	SPropValuePtr lpPropIPM;
	494
	495	if(libpff_file_initialize(&file, &error) != 1) {
	496	wcerr << "Init failed\n";
	497	return 1;
	498	}
	499
	500	if(libpff_file_open(file, filename, LIBPFF_OPEN_READ, &error) != 1) {
	501	wcerr << "Unable to open file\n";
	502	return 1;
	503	}
	504
	505	hr = HrOpenECSession(ec_log_get(), &lpSession, "PST importer", PROJECT_SVN_REV_STR, convert_to<std::wstring>(username).c_str(), L"", "default:");
	506	if(hr != hrSuccess) {
	507	wcerr << "Unable to open MAPI session\n";
	508	return 1;
	509	}
	510
	511	if(libpff_file_get_message_store(file, &pff_store_item, &error) != 1) {
	512	wcerr << "Unable to get store item\n";
	513	hr = MAPI_E_NOT_FOUND;
	514	goto exit;
	515	}
	516
	517	if(libpff_file_get_root_folder(file, &pff_root_item, &error) != 1) {
	518	wcerr << "Unable to get root folder\n";
	519	hr = MAPI_E_NOT_FOUND;
	520	goto exit;
	521	}
	522
	523	hr = HrOpenDefaultStore(lpSession, &lpStore);
	524	if(hr != hrSuccess) {
	525	wcerr << "Unable to get default store\n";
	526	goto exit;
	527	}
	528
	529	hr = HrGetOneProp(lpStore, PR_IPM_SUBTREE_ENTRYID, &lpPropIPM);
	530	if(hr != hrSuccess) {
	531	wcerr << "Unable to get ipm subtree root\n";
	532	goto exit;
	533	}
	534
	535	hr = lpStore->OpenEntry(lpPropIPM->Value.bin.cb, (LPENTRYID)lpPropIPM->Value.bin.lpb, NULL, MAPI_MODIFY, &ulType, (IUnknown **)&lpFolder);
	536	if(hr != hrSuccess) {
	537	wcerr << "Unable to open ipm subtree\n";
	538	goto exit;
	539	}
	540
	541	hr = dump_store(file, pff_store_item, pff_root_item, lpFolder);
	542	if(hr != hrSuccess) {
	543	wcerr << "Import failed\n";
	544	goto exit;
	545	}
	546
	547	wcerr << "Import complete\n";
	548
	549	exit:
	550	if(pff_root_item)
	551	libpff_item_free(&pff_root_item, &error);
	552
	553	if(pff_store_item)
	554	libpff_item_free(&pff_store_item, &error);
	555
	556	if(file) {
	557	libpff_file_close(file, &error);
	558	libpff_file_free(&file, &error);
	559	}
	560
	561	}
	562	MAPIUninitialize();
	563
	564	return hr == hrSuccess ? 0 : 2;
	565	}

+7

-2

ECtools/search/Makefile.am less more

8	8	kopano_search/xmltotext.xslt
9	9
10	10	install-exec-local:
11		cd ${srcdir} && ${PYTHON} setup.py install -f \
12		$${DESTDIR+--root=${DESTDIR}} \
	11	cd ${srcdir} && ${PYTHON} setup.py \
	12	build --build-base="${abs_builddir}/build" \
	13	install -f $${DESTDIR+--root=${DESTDIR}} \
13	14	--prefix="${prefix}" --install-purelib ${pythondir}
14	15	rm -Rf build
15	16
16	17	install-data-local:
17	18	mkdir -p "${DESTDIR}${localstatedir}/lib/kopano/search"
	19
	20	uninstall-local:
	21	rm -Rf ${DESTDIR}${pythondir}/kopano_search \
	22	${DESTDIR}${pythondir}/kopano_search-0*.egg-info

+7

-2

ECtools/search/kopano_search/plugin_xapian.py less more

59	59
60	60	db = self.open_db(server_guid, store_guid, log=log)
61	61	if not db:
62		return [], ''
	62	return []
	63
63	64	qp = xapian.QueryParser()
64	65	qp.add_prefix("sourcekey", "XK:")
65	66	qp.add_prefix("folderid", "XF:")

80	81	def suggest(self, server_guid, store_guid, terms, orig, log):
81	82	""" update original search text with suggested terms """
82	83
83		with closing(self.open_db(server_guid, store_guid)) as db:
	84	db = self.open_db(server_guid, store_guid, log=log)
	85	if not db:
	86	return orig
	87
	88	with closing(db) as db:
84	89	# XXX revisit later. looks like xapian cannot do this for us? :S
85	90	for term in sorted(terms, key=lambda s: len(s), reverse=True):
86	91	suggestion = db.get_spelling_suggestion(term).decode('utf8') or term

+6

-25

Makefile.am less more

10	10	endif
11	11	SUBDIRS += ECtools spooler gateway caldav installer po doc swig
12	12
13		#EXTRA_DIST = version php-webclient-ajax
14		EXTRA_DIST = version versionheader.sh php-webclient-ajax \
15		LICENSE.txt CONTRIBUTORS.txt AGPL-3 \
	13	EXTRA_DIST = version versionheader.sh \
	14	LICENSE.txt AGPL-3 \
16	15	lddcheck global.am pwdcheck.sh
17	16
18	17	BUILT_SOURCES = source-moved-check common/include/kopano/ecversion.h
19	18
20		sbin_SCRIPTS = tools/python-scripts/kopano-cachestat.py
	19	dist_sbin_SCRIPTS = tools/python-scripts/kopano-cachestat.py
21	20	gdbautoloaddir = ${datadir}/gdb/auto-load/${libdir}
22		gdbautoload_DATA = tools/libmapi.so.1.0.0-gdb.py
	21	dist_gdbautoload_DATA = tools/libmapi.so.1.0.0-gdb.py
	22
	23	DISTCHECK_CONFIGURE_FLAGS = --with-dcprefix='$${prefix}'
23	24
24	25	.PHONY: source-moved-check
25	26	source-moved-check:

31	32	dist-hook:
32	33	find $(distdir) -type d -name .svn -exec rm -rf {} \; 2>/dev/null \|\| true
33	34
34		install-ajax-webaccess:
35		install -d -m 755 $(DESTDIR)/usr/share
36		cp -a $(top_srcdir)/php-webclient-ajax $(DESTDIR)/usr/share/kopano-webaccess
37		rm -rf $(DESTDIR)/usr/share/kopano-webaccess/plugins
38		install -d -m 755 $(DESTDIR)/var/lib/kopano-webaccess/plugins
39		install -d -m 755 $(DESTDIR)/var/lib/kopano-webaccess/tmp
40		install -d -m 755 $(DESTDIR)/etc/kopano/webaccess-ajax
41		mv $(DESTDIR)/usr/share/kopano-webaccess/config.php.dist $(DESTDIR)/etc/kopano/webaccess-ajax/config.php
42		rm -f $(DESTDIR)/usr/share/kopano-webaccess/debug.php
43		for podir in $(DESTDIR)/usr/share/kopano-webaccess/server/language/*; do \
44		if [ `grep msgstr $$podir/LC_MESSAGES/*po \| grep -v 'msgstr ""' \|wc -l` = 0 ]; then \
45		echo "Remove empty language $$podir"; \
46		rm -rf $$podir; \
47		fi; \
48		done; \
49		for po in $(DESTDIR)/usr/share/kopano-webaccess/server/language//LC_MESSAGES/.po; do \
50		msgfmt -f -v -o $${po%.po}.mo $$po; \
51		rm $$po; \
52		done
53
54	35	default.sym: ${top_builddir}/config.status

+33

-4

RELNOTES.txt less more

0		Release notes for 8.1.0
1		=======================
	0	Release notes for 8.1.0 [2016-10-05]
	1	====================================
2	2	Fixes:
3	3	* server: A fast-growing memory leak was resolved [KC-12]
4	4	* sql schema: all PRIMARY keys need to be NOT NULL, otherwise a UNIQUE
5	5	key would be required. / MySQL 5.7 support [KC-2]
6		* server: avoid "netlink: 4 bytes leftover" in dmesg
	6	* server: avoid "netlink: 4 bytes leftover" in dmesg [KC-82]
7	7	* ldapplugin: hopefully avoid "Timed out" errors from ldap_search [KC-74]
8	8	* swig: resolve a memory leak when using python components [KC-72]
9	9	* server: better guard against off-size EntryIDs [KC-60]

11	11	* backup: restore container classes [KC-22]
12	12	* all daemons: fixed coredumps not getting generated most of the time [KC-61]
13	13	* all: issue setgroups(2) before setuid(2) [KC-37]
	14	* server: avoid infinite do-nothing loop if tmp_path is unwritable [KC-77]
	15	* backup: users without a store are now ignored [KC-78]
	16	* kopano-mailbox-permissions: resolve a crash involving Unicode [KC-100]
	17	* inetmapi: Message-Id was truncated on send [KC-101]
	18	* inetmapi: character set was ignored when reading TNEF mails
	19	(mails with a winmail.dat part/attachment) [KC-83]
	20	* python: avoid terminal exception when handling a date past year 9999 [KC-184]
	21	* caldav: Lightning workaround is not to apply to Apple mail client [KC-145]
	22	* search: continue even if xapian db cannot be opened [KC-174]
	23	* search: cure an infinite loop [KC-157]
	24	* backup: miscellaneous [KC-161, KC-162, KC-192]
	25	* init: classic init scripts showed wrong status for python daemons [KC-220]
14	26	Enhancements:
15		* PHP7 support
16	27	* server: add ICS log messages [KC-18]
17	28	* server: ship example config files for ldap multi-server [KC-65]
18	29	* server: speed up REPLACE-type sql queries [KC-58]
19	30	* server: speed up login phase by caching PR_LOGON_TIME [KC-6]
	31	* server: indexing of junk folders can be controlled now [KC-17]
	32	* server: warn about on-disk attachments that have wrong metadata [KC-104]
20	33	* libicalmapi: improve fallback scenario to server_timezone in ical.cfg [KC-11]
	34	* tools: add an SPropValue pretty printer for use with gdb
	35	* `systemctl reload` for kopano services is now usable where supported [KC-71]
	36	* RHEL(6) initscripts did not cope with python daemons well [KC-96]
	37	* backup: add option to skip broken attachments [KC-45]
	38	* spooler: rule name is now logged [KC-102]
	39	* archiver: new scripts kopano-archiver-{aclsync,aclset,restore} [KC-39]
	40	* python/swig: resolve some memory leaks [KC-92, KC-95]
	41	* client: permit self-signed certificates [KC-155]
	42	* Add scripts (source tarball only) to inspect/delete stale search folders
	43	which slow down kopano-server startup and message modification when too many
	44	have accumulated [KC-140]
	45	* server: the allocator library is now switchable [KC-191, KC-216],
	46	there is a new option "allocator_library" in server.cfg to control it.
	47	* Initial PHP7 support [KC-130, KC-131, KC-134, KC-158]
	48	(not complete for Z-Push yet)
21	49	Changes:
22	50	* search: no longer do indexing on root and Draft folders [KC-57]
23	51	* search: index junk folders, but skip updating suggestion list [KC-57]
24	52	* Python 2.5 support is removed
	53	* server: libs3 is now dlopened to workaround libldap effects [KC-64]

+3

-46

caldav/CalDAV.cpp less more

18	18	#include <kopano/platform.h>
19	19	#include <climits>
20	20	#include "mapidefs.h"
21		#include <kopano/ECChannel.h>
22	21	#include <mapix.h>
23	22	#include <kopano/MAPIErrors.h>
24	23	#include "Http.h"

43	42
44	43	using namespace std;
45	44
46		#ifdef LINUX
47	45	#include <execinfo.h>
48	46	#include <kopano/UnixUtil.h>
49		#endif
50
51	47	#ifdef ZCP_USES_ICU
52	48	#include <unicode/uclean.h>
53	49	#endif
54
55
56		#ifdef _DEBUG
57		#define new DEBUG_NEW
58		#endif
59
60	50
61	51	struct HandlerArgs {
62	52	ECChannel *lpChannel;

87	77
88	78	static void sighup(int)
89	79	{
90		// In Win32, the signal is sent in a separate, special signal thread. So this test is
91		// not needed or required.
92		#ifdef LINUX
93	80	if (g_bThreads && pthread_equal(pthread_self(), mainthread)==0)
94	81	return;
95		#endif
96	82	if (g_lpConfig) {
97	83	if (!g_lpConfig->ReloadSettings() && g_lpLogger)
98	84	g_lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to reload configuration file, continuing with current settings.");

110	96	}
111	97	}
112	98
113
114		#ifdef LINUX
115	99	static void sigchld(int)
116	100	{
117	101	int stat;

124	108	generic_sigsegv_handler(g_lpLogger, "CalDAV",
125	109	PROJECT_VERSION_GATEWAY_STR, signr, si, uc);
126	110	}
127		#endif
128	111
129	112	static void PrintHelp(const char *name)
130	113	{

142	125	cout << "Product version:\t" << PROJECT_VERSION_CALDAV_STR << endl << "File version:\t\t" << PROJECT_SVN_REV_STR << endl;
143	126	}
144	127
145
146	128	int main(int argc, char **argv) {
147	129	HRESULT hr = hrSuccess;
148	130	int ulListenCalDAV = 0;
149	131	int ulListenCalDAVs = 0;
150	132	bool bIgnoreUnknownConfigOptions = false;
151
152		#ifdef LINUX
153	133	stack_t st = {0};
154	134	struct sigaction act = {{0}};
155		#endif
156	135
157	136	// Configuration
158	137	int opt = 0;
159	138	const char *lpszCfg = ECConfig::GetDefaultPath("ical.cfg");
160	139	static const configsetting_t lpDefaults[] = {
161		#ifdef LINUX
162	140	{ "run_as_user", "kopano" },
163	141	{ "run_as_group", "kopano" },
164	142	{ "pid_file", "/var/run/kopano/ical.pid" },
165	143	{ "running_path", "/var/lib/kopano" },
166	144	{ "process_model", "fork" },
167		#endif
168	145	{ "server_bind", "" },
169	146	{ "ical_port", "8080" },
170	147	{ "ical_enable", "yes" },

175	152	{ "server_timezone","Europe/Amsterdam"},
176	153	{ "default_charset","utf-8"},
177	154	{ "log_method", "file" },
178		#ifdef LINUX
179	155	{ "log_file", "/var/log/kopano/ical.log" },
180		#else
181		{ "log_file", "ical.log" },
182		#endif
183	156	{ "log_level", "3", CONFIGSETTING_RELOADABLE },
184	157	{ "log_timestamp", "1" },
185	158	{ "log_buffer_size", "0" },
186		#ifdef LINUX
187	159	{ "ssl_private_key_file", "/etc/kopano/ical/privkey.pem" },
188	160	{ "ssl_certificate_file", "/etc/kopano/ical/cert.pem" },
189		#else
190		{ "ssl_private_key_file", "privkey.pem" },
191		{ "ssl_certificate_file", "cert.pem" },
192		#endif
193	161	{ "ssl_protocols", "!SSLv2" },
194	162	{ "ssl_ciphers", "ALL:!LOW:!SSLv2:!EXP:!aNULL" },
195	163	{ "ssl_prefer_server_ciphers", "no" },

275	243	if (hr != hrSuccess)
276	244	goto exit;
277	245
278
279	246	// setup signals
280	247	signal(SIGTERM, sigterm);
281	248	signal(SIGINT, sigterm);
282		#ifdef LINUX
283	249	signal(SIGHUP, sighup);
284	250	signal(SIGCHLD, sigchld);
285	251	signal(SIGPIPE, SIG_IGN);

313	279	else
314	280	g_lpLogger->SetLogprefix(LP_TID);
315	281	ec_log_set(g_lpLogger);
316		#endif
	282
317	283	hr = MAPIInitialize(NULL);
318	284	if (hr != hrSuccess) {
319	285	fprintf(stderr, "Messaging API could not be initialized: %s (%x)",

330	296	if (hr != hrSuccess)
331	297	goto exit2;
332	298
333
334	299	g_lpLogger->Log(EC_LOGLEVEL_ALWAYS, "CalDAV Gateway will now exit");
335	300
336		#ifdef LINUX
337	301	// in forked mode, send all children the exit signal
338	302	if (g_bThreads == false) {
339	303	int i;

353	317	else
354	318	g_lpLogger->Log(EC_LOGLEVEL_ALWAYS, "CalDAV Gateway shutdown complete");
355	319	}
356		#endif
357
358	320	exit2:
359	321	MAPIUninitialize();
360	322	exit:
361
362		#ifdef LINUX
363	323	free(st.ss_sp);
364		#endif
365
366	324	ECChannel::HrFreeCtx();
367	325	delete g_lpConfig;
368	326	DeleteLogger(g_lpLogger);
369
370	327
371	328	SSL_library_cleanup(); // Remove ssl data for the main application and other related libraries
372	329

396	353	int ulSecureSocket = 0;
397	354
398	355	// setup sockets
399		bListenSecure = (stricmp(g_lpConfig->GetSetting("icals_enable"), "yes") == 0);
400		bListen = (stricmp(g_lpConfig->GetSetting("ical_enable"), "yes") == 0);
	356	bListenSecure = (strcasecmp(g_lpConfig->GetSetting("icals_enable"), "yes") == 0);
	357	bListen = (strcasecmp(g_lpConfig->GetSetting("ical_enable"), "yes") == 0);
401	358
402	359	if (!bListen && !bListenSecure) {
403	360	g_lpLogger->Log(EC_LOGLEVEL_FATAL, "No ports to open for listening.");

+2

-15

caldav/CalDavProto.cpp less more

21	21	#include <kopano/MAPIErrors.h>
22	22
23	23	using namespace std;
24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28
29	24
30	25	/**
31	26	* Maping of caldav properties to Mapi properties

98	93	}
99	94
100	95	/**
101		* Default constructor
102	96	* @param[in] lpRequest Pointer to Http class object
103	97	* @param[in] lpSession Pointer to Mapi session object
104	98	* @param[in] lpLogger Pointer to ECLogger object

345	339	goto exit;
346	340	}
347	341
348
349	342	// restrict on meeting requests and appointments
350	343	CREATE_RESTRICTION(lpsRestriction);
351	344	CREATE_RES_OR(lpsRestriction, lpsRestriction, 3);

394	387	m_lpLogger->Log(EC_LOGLEVEL_ERROR, "Unable to receive folder properties, error 0x%08X %s", hr, GetMAPIErrorMessage(hr));
395	388	goto exit;
396	389	}
397
398	390
399	391	// @todo, add "start time" property and recurrence data to table and filter in loop
400	392	// if lpsWebRCalQry->sFilter.tStart is set.

897	889	return hr;
898	890	}
899	891
900
901	892	/**
902	893	* Function moves a folder or message to the deleted items folder
903	894	* @note does not check if-match: if you had a message modified which you now want to delete, we delete anyway

924	915	bool bisFolder = false;
925	916	SizedSPropTagArray(3, lpPropTagArr) = {3, {PR_ENTRYID, PR_LAST_MODIFICATION_TIME, PR_DISPLAY_NAME_W}};
926	917
927
928	918	m_lpRequest->HrGetUrl(&strUrl);
929	919	bisFolder = m_ulUrlFlag & REQ_COLLECTION;
930	920

1434	1424	sPropValSet[1].ulPropTag = PR_COMMENT_A;
1435	1425	sPropValSet[1].Value.lpszA = const_cast<char *>("Created by CalDAV Gateway");
1436	1426
1437		hr = lpUsrFld->SetProps(2, (LPSPropValue)&sPropValSet, NULL);
	1427	hr = lpUsrFld->SetProps(2, sPropValSet, NULL);
1438	1428	if (hr != hrSuccess) {
1439	1429	m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "CalDAV::HrHandleMkCal SetProps failed: 0x%x %s", hr, GetMAPIErrorMessage(hr));
1440	1430	goto exit;

1503	1493	else
1504	1494	strReqUrl = "/caldav/public/";
1505	1495
1506
1507	1496	// all folder properties to fill request.
1508	1497	cbsize = lpsDavProp->lstProps.size() + 2;
1509	1498

1523	1512	iter = lpsDavProp->lstProps.begin();
1524	1513	for (int i = 2; iter != lpsDavProp->lstProps.end(); ++iter, ++i)
1525	1514	lpPropTagArr->aulPropTag[i] = GetPropIDForXMLProp(m_lpUsrFld, iter->sPropName, m_converter);
1526
1527	1515
1528	1516	if (m_ulFolderFlag & SINGLE_FOLDER)
1529	1517	{

2129	2117	HrGetOneProp(m_lpActiveUser, PR_SMTP_ADDRESS_A, &ptrEmail);
2130	2118	HrGetOneProp(m_lpActiveUser, PR_DISPLAY_NAME_W, &ptrFullname);
2131	2119
2132
2133	2120	// owner is DAV namespace, the owner of the resource (url)
2134	2121	strOwnerURL = "/caldav/" + urlEncode(m_wstrFldOwner, "utf-8") + "/";
2135	2122	strCurrentUserURL = "/caldav/" + urlEncode(m_wstrUser, "utf-8") + "/";

2324	2311	// do not set on public, so thunderbird/lightning doesn't require calendar-user-address-set, schedule-inbox-URL and schedule-outbox-URL
2325	2312	// public doesn't do meeting requests
2326	2313	// check here, because lpFoundProp is set to display name and isn't binary
2327		if ((m_ulUrlFlag & REQ_PUBLIC) == 0) {
	2314	if ((m_ulUrlFlag & REQ_PUBLIC) == 0 \|\| strAgent.find("Lightning") == string::npos) {
2328	2315	// Purpose: Identifies the URL of any WebDAV collections that contain
2329	2316	// calendar collections owned by the associated principal resource.
2330	2317	// apple seems to use this as the root container where you have your calendars (and would create more)

+0

-6

caldav/CalDavUtil.cpp less more

21	21	#include <kopano/mapi_ptr.h>
22	22
23	23	using namespace std;
24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28	24
29	25	/**
30	26	* Open MAPI session

194	190	// we're done either way
195	191	goto exit;
196	192	}
197
198	193
199	194	hr = lpRootFolder->GetHierarchyTable(CONVENIENT_DEPTH, &lpHichyTable);
200	195	if(hr != hrSuccess)

850	845	hr = lpAddrBook->OpenEntry(cbEntryId, ptrEntryId, NULL, 0, &ulObj, &ptrABDir);
851	846	if (hr != hrSuccess)
852	847	goto exit;
853
854	848
855	849	cUsers = lplstUsers->size();
856	850

+2

-10

caldav/Http.cpp less more

22	22	#include <kopano/ECConfig.h>
23	23
24	24	using namespace std;
25
26		#ifdef _DEBUG
27		#define new DEBUG_NEW
28		#endif
29	25
30	26	/**
31	27	* Parse the incoming URL into known pieces:

133	129	m_ulRetCode = 0;
134	130	}
135	131
136		/**
137		* Default destructor
138		*/
139	132	Http::~Http()
140	133	{
141	134	m_lpLogger->Release();

211	204	{
212	205	HRESULT hr;
213	206	std::string strAuthdata;
214		std::string strLength;
215	207	std::string strUserAgent;
216	208
217	209	std::vector<std::string> items;

390	382	}
391	383
392	384	/**
393		* Checks the etag of a MAPI object agains If-(None)-Match headers
	385	* Checks the etag of a MAPI object against If-(None)-Match headers
394	386	*
395	387	* @param[in] lpProp Object to check etag (PR_LAST_MODIFICATION_TIME) to
396	388	*

791	783	strftime(lpszChar, 127, "%a, %d %b %Y %H:%M:%S GMT", gmtime_safe(&tmCurrenttime, &dummy));
792	784
793	785	HrResponseHeader("Date", lpszChar);
794		if (m_ulKeepAlive != 0 && stricmp(strConnection.c_str(), "keep-alive") == 0) {
	786	if (m_ulKeepAlive != 0 && strcasecmp(strConnection.c_str(), "keep-alive") == 0) {
795	787	HrResponseHeader("Connection", "Keep-Alive");
796	788	HrResponseHeader("Keep-Alive", stringify(m_ulKeepAlive, false));
797	789	}

+1

-0

caldav/Makefile.am less more

8	8
9	9	sbin_PROGRAMS = kopano-ical
10	10	noinst_DATA = kopano-ical.ldx
	11	CLEANFILES = ${noinst_DATA}
11	12
12	13	kopano_ical_SOURCES = CalDAV.cpp \
13	14	CalDavProto.cpp CalDavProto.h \

+0

-5

caldav/ProtocolBase.cpp less more

83	83	HRESULT hr = hrSuccess;
84	84	std::string strUrl;
85	85	std::string strMethod;
86		std::string strAgent;
87	86	string strFldOwner;
88	87	string strFldName;
89	88	LPSPropValue lpDefaultProp = NULL;

175	174	if(hr != hrSuccess)
176	175	goto exit;
177	176
178
179	177	/*
180	178	* Set m_lpIPMSubtree, used for CopyFolder, CreateFolder, DeleteFolder
181	179	*/

185	183	m_lpLogger->Log(EC_LOGLEVEL_ERROR, "Error opening IPM SUBTREE, using user %ls, error code : 0x%08X", m_wstrUser.c_str(), hr);
186	184	goto exit;
187	185	}
188
189	186
190	187	// Get active store default calendar to prevent delete action on this folder
191	188	hr = m_lpActiveStore->OpenEntry(0, NULL, NULL, 0, &ulType, &lpRoot);

261	258	}
262	259	}
263	260
264
265	261	/*
266	262	* Workaround for old users with sunbird / lightning on old url base.
267	263	*/

324	320	m_blFolderAccess = false;
325	321	}
326	322
327
328	323	exit:
329	324	MAPIFreeBuffer(lpFldProp);
330	325	MAPIFreeBuffer(lpDefaultProp);

+2

-0

caldav/ProtocolBase.h less more

61	61	std::string W2U(const WCHAR* lpwWideChar);
62	62	std::wstring U2W(const std::string&); //!< convert utf-8 to widestring
63	63	std::string SPropValToString(SPropValue * lpSprop);
	64
	65	std::string strAgent;
64	66	};
65	67
66	68	#endif

+3

-13

caldav/WebDav.cpp less more

22	22
23	23	using namespace std;
24	24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28
29		/**
30		* Default constructor
	25	/**
31	26	* @param[in] lpRequest Pointer to http Request object
32	27	* @param[in] lpSession Pointer to mapi session of the user
33	28	* @param[in] lpLogger Pointer to logger object to log errors and information

37	32	m_lpXmlDoc = NULL;
38	33	}
39	34
40		/**
41		* Default Destructor
42		*/
43	35	WebDav::~WebDav()
44	36	{
45	37	if (m_lpXmlDoc)

147	139	hr = RespStructToXml(&sDavMStatus, &strXml);
148	140	if (hr != hrSuccess)
149	141	{
150		m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Unable to convert reponse to xml: 0x%08X", hr);
	142	m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Unable to convert response to xml: 0x%08X", hr);
151	143	goto exit;
152	144	}
153	145

167	159
168	160	return hr;
169	161	}
170
171	162
172	163	/**
173	164	* Converts WEBDAVMULTISTATUS response structure to xml data

967	958	{
968	959	HRESULT hr;
969	960	WEBDAVRESPONSE sWebResp;
970		std::string strNsPrefix;
971	961	std::list<WEBDAVPROPSTAT>::const_iterator iterPropStat;
972	962	std::list<WEBDAVPROPERTY>::const_iterator iterProperty;
973	963	int ulRet;

1401	1391	hr = RespStructToXml(&sDavMStatus, &strXml);
1402	1392	if (hr != hrSuccess)
1403	1393	{
1404		m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Unable to convert reponse to xml: 0x%08X", hr);
	1394	m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Unable to convert response to xml: 0x%08X", hr);
1405	1395	goto exit;
1406	1396	}
1407	1397

+0

-1

caldav/WebDav.h less more

20	20	#include <libxml/tree.h>
21	21	#include <libxml/xmlwriter.h>
22	22	#include <libxml/parser.h>
23		#include <libxml/tree.h>
24	23
25	24	#include <mapi.h>
26	25	#include <map>

+0

-8

caldav/iCal.cpp less more

32	32
33	33	using namespace std;
34	34
35		#ifdef _DEBUG
36		#define new DEBUG_NEW
37		#endif
38
39		/**
40		* Default constructor
41		*/
42	35	iCal::iCal(Http lpRequest, IMAPISession lpSession, ECLogger *lpLogger, std::string strSrvTz, std::string strCharset) : ProtocolBase(lpRequest, lpSession, lpLogger, strSrvTz, strCharset)
43	36	{
44	37	}

171	164
172	165	map<std::string, int>::const_iterator mpIterI;
173	166	map<std::string,SBinary>::const_iterator mpIterJ;
174
175	167
176	168	ulProptag = CHANGE_PROP_TYPE(m_lpNamedProps->aulPropTag[PROP_GOID], PT_BINARY);
177	169	cValues = 3;

+5

-6

common/ConsoleTable.cpp less more

198	198	*/
199	199	void ConsoleTable::PrintTable()
200	200	{
201		size_t nRow, nCol;
202		size_t total;
203
204	201	if (bHaveHeader) {
205	202	PrintRow(m_vHeader);
206		total = 0;
207		for (nCol = 0; nCol < m_iColumns; ++nCol)
	203	size_t total = 0;
	204
	205	for (size_t nCol = 0; nCol < m_iColumns; ++nCol)
208	206	total += m_vMaxLengths[nCol];
	207
209	208	total += (m_iColumns -1) * 8;
210	209	cout << "\t" << string(total, '-') << endl;
211	210	}
212	211
213		for (nRow = 0; nRow < m_nRow; ++nRow)
	212	for (size_t nRow = 0; nRow < m_nRow; ++nRow)
214	213	PrintRow(m_vTable[nRow]);
215	214	}
216	215

+0

-4

common/ECABEntryID.cpp less more

19	19	#include <kopano/ECGuid.h>
20	20
21	21	#include <mapicode.h>
22
23		#ifdef _DEBUG
24		#define new DEBUG_NEW
25		#endif
26	22
27	23	/* This is a copy from the definition in kcore.hpp. It's for internal use only as we
28	24	* don't want to expose the format of the entry id. */

+0

-5

common/ECCache.cpp less more

20	20	#include "ECCache.h"
21	21	#include <kopano/ECLogger.h>
22	22	#include <kopano/stringutil.h>
23
24		#ifdef _DEBUG
25		#define new DEBUG_NEW
26		#endif
27
28	23
29	24	ECCacheBase::ECCacheBase(const std::string &strCachename, size_type ulMaxSize, long lMaxAge)
30	25	: m_strCachename(strCachename)

+9

-18

common/ECChannel.cpp less more

19	19	#include <kopano/ECChannel.h>
20	20	#include <kopano/stringutil.h>
21	21	#include <csignal>
22		#ifdef LINUX
23	22	#include <netdb.h>
24	23	#include <sys/types.h>
25	24	#include <sys/select.h>

29	28	#include <netinet/in.h>
30	29	#include <netinet/tcp.h>
31	30	#include <arpa/inet.h>
	31	#ifdef LINUX
32	32	#include <linux/rtnetlink.h>
33	33	#endif
34	34
35	35	#include <cerrno>
36	36	#include <mapicode.h>
37
38		#ifdef _DEBUG
39		#define new DEBUG_NEW
40		#endif
41
42	37
43	38	#ifndef hrSuccess
44	39	#define hrSuccess 0

99	94	ssl_neg = true;
100	95	}
101	96
102		if (strcmp_ci(ssl_name, SSL_TXT_SSLV2) == 0)
	97	if (strcasecmp(ssl_name, SSL_TXT_SSLV2) == 0)
103	98	ssl_proto = 0x01;
104		else if (strcmp_ci(ssl_name, SSL_TXT_SSLV3) == 0)
	99	else if (strcasecmp(ssl_name, SSL_TXT_SSLV3) == 0)
105	100	ssl_proto = 0x02;
106		else if (strcmp_ci(ssl_name, SSL_TXT_TLSV1) == 0)
	101	else if (strcasecmp(ssl_name, SSL_TXT_TLSV1) == 0)
107	102	ssl_proto = 0x04;
108	103	#ifdef SSL_TXT_TLSV1_1
109		else if (strcmp_ci(ssl_name, SSL_TXT_TLSV1_1) == 0)
	104	else if (strcasecmp(ssl_name, SSL_TXT_TLSV1_1) == 0)
110	105	ssl_proto = 0x08;
111	106	#endif
112	107	#ifdef SSL_TXT_TLSV1_2
113		else if (strcmp_ci(ssl_name, SSL_TXT_TLSV1_2) == 0)
	108	else if (strcasecmp(ssl_name, SSL_TXT_TLSV1_2) == 0)
114	109	ssl_proto = 0x10;
115	110	#endif
116	111	else {

243	238	SSL_free(lpSSL);
244	239	lpSSL = NULL;
245	240	}
246		closesocket(fd);
	241	close(fd);
247	242	}
248	243
249	244	HRESULT ECChannel::HrEnableTLS(ECLogger *const lpLogger) {

510	505	int res = 0;
511	506	struct timeval timeout = { seconds, 0 };
512	507
513		#ifdef LINUX
514	508	if(fd >= FD_SETSIZE)
515	509	return MAPI_E_NOT_ENOUGH_MEMORY;
516		#endif
517	510	if(lpSSL && SSL_pending(lpSSL))
518	511	return hrSuccess;
519	512

818	811
819	812	memset(&sun_addr, 0, sizeof(sun_addr));
820	813	sun_addr.sun_family = AF_UNIX;
821		strncpy(sun_addr.sun_path, szPath, sizeof(sun_addr.sun_path));
	814	kc_strlcpy(sun_addr.sun_path, szPath, sizeof(sun_addr.sun_path));
822	815
823	816	if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1) {
824	817	if (lpLogger)

835	828	if (bind(fd, (struct sockaddr *)&sun_addr, sizeof(sun_addr)) == -1) {
836	829	if (lpLogger)
837	830	lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to bind to socket %s (%s). This is usually caused by another process (most likely another kopano-server) already using this port. This program will terminate now.", szPath, strerror(errno));
838		#ifdef LINUX
839	831	kill(0, SIGTERM);
840		#endif
841	832	exit(1);
842	833	}
843	834

975	966	if (sock_res != NULL)
976	967	freeaddrinfo(sock_res);
977	968	if (hr != hrSuccess && fd >= 0)
978		closesocket(fd);
	969	close(fd);
979	970	return hr;
980	971	}
981	972

+7

-7

common/ECChannelClient.cpp less more

20	20	#include <mapidefs.h>
21	21	#include <mapiutil.h>
22	22	#include <mapix.h>
23
24		#ifdef LINUX
25	23	#include <netdb.h>
26	24	#include <arpa/inet.h>
27	25	#include <netinet/in.h>
28	26	#include <sys/un.h>
29	27	#include <sys/socket.h>
30		#endif
31
32	28	#include <kopano/base64.h>
33	29	#include <kopano/ECChannel.h>
34	30	#include <kopano/ECDefs.h>

132	128
133	129	exit:
134	130	if (er != erSuccess && fd != -1)
135		closesocket(fd);
	131	close(fd);
136	132
137	133	return er;
138	134	}

161	157	fd = socket(sock_addr->ai_family, sock_addr->ai_socktype,
162	158	sock_addr->ai_protocol);
163	159	if (fd < 0)
	160	/* Socket type could not be created */
164	161	continue;
165	162
166	163	if (connect(fd, sock_addr->ai_addr,
167	164	sock_addr->ai_addrlen) < 0) {
	165	/* No route */
168	166	int saved_errno = errno;
169		closesocket(fd);
	167	close(fd);
170	168	fd = -1;
171	169	errno = saved_errno;
172	170	continue;
173	171	}
	172	/* Good connected socket, use it */
	173	break;
174	174	}
175	175	if (fd < 0) {
176	176	er = KCERR_NETWORK_ERROR;

187	187	if (sock_res != NULL)
188	188	freeaddrinfo(sock_res);
189	189	if (er != erSuccess && fd != -1)
190		closesocket(fd);
	190	close(fd);
191	191
192	192	return er;
193	193	}

+0

-5

common/ECConfig.cpp less more

18	18	#include "ECConfigImpl.h"
19	19	#include <kopano/charset/convert.h>
20	20
21		#ifdef _DEBUG
22		#define new DEBUG_NEW
23		#endif
24
25	21	ECConfig ECConfig::Create(const configsetting_t lpDefaults,
26	22	const char const lpszDirectives)
27	23	{

33	29	convert_context converter;
34	30	return LoadSettings(converter.convert_to<char*>(szFilename));
35	31	}
36
37	32
38	33	/**
39	34	* Get the default path for the configuration file specified with lpszBasename.

+2

-12

common/ECConfigImpl.cpp less more

21	21	#include <cstdlib>
22	22	#include <algorithm>
23	23	#include <cassert>
24		#ifdef LINUX
25	24	#include <climits>
26		#endif
27
28		#include <algorithm>
29	25	#include <kopano/stringutil.h>
30	26	#include "ECConfigImpl.h"
31	27

33	29	#include <kopano/boost_compat.h>
34	30
35	31	using namespace std;
36
37		#ifdef _DEBUG
38		#define new DEBUG_NEW
39		#endif
40	32
41	33	#include <boost/filesystem.hpp>
42	34	namespace fs = boost::filesystem;

509	501	return true;
510	502	}
511	503
512
513	504	bool ECConfigImpl::HandleInclude(const char *lpszArgs, unsigned int ulFlags)
514	505	{
515	506	string strValue;

542	533	return false;
543	534
544	535	memset(lpsKey, 0, sizeof(*lpsKey));
545		strncpy(lpsKey->s, lpsSetting->szName, sizeof(lpsKey->s));
	536	kc_strlcpy(lpsKey->s, lpsSetting->szName, sizeof(lpsKey->s));
546	537	lpsKey->ulFlags = lpsSetting->ulFlags;
547	538	lpsKey->ulGroup = lpsSetting->ulGroup;
548	539

578	569	if (szAlias) {
579	570	if (!(ulFlags & LOADSETTING_INITIALIZING))
580	571	warnings.push_back("Option '" + string(lpsConfig->szName) + "' is deprecated! New name for option is '" + szAlias + "'.");
581		strncpy(s.s, szAlias, sizeof(s.s));
	572	kc_strlcpy(s.s, szAlias, sizeof(s.s));
582	573	}
583	574
584	575	pthread_rwlock_wrlock(&m_settingsRWLock);

785	776	return true;
786	777	}
787	778
788
789	779	void ECConfigImpl::WriteLinesToFile(const char* szName, const char* szValue, ifstream& in, ofstream& out, bool bWriteAll)
790	780	{
791	781	string strLine;

+3

-12

common/ECDatabaseMySQL.cpp less more

26	26	#include <mapidefs.h>
27	27	#include <kopano/CommonUtil.h>
28	28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32	29	#ifdef DEBUG
33	30	#define DEBUG_SQL 0
34	31	#define DEBUG_TRANSACTION 0

399	396	return (unsigned int)mysql_num_rows((MYSQL_RES *)sResult);
400	397	}
401	398
402		unsigned int ECDatabaseMySQL::GetNumRowFields(DB_RESULT sResult) {
403
404		return mysql_num_fields((MYSQL_RES *)sResult);
405		}
406
407	399	DB_ROW ECDatabaseMySQL::FetchRow(DB_RESULT sResult) {
408	400
409	401	return mysql_fetch_row((MYSQL_RES *)sResult);

508	500	}
509	501
510	502	while ((lpDBRow = FetchRow(lpResult)) != NULL) {
511		if (stricmp(lpDBRow[0], "InnoDB") != 0)
	503	if (strcasecmp(lpDBRow[0], "InnoDB") != 0)
512	504	continue;
513	505
514		if (stricmp(lpDBRow[1], "DISABLED") == 0) {
	506	if (strcasecmp(lpDBRow[1], "DISABLED") == 0) {
515	507	// mysql has run with innodb enabled once, but disabled this.. so check your log.
516	508	m_lpLogger->Log(EC_LOGLEVEL_FATAL, "INNODB engine is disabled. Please re-enable the INNODB engine. Check your MySQL log for more information or comment out skip-innodb in the mysql configuration file.");
517	509	er = KCERR_DATABASE_ERROR;
518	510	goto exit;
519		} else if (stricmp(lpDBRow[1], "YES") != 0 && stricmp(lpDBRow[1], "DEFAULT") != 0) {
	511	} else if (strcasecmp(lpDBRow[1], "YES") != 0 && strcasecmp(lpDBRow[1], "DEFAULT") != 0) {
520	512	// mysql is incorrectly configured or compiled.
521	513	m_lpLogger->Log(EC_LOGLEVEL_FATAL, "INNODB engine is not supported. Please enable the INNODB engine in the mysql configuration file.");
522	514	er = KCERR_DATABASE_ERROR;

544	536	const char *lpDatabase = lpConfig->GetSetting("mysql_database");
545	537	const char *lpMysqlPort = lpConfig->GetSetting("mysql_port");
546	538	const char *lpMysqlSocket = lpConfig->GetSetting("mysql_socket");
547
548	539
549	540	if(*lpMysqlSocket == '\0')
550	541	lpMysqlSocket = NULL;

+0

-2

common/ECDatabaseMySQL.h less more

62	62
63	63	//Result functions
64	64	unsigned int GetNumRows(DB_RESULT sResult);
65		unsigned int GetNumRowFields(DB_RESULT sResult);
66
67	65	DB_ROW FetchRow(DB_RESULT sResult);
68	66	DB_LENGTHS FetchRowLengths(DB_RESULT sResult);
69	67

+2

-29

common/ECDebug.cpp less more

35	35
36	36	#include "freebusyguid.h"
37	37
38		#include <kopano/stringutil.h>
39
40	38	#include <iostream>
41	39	#include <sstream>
42	40	#include <kopano/mapi_ptr.h>
43	41
44	42	using namespace std;
45	43
46		#ifdef _DEBUG
47		#define new DEBUG_NEW
48		#endif
49
50	44	#define RETURN_ERROR_CASE(x) \
51	45	case x: \
52	46	return (HR_FAILED(x) ? "FAILED: " #x : ((x == hrSuccess) ? #x : "WARNING: " #x));

54	48	#define RETURN_CASE(x) \
55	49	case x: \
56	50	return #x;
57
58	51
59	52	#define RETURN_PROP_CASE(pt) case PROP_ID(pt): return((#pt))
60	53

260	253	{3, (GUID*)&KOPANO_STORE_DELEGATE_GUID, "Kopano Delegate Store"},
261	254	{3, (GUID*)&GUID_NULL , "GUID_NULL"},
262	255
263		#ifndef LINUX
264		{4, (GUID*)&IID_IExternalConnection, "IID_IExternalConnection"},
265		{4, (GUID*)&IID_IMarshal, "IID_IMarshal"},
266		// {4, (GUID*)&IID_IMarshal2, "IID_IMarshal2"},
267		{4, (GUID*)&IID_IMalloc, "IID_IMalloc"},
268		{4, (GUID*)&IID_IStdMarshalInfo, "IID_IStdMarshalInfo"},
269		{4, (GUID*)&IID_IStorage, "IID_IStorage"},
270		{4, (GUID*)&IID_IClassFactory, "IID_IClassFactory"},
271
272		#endif
273	256	{4, (GUID*)&IID_IMSCapabilities, "IID_IMSCapabilities"},
274	257	{4, (GUID*)&IID_IFolderSupport, "IID_IFolderSupport"},
275	258	{4, (GUID*)&IID_IMessageRaw , "IID_IMessageRaw"},

305	288	//End of list
306	289	{0, NULL}
307	290	};
308
309	291
310	292	std::string GetMAPIErrorDescription(HRESULT hResult)
311	293	{

403	385
404	386	char szResult[DEBUGBUFSIZE+1];
405	387
406		_snprintf(szResult, DEBUGBUFSIZE, "0x%08X", hResult);
	388	snprintf(szResult, DEBUGBUFSIZE, "0x%08X", hResult);
407	389
408	390	return szResult;
409	391	}

1117	1099
1118	1100	RETURN_PROP_CASE(PR_AUTO_ADD_NEW_SUBS);
1119	1101	RETURN_PROP_CASE(PR_NEW_SUBS_GET_AUTO_ADD);
1120
1121	1102
1122	1103	RETURN_PROP_CASE(PR_OFFLINE_FLAGS);
1123	1104	RETURN_PROP_CASE(PR_SYNCHRONIZE_FLAGS);

1917	1898	}
1918	1899	}//PropNameFromPropTag
1919	1900
1920
1921	1901	const char *RelationalOperatorToString(ULONG relop)
1922	1902	{
1923	1903	switch(relop) {

2142	2122	}
2143	2123
2144	2124	return strResult;
2145		}
2146
2147		std::string unicodetostr(const wchar_t *lpszW)
2148		{
2149		return convert_to<std::string>(lpszW);
2150	2125	}
2151	2126
2152	2127	std::string PropValueToString(const SPropValue *lpPropValue)

2737	2712	}
2738	2713
2739	2714	if (guidIDD.empty()) {
2740		_snprintf(szGuidId, DEBUGBUFSIZE, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", iid.Data1, iid.Data2, iid.Data3, iid.Data4[0], iid.Data4[1], iid.Data4[2], iid.Data4[3], iid.Data4[4], iid.Data4[5], iid.Data4[6], iid.Data4[7]);
	2715	snprintf(szGuidId, DEBUGBUFSIZE, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", iid.Data1, iid.Data2, iid.Data3, iid.Data4[0], iid.Data4[1], iid.Data4[2], iid.Data4[3], iid.Data4[4], iid.Data4[5], iid.Data4[6], iid.Data4[7]);
2741	2716	guidIDD = "Unknown ";
2742	2717	guidIDD+=szGuidId;
2743	2718	}
2744
2745	2719
2746	2720	return guidIDD;
2747	2721	}

2771	2745	{
2772	2746	std::string str;
2773	2747	ULONG i;
2774
2775	2748
2776	2749	if(ppNames == NULL)
2777	2750	return "NULL";

+0

-6

common/ECDebugPrint.cpp less more

22	22
23	23	using namespace std;
24	24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28
29
30	25	namespace details {
31	26	string conversion_helpers<string>::convert_from(const wstring &s) {
32	27	return convert_to<string>(s);

43	38	const string conversion_helpers<string>::strNULL = "NULL";
44	39	const string conversion_helpers<string>::strCOMMA= ",";
45	40
46
47	41	wstring conversion_helpers<wstring>::convert_from(const string &s) {
48	42	return convert_to<wstring>(s);
49	43	}

+0

-4

common/ECFifoBuffer.cpp less more

16	16
17	17	#include <kopano/platform.h>
18	18	#include "ECFifoBuffer.h"
19
20		#ifdef _DEBUG
21		#define new DEBUG_NEW
22		#endif
23	19
24	20	ECFifoBuffer::ECFifoBuffer(size_type ulMaxSize)
25	21	: m_ulMaxSize(ulMaxSize)

+0

-5

common/ECGetText.cpp less more

24	24
25	25	#include <pthread.h>
26	26	#include <cassert>
27
28		#ifdef _DEBUG
29		#define new DEBUG_NEW
30		#endif
31	27
32	28	namespace detail {
33	29

117	113
118	114	} // namespace detail
119	115
120
121	116	/**
122	117	* Performs a 'regular' gettext and converts the result to a wide character string.
123	118	*

+0

-4

common/ECIConv.cpp less more

17	17	#include <kopano/platform.h>
18	18	#include <kopano/ECIConv.h>
19	19
20		#ifdef _DEBUG
21		#define new DEBUG_NEW
22		#endif
23
24	20	ECIConv::ECIConv(const std::string &strToCharset, const std::string &strFromCharset) {
25	21	try {
26	22	m_lpContext = new context_t(strToCharset.c_str(), strFromCharset.c_str());

+1

-8

common/ECKeyTable.cpp less more

18	18	#include <cassert>
19	19	#include <kopano/ECKeyTable.h>
20	20	#include <kopano/ustringutil.h>
21		#ifdef _DEBUG
22		#define new DEBUG_NEW
23		#endif
24	21
25	22	bool operator!=(const sObjectTableKey& a, const sObjectTableKey& b)
26	23	{

101	98	void ECTableRow::initSortCols(unsigned int ulSortCols, const int *lpSortLen,
102	99	const unsigned char lpFlags, unsigned char *lppSortData)
103	100	{
104		unsigned int i=0;
105	101	int len = 0;
106	102
107	103	this->ulSortCols = ulSortCols;

121	117	memcpy(this->lpSortLen, lpSortLen, sizeof(unsigned int) * ulSortCols);
122	118
123	119	// Copy sort keys
124		for (i = 0; i < ulSortCols; ++i) {
	120	for (unsigned int i = 0; i < ulSortCols; ++i) {
125	121	len = lpSortLen[i];
126	122	len = len < 0 ? -len : len;
127	123

315	311	// The start of bookmark, the first 3 (0,1,2) are default
316	312	m_ulBookmarkPosition = 3;
317	313
318
319	314	// g++ doesn't like static initializers on existing variables
320	315	pthread_mutexattr_t mattr;
321	316	pthread_mutexattr_init(&mattr);

838	833	return erSuccess;
839	834	}
840	835
841
842	836	ECRESULT ECKeyTable::SeekRow(unsigned int lbkOrgin, int lSeekTo, int *lplRowsSought)
843	837	{
844	838	ECRESULT er = erSuccess;

846	840	unsigned int ulCurrentRow = 0;
847	841	unsigned int ulRowCount = 0;
848	842	ECTableRow *lpRow = NULL;
849
850	843
851	844	pthread_mutex_lock(&mLock);
852	845

+10

-39

common/ECLogger.cpp less more

25	25	#include <zlib.h>
26	26	#include <kopano/stringutil.h>
27	27	#include "charset/localeutil.h"
28
29		#ifdef LINUX
30	28	#include "config.h"
31	29	#include <poll.h>
32	30	#if HAVE_SYSLOG_H

40	38	#include <sys/time.h>
41	39	#include <sys/types.h>
42	40	#include <sys/utsname.h>
43		#endif
44
45	41	#include <kopano/ECConfig.h>
46		#ifdef _DEBUG
47		#define new DEBUG_NEW
48		#endif
49	42
50	43	using namespace std;
51	44

173	166	void ECLogger_Null::LogVA(unsigned int loglevel, const char *format, va_list& va) {}
174	167
175	168	/**
176		* ECLogger_File constructor
177		*
178	169	* @param[in] max_ll max loglevel passed to ECLogger
179	170	* @param[in] add_timestamp true if a timestamp before the logmessage is wanted
180	171	* @param[in] filename filename of log in current locale

395	386	Log(loglevel, std::string(msgbuffer));
396	387	}
397	388
398		#ifdef LINUX
399	389	ECLogger_Syslog::ECLogger_Syslog(unsigned int max_ll, const char *ident, int facility) : ECLogger(max_ll) {
400	390	/*
401	391	* Because @ident can go away, and openlog(3) does not make a copy for

454	444	syslog(levelmap[loglevel & EC_LOGLEVEL_MASK], "%s", msgbuffer);
455	445	#endif
456	446	}
457		#endif
458
459		/**
460		* Consructor
461		*/
	447
462	448	ECLogger_Tee::ECLogger_Tee(): ECLogger(EC_LOGLEVEL_DEBUG) {
463	449	}
464	450
465	451	/**
466		* Destructor
467		*
468	452	* The destructor calls Release on each attached logger so
469	453	* they'll be deleted if it was the last reference.
470	454	*/

556	540	}
557	541	}
558	542
559		#ifdef LINUX
560	543	ECLogger_Pipe::ECLogger_Pipe(int fd, pid_t childpid, int loglevel) : ECLogger(loglevel) {
561	544	m_fd = fd;
562	545	m_childpid = childpid;

704	687	static int PipePassLoop(int readfd, ECLogger_File *lpFileLogger,
705	688	ECConfig *lpConfig)
706	689	{
707		int ret = 0;
	690	ssize_t ret;
708	691	char buffer[_LOG_BUFSIZE] = {0};
709	692	std::string complete;
710	693	const char *p = NULL;

762	745	do {
763	746	// if we don't read anything from the fd, it was the end
764	747	ret = read(readfd, buffer, sizeof buffer);
765
	748	if (ret <= 0)
	749	break;
766	750	complete.append(buffer,ret);
767	751	} while (ret == sizeof buffer);
768	752

814	798	ECLogger_Pipe *lpPipeLogger = NULL;
815	799	int filefd;
816	800	int pipefds[2];
817		int t, i;
818	801	pid_t child = 0;
819	802
820	803	if (lpFileLogger == NULL)

832	815
833	816	if (child == 0) {
834	817	// close all files except the read pipe and the logfile
835		t = getdtablesize();
836		for (i = 3; i < t; ++i) {
	818	int t = getdtablesize();
	819	for (int i = 3; i < t; ++i) {
837	820	if (i == pipefds[0] \|\| i == filefd) continue;
838	821	close(i);
839	822	}

862	845
863	846	return lpPipeLogger;
864	847	}
865		#endif
866	848
867	849	/**
868	850	* Create ECLogger object from configuration.

880	862	ECLogger *lpLogger = NULL;
881	863	string prepend;
882	864	int loglevel = 0;
883
884		#ifdef LINUX
885	865	int syslog_facility = LOG_MAIL;
886		#endif
887	866
888	867	if (bAudit) {
889		#ifdef LINUX
	868	#if 1 /* change to ifdef HAVE_LOG_AUTHPRIV */
890	869	if (!parseBool(lpConfig->GetSetting("audit_log_enabled")))
891	870	return NULL;
892	871	prepend = "audit_";

898	877
899	878	loglevel = strtol(lpConfig->GetSetting((prepend+"log_level").c_str()), NULL, 0);
900	879
901		if (stricmp(lpConfig->GetSetting((prepend+"log_method").c_str()), "syslog") == 0) {
902		#ifdef LINUX
	880	if (strcasecmp(lpConfig->GetSetting((prepend+"log_method").c_str()), "syslog") == 0) {
903	881	char *argzero = strdup(argv0);
904	882	lpLogger = new ECLogger_Syslog(loglevel, basename(argzero), syslog_facility);
905	883	free(argzero);
906		#else
907		fprintf(stderr, "syslog logging is only available on linux.\n");
908		#endif
909		} else if (stricmp(lpConfig->GetSetting((prepend+"log_method").c_str()), "eventlog") == 0) {
	884	} else if (strcasecmp(lpConfig->GetSetting((prepend+"log_method").c_str()), "eventlog") == 0) {
910	885	fprintf(stderr, "eventlog logging is only available on windows.\n");
911		} else if (stricmp(lpConfig->GetSetting((prepend+"log_method").c_str()), "file") == 0) {
	886	} else if (strcasecmp(lpConfig->GetSetting((prepend+"log_method").c_str()), "file") == 0) {
912	887	int ret = 0;
913		#ifdef LINUX
914	888	const struct passwd *pw = NULL;
915	889	const struct group *gr = NULL;
916	890	if (strcmp(lpConfig->GetSetting((prepend+"log_file").c_str()), "-")) {

952	926	}
953	927	}
954	928	}
955		#endif
956	929	if (ret == 0) {
957	930	bool logtimestamp = parseBool(lpConfig->GetSetting((prepend + "log_timestamp").c_str()));
958	931

963	936	ECLogger_File *log = new ECLogger_File(loglevel, logtimestamp, lpConfig->GetSetting((prepend + "log_file").c_str()), false);
964	937	log->reinit_buffer(log_buffer_size);
965	938	lpLogger = log;
966		#ifdef LINUX
967	939	// chown file
968	940	if (pw \|\| gr) {
969	941	uid_t uid = -1;

974	946	gid = gr->gr_gid;
975	947	chown(lpConfig->GetSetting((prepend+"log_file").c_str()), uid, gid);
976	948	}
977		#endif
978	949	} else {
979	950	fprintf(stderr, "Not enough permissions to append logfile '%s'. Reverting to stderr.\n", lpConfig->GetSetting((prepend+"log_file").c_str()));
980	951	bool logtimestamp = parseBool(lpConfig->GetSetting((prepend + "log_timestamp").c_str()));

+1

-13

common/ECMemStream.cpp less more

21	21	#include "ECMemStream.h"
22	22	#include <kopano/Trace.h>
23	23	#include <kopano/ECDebug.h>
24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28
29		/*
30		* ECMemBlock implementation
31		*
32		*/
33
34	24	#define EC_MEMBLOCK_SIZE 8192
35	25
36	26	ECMemBlock::ECMemBlock(char *buffer, ULONG ulDataLen, ULONG ulFlags) : ECUnknown("ECMemBlock")

113	103	memset(lpCurrent+cbTotal, 0, newsize-cbTotal); // clear new alloced mem
114	104	cbTotal = newsize; // set new size
115	105	}
116
117	106
118	107	if (dsize > cbCurrent) // if write part is bigger than actual data
119	108	cbCurrent = ulPos + ulLen; // set _real_ buffer size

525	514	HRESULT ECMemStream::xStream::QueryInterface(REFIID refiid, LPVOID *lppInterface)
526	515	{
527	516	char szGuidId[1024+1];
528		_snprintf(szGuidId, 1024, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", refiid.Data1, refiid.Data2, refiid.Data3, refiid.Data4[0], refiid.Data4[1], refiid.Data4[2], refiid.Data4[3], refiid.Data4[4], refiid.Data4[5], refiid.Data4[6], refiid.Data4[7]);
	517	snprintf(szGuidId, 1024, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", refiid.Data1, refiid.Data2, refiid.Data3, refiid.Data4[0], refiid.Data4[1], refiid.Data4[2], refiid.Data4[3], refiid.Data4[4], refiid.Data4[5], refiid.Data4[6], refiid.Data4[7]);
529	518
530	519	TRACE_STREAM(TRACE_ENTRY, "IStream::QueryInterface", "%s", szGuidId);
531	520	METHOD_PROLOGUE_(ECMemStream, Stream);

534	523	return hr;
535	524	}
536	525
537
538	526	HRESULT ECMemStream::xStream::Read(void pv, ULONG cb, ULONG pcbRead)
539	527	{
540	528	TRACE_STREAM(TRACE_ENTRY, "IStream::Read", "size=%d", cb);

+0

-7

common/ECScheduler.cpp less more

16	16
17	17	#include <kopano/platform.h>
18	18	#include <kopano/ECScheduler.h>
19		#ifdef LINUX
20		// ETIMEDOUT in linux is in errno, windows has this though pthread.h
21	19	#include <cerrno>
22		#endif
23	20	#include <sys/time.h> /* gettimeofday */
24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28	21
29	22	#define SCHEDULER_POLL_FREQUENCY 5
30	23

+0

-9

common/ECSerializer.cpp less more

15	15	*/
16	16
17	17	#include <kopano/platform.h>
18
19		#ifdef LINUX
20	18	#include <arpa/inet.h>
21		#endif
22
23	19	#include "ECFifoBuffer.h"
24	20	#include "ECSerializer.h"
25
26		#ifdef _DEBUG
27		#define new DEBUG_NEW
28		#endif
29
30	21
31	22	ECStreamSerializer::ECStreamSerializer(IStream *lpBuffer)
32	23	{

+0

-4

common/ECUnknown.cpp less more

22	22
23	23	#include <kopano/ECUnknown.h>
24	24	#include <kopano/ECGuid.h>
25
26		#ifdef _DEBUG
27		#define new DEBUG_NEW
28		#endif
29	25
30	26	ECUnknown::ECUnknown(const char *szClassName)
31	27	{

+1

-2

common/HtmlEntity.cpp less more

523	523	return wcscmp( e1->s, e2->s );
524	524	}
525	525
526
527	526	static int compareHTMLEntityToName(const void m1, const void m2)
528	527	{
529	528	const HTMLEntityToName_t e1 = static_cast<const HTMLEntityToName_t >(m1);

626	625	return false;
627	626
628	627	std::wstring str;
629		int base = 10;
630	628
631	629	if (strEntity[1] == '#') {
	630	int base = 10;
632	631	str = strEntity.substr(2, pos-2);
633	632
634	633	if(str[0] == 'x')

+0

-2

common/HtmlToTextParser.cpp less more

18	18	#include "HtmlToTextParser.h"
19	19	#include "HtmlEntity.h"
20	20	#include <cwctype>
21
22	21
23	22	CHtmlToTextParser::CHtmlToTextParser(void)
24	23	{

338	337	addNewLine( true );
339	338	}
340	339
341
342	340	void CHtmlToTextParser::parseTagBR()
343	341	{
344	342	addNewLine( true );

+1

-0

common/Makefile.am less more

15	15	noinst_DATA = \
16	16	libkcutil.ldd libkcmapi.ldd \
17	17	libkcssl.ldd libkcservice.ldd
	18	CLEANFILES = ${noinst_DATA}
18	19
19	20	#
20	21	# libkcutil

+0

-4

common/SSLUtil.cpp less more

22	22	#include <openssl/ssl.h>
23	23	#include <openssl/conf.h>
24	24	#include <openssl/engine.h>
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28
29	25
30	26	static pthread_mutex_t *ssl_locks;
31	27

+1

-1

common/StatsClient.cpp less more

157	157	}
158	158	pthread_mutex_destroy(&mapsLock);
159	159
160		closesocket(fd);
	160	close(fd);
161	161
162	162	logger -> Log(EC_LOGLEVEL_DEBUG, "StatsClient terminated");
163	163	}

+0

-51

common/SymmetricCrypt.cpp less more

37	37	* @retval true The provided string was encrypted.
38	38	* @retval false The provided string was not encrypted.
39	39	*/
40		#ifdef _DEBUG
41		#define new DEBUG_NEW
42		#endif
43	40
44	41	bool SymmetricIsCrypted(const char *c)
45	42	{

64	61	bool SymmetricIsCrypted(const wchar_t *c)
65	62	{
66	63	return wcsncmp(c, L"{1}:", 4) == 0 \|\| wcsncmp(c, L"{2}:", 4) == 0;
67		}
68
69		/**
70		* Crypt a pasword using algorithm 2.
71		*
72		* @param[in] strPlain
73		* The string to encrypt.
74		*
75		* @return The encrypted string encoded in UTF-8.
76		*/
77		std::string SymmetricCrypt(const std::wstring &strPlain)
78		{
79		std::string u = convert_to<std::string>("UTF-8", strPlain, rawsize(strPlain), CHARSET_WCHAR);
80		size_t z = u.size();
81
82		for (size_t i = 0; i < z; ++i)
83		u[i] ^= 0xA5;
84		// Do the base64 encode
85		return "{2}:" + base64_encode(reinterpret_cast<const unsigned char *>(u.c_str()), z);
86		}
87
88		/**
89		* Crypt a pasword using algorithm 2.
90		*
91		* @param[in] strPlain
92		* The string to encrypt.
93		*
94		* @return The encrypted string encoded in UTF-16/32 (depending on type of wchar_t).
95		*/
96		std::wstring SymmetricCryptW(const std::wstring &strPlain)
97		{
98		return convert_to<std::wstring>(SymmetricCrypt(strPlain));
99	64	}
100	65
101	66	/**

165	130	return SymmetricDecryptBlob(wstrCrypted[1] - '0',
166	131	base64_decode(convert_to<std::string>(wstrCrypted + 4)));
167	132	}
168
169		/**
170		* Decrypt an encrypted password.
171		*
172		* Depending on the N value, the password is decrypted using algorithm 1 or 2.
173		*
174		* @param[in] strCrypted
175		* The encrypted password to decrypt.
176		*
177		* @return THe decrypted password encoded in in UTF-16/32 (depending on type of wchar_t).
178		*/
179		std::wstring SymmetricDecryptW(const wchar_t *wstrCrypted)
180		{
181		const std::string strDecrypted = SymmetricDecrypt(wstrCrypted);
182		return convert_to<std::wstring>(strDecrypted, rawsize(strDecrypted), "UTF-8");
183		}

+0

-5

common/SymmetricCrypt.h less more

19	19
20	20	bool SymmetricIsCrypted(const wchar_t *);
21	21	bool SymmetricIsCrypted(const char *);
22
23		std::string SymmetricCrypt(const std::wstring &strPlain);
24		std::wstring SymmetricCryptW(const std::wstring &strPlain);
25
26	22	std::string SymmetricDecrypt(const char *strCrypted);
27	23	std::string SymmetricDecrypt(const wchar_t *wstrCrypted);
28		std::wstring SymmetricDecryptW(const wchar_t *wstrCrypted);
29	24
30	25	#endif

+0

-4

common/TimeUtil.cpp less more

17	17	#include <kopano/platform.h>
18	18
19	19	#include "TimeUtil.h"
20
21		#ifdef _DEBUG
22		#define new DEBUG_NEW
23		#endif
24	20
25	21	/**
26	22	* Get a timestamp for the given date/time point

+1

-11

common/Trace.cpp less more

19	19	#include <cstdio>
20	20	#include <cstdarg>
21	21	#include <kopano/Trace.h>
22
23		#ifdef _DEBUG
24		#define new DEBUG_NEW
25		#endif
26	22
27	23	#ifdef WITH_TRACING
28	24	// Turn these on/off

87	83	break;
88	84	}
89	85
90
91		pos = _snprintf(debug, sizeof(debug), "%lu %08X %s %s: %s(", GetTickCount(), GetCurrentThreadId(), lpMsg, lpTraceType, func);
	86	pos = snprintf(debug, sizeof(debug), "%lu %08X %s %s: %s(", GetTickCount(), GetCurrentThreadId(), lpMsg, lpTraceType, func);
92	87
93	88	len = pos + 3;
94	89
95	90	if (format) {
96	91	va_copy(va_lentest, va);
97		#ifdef LINUX
98	92	len += _vsnprintf(NULL, 0, format, va_lentest);
99		#else
100		len += _vscprintf(format, va_lentest);
101		#endif
102	93	va_end(va_lentest);
103	94	}
104	95

200	191	va_end(va);
201	192	}
202	193
203
204	194	void TraceStream(int time, const char func, const char format, ...)
205	195	{
206	196	va_list va;

+0

-4

common/base64.cpp less more

17	17	#include <kopano/platform.h>
18	18	#include <kopano/base64.h>
19	19	#include <cctype>
20
21		#ifdef _DEBUG
22		#define new DEBUG_NEW
23		#endif
24	20
25	21	static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
26	22

+1

-7

common/charset/convert.cpp less more

26	26	#include <cerrno>
27	27	#define BUFSIZE 4096
28	28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32
33	29	convert_exception::convert_exception(enum exception_type type, const std::string &message)
34	30	: std::runtime_error(message)
35	31	, m_type(type)

42	38	illegal_sequence_exception::illegal_sequence_exception(const std::string &message)
43	39	: convert_exception(eIllegalSequence, message)
44	40	{}
45
46	41
47	42	namespace details {
48	43

133	128	m_bForce = true;
134	129	} else if (i == "NOIGNORE" \|\| i == "NOFORCE") {
135	130	m_bForce = false;
136		} else if(*i == "HTMLENTITIES" && stricmp(fromcode, CHARSET_WCHAR) == 0) {
	131	} else if(*i == "HTMLENTITIES" && strcasecmp(fromcode, CHARSET_WCHAR) == 0) {
137	132	m_bHTML = true;
138	133	} else vOptionsFiltered.push_back(*i);
139	134	++i;

144	139	strto += join(vOptionsFiltered.begin(), vOptionsFiltered.end(), std::string(","));
145	140	}
146	141	}
147
148	142
149	143	m_cd = iconv_open(strto.c_str(), fromcode);
150	144	if (m_cd == (iconv_t)(-1))

+1

-13

common/charset/convstring.cpp less more

17	17	#include <kopano/platform.h>
18	18	#include <kopano/charset/convstring.h>
19	19
20		#ifdef _DEBUG
21		#define new DEBUG_NEW
22		#endif
23
24	20	/** Create a convstring instance from a SPropValue.
25	21	*
26	22	* Extarcts the lpszA or lpszW depending on the PROP_TYPE of the provided

73	69	return from_SPropValue(&sPropVal, bCheapCopy);
74	70	}
75	71
76		/** Default constructor
77		*
78		* Creates an empty convstring
79		*/
80	72	convstring::convstring()
81	73	: m_lpsz(NULL)
82	74	, m_ulFlags(0)
83	75	{}
84	76
85		/** Copy constructor
86		*
	77	/**
87	78	* Create a new convstring object based on another convstring object.
88	79	*
89	80	* @param[in] other

217	208	}
218	209	}
219	210
220
221	211	/** Check if the convstring is initialized with a NULL pointer or with an empty string.
222	212	*
223	213	* @return A boolean specifying of the internal string is a NULL pointer or an empty string.

275	265	return (m_lpsz ? convert_to<char*>() : NULL);
276	266	}
277	267
278
279	268	/**
280	269	* Convert this convstring object to a raw wchar_t pointer.
281	270	*

289	278	return (m_lpsz ? convert_to<wchar_t*>() : NULL);
290	279	}
291	280
292
293	281	/**
294	282	* Convert this convstring object to a raw char pointer encoded in UTF-8.
295	283	*

+0

-16

common/charset/traits.cpp less more

18	18	#include <kopano/charset/utf16string.h>
19	19	#include "utf32string.h"
20	20
21		#ifdef _DEBUG
22		#define new DEBUG_NEW
23		#endif
24
25	21	/**
26	22	* Make charset string ignore invalid characters, possebly converting
27	23	* them with '?' character in iconv.

41	37	return len;
42	38	}
43	39
44		#ifdef LINUX
45	40	size_t iconv_charset<unsigned short>::rawsize(const unsigned short from) {
46	41	return ucslen(from) * sizeof(unsigned short);
47	42	}

49	44	size_t iconv_charset<const unsigned short>::rawsize(const unsigned short from) {
50	45	return ucslen(from) * sizeof(unsigned short);
51	46	}
52
53		#else
54		size_t iconv_charset<unsigned int>::rawsize(const unsigned int from) {
55		return ucslen(from) * sizeof(unsigned int);
56		}
57
58		size_t iconv_charset<const unsigned int>::rawsize(const unsigned int from) {
59		return ucslen(from) * sizeof(unsigned int);
60		}
61
62		#endif

+0

-132

common/charset/utf32string.h less more

20	20	#include <kopano/zcdefs.h>
21	21	#include <kopano/charset/traits.h>
22	22
23		#ifdef LINUX
24	23	// The utf32string type
25	24	typedef std::wstring utf32string;
26	25
27		#else
28		// The utf32string type
29		typedef std::basic_string<unsigned int> utf32string;
30
31		namespace std {
32
33		template<>
34		struct char_traits<unsigned int>
35		{
36		typedef unsigned int char_type;
37		typedef wint_t int_type;
38		typedef streamoff off_type;
39		typedef wstreampos pos_type;
40		typedef mbstate_t state_type;
41
42		static void
43		assign(char_type& __c1, const char_type& __c2)
44		{ __c1 = __c2; }
45
46		static bool
47		eq(const char_type& __c1, const char_type& __c2)
48		{ return __c1 == __c2; }
49
50		static bool
51		lt(const char_type& __c1, const char_type& __c2)
52		{ return __c1 < __c2; }
53
54		static int
55		compare(const char_type* __s1, const char_type* __s2, size_t __n)
56		{ while(__s1 != 0 && __s2 != 0 && __n != 0) {
57		if(__s1 != __s2) return __s1 - __s2;
58		++__s1;
59		++__s2;
60		--__n;
61		}
62		if((__s1 == 0 && __s2 == 0) \|\| __n == 0) return 0;
63		if(*__s1 != 0) return -1;
64		return 1;
65		}
66
67		static size_t
68		length(const char_type* __s)
69		{ int l = 0;
70		while (*__s != 0) { ++l; ++__s; }
71		return l;
72		}
73
74		static const char_type*
75		find(const char_type* __s, size_t __n, const char_type& __a)
76		{ while(*__s != 0 && __n > 0) {
77		if(*__s == __a) return __s;
78		++__s; --__n;
79		}
80		return NULL;
81		}
82
83		static char_type*
84		move(char_type* __s1, const char_type* __s2, int_type __n)
85		{ return (unsigned int )memmove((void )__s1, (void )__s2, __nsizeof(unsigned int)); }
86
87		static char_type*
88		copy(char_type* __s1, const char_type* __s2, size_t __n)
89		{ return (unsigned int )memcpy((void )__s1, (void )__s2, __nsizeof(unsigned int)); }
90
91		static char_type*
92		assign(char_type* __s, size_t __n, char_type __a)
93		{ char_type *__o = __s;
94		while (__n > 0) { *__s = __a; --__n; ++__s; }
95		return __o;
96		}
97
98		static char_type
99		to_char_type(const int_type& __c) { return char_type(__c); }
100
101		static int_type
102		to_int_type(const char_type& __c) { return int_type(__c); }
103
104		static bool
105		eq_int_type(const int_type& __c1, const int_type& __c2)
106		{ return __c1 == __c2; }
107
108		static int_type
109		eof() { return static_cast<int_type>(-1); }
110
111		static int_type
112		not_eof(const int_type& __c)
113		{ return eq_int_type(__c, eof()) ? 0 : __c; }
114		};
115		}
116
117		// 32-bit character specializations
118		template <>
119		class iconv_charset<utf32string> _zcp_final {
120		public:
121		static const char *name() {
122		return "UTF-32LE";
123		}
124		static const char *rawptr(const utf32string &from) {
125		return reinterpret_cast<const char*>(from.c_str());
126		}
127		static size_t rawsize(const utf32string &from) {
128		return from.size() * sizeof(utf32string::value_type);
129		}
130		};
131
132		template <>
133		class iconv_charset<unsigned int *> _zcp_final {
134		public:
135		static const char *name() {
136		return "UTF32LE//TRANSLIT";
137		}
138		static const char rawptr(const unsigned int from) {
139		return reinterpret_cast<const char*>(from);
140		}
141		static size_t rawsize(const unsigned int *from);
142		};
143
144		template <>
145		class iconv_charset<const unsigned int *> _zcp_final {
146		public:
147		static const char *name() {
148		return "UTF32LE//TRANSLIT";
149		}
150		static const char rawptr(const unsigned int from) {
151		return reinterpret_cast<const char*>(from);
152		}
153		static size_t rawsize(const unsigned int *from);
154		};
155
156		#endif
157
158	26	#endif // ndef utf32string_INCLUDED

+1

-5

common/codepage.cpp less more

20	20	#include <mapicode.h>
21	21
22	22	#include <kopano/codepage.h>
23
24		#ifdef _DEBUG
25		#define new DEBUG_NEW
26		#endif
27	23
28	24	// These charset should all be supported by iconv
29	25

114	110	HRESULT HrGetCPByCharset(const char lpszCharset,ULONG codepage)
115	111	{
116	112	for (size_t i = 0; i < ARRAY_SIZE(CPMAP); ++i) {
117		if(stricmp(CPMAP[i].charset, lpszCharset) == 0) {
	113	if(strcasecmp(CPMAP[i].charset, lpszCharset) == 0) {
118	114	*codepage = CPMAP[i].codepage;
119	115	return hrSuccess;
120	116	}

+3

-0

common/cov-scope.cpp less more

13	13	#include <mapidefs.h>
14	14	class I {
15	15	public:
	16	virtual ~I(void) {}
16	17	/* ptr-to-non-const on purpose */
17	18	virtual void SetProps(SPropValue *, size_t) {}
18	19	};

45	46	else
46	47	obj = new Y();
47	48	obj->SetProps(prop, ARRAY_SIZE(prop));
	49	memset(prop, '\0', sizeof(prop));
	50	delete obj;
48	51	return 0;
49	52	}

+2

-72

common/fileutil.cpp less more

23	23	#include <kopano/ECIConv.h>
24	24	#include <kopano/ECLogger.h>
25	25
26		#include <mapicode.h> // only for MAPI error codes
27		#include <mapidefs.h> // only for MAPI error codes
28
29		#ifdef LINUX
	26	#include <mapicode.h>
	27	#include <mapidefs.h>
30	28	#include <sys/mman.h>
31	29	#include <sys/socket.h>
32	30	#include <sys/stat.h>
33	31	#include <arpa/inet.h>
34		#endif
35	32	#include "fileutil.h"
36
37		#ifdef _DEBUG
38		#define new DEBUG_NEW
39		#endif
40	33
41	34	#define BLOCKSIZE 65536
42	35

123	116
124	117	*lpImmap = false;
125	118
126		#ifdef LINUX
127	119	/* Try mmap first */
128	120	if (fstat(fd, &stat) != 0) {
129	121	perror("Stat failed");

138	130	*lpSize = stat.st_size;
139	131	return hrSuccess;
140	132	}
141		#endif /* LINUX */
142	133
143	134	/* mmap failed (probably reading from STDIN as a stream), just read the file into memory, and return that */
144	135	lpBuffer = (char*)malloc(BLOCKSIZE); // will be deleted as soon as possible

185	176	*/
186	177	HRESULT HrUnmapFileBuffer(char *lpBuffer, int ulSize, bool bImmap)
187	178	{
188		#ifdef LINUX
189	179	if (bImmap)
190	180	munmap(lpBuffer, mmapsize(ulSize));
191	181	else
192		#endif
193	182	free(lpBuffer);
194
195	183	return hrSuccess;
196	184	}
197	185

290	278
291	279	return bResult;
292	280	}
293
294		/**
295		* Convert file from UCS2 to UTF8
296		*
297		* @param[in] strSrcFileName Source filename
298		* @param[in] strDstFileName Destination filename
299		*/
300		bool ConvertFileFromUCS2ToUTF8(const std::string &strSrcFileName, const std::string &strDstFileName)
301		{
302		bool bResult = false;
303		int ulBufferSize = 0;
304		FILE *pfSrc = NULL;
305		FILE *pfDst = NULL;
306		char *lpBuffer = NULL;
307		bool bImmap = false;
308		std::string strConverted;
309
310		pfSrc = fopen(strSrcFileName.c_str(), "rb");
311		if(pfSrc == NULL) {
312		ec_log_err("%s: Unable to open file \"%s\": %s", __PRETTY_FUNCTION__, strSrcFileName.c_str(), strerror(errno));
313		goto exit;
314		}
315
316		// create new file
317		pfDst = fopen(strDstFileName.c_str(), "wb");
318		if(pfDst == NULL) {
319		ec_log_err("%s: Unable to create file \"%s\": %s", __PRETTY_FUNCTION__, strDstFileName.c_str(), strerror(errno));
320		goto exit;
321		}
322
323		if(HrMapFileToBuffer(pfSrc, &lpBuffer, &ulBufferSize, &bImmap))
324		goto exit;
325
326		try {
327		strConverted = convert_to<std::string>("UTF-8", lpBuffer, ulBufferSize, "UCS-2//IGNORE");
328		} catch (const std::runtime_error &) {
329		goto exit;
330		}
331
332		if (fwrite(strConverted.c_str(), 1, strConverted.size(), pfDst) != strConverted.size()) {
333		ec_log_crit("%s: Unable to write to file \"%s\": %s", __PRETTY_FUNCTION__, strDstFileName.c_str(), strerror(errno));
334		goto exit;
335		}
336
337		bResult = true;
338
339		exit:
340		if (lpBuffer)
341		HrUnmapFileBuffer(lpBuffer, ulBufferSize, bImmap);
342
343		if (pfSrc)
344		fclose(pfSrc);
345
346		if (pfDst)
347		fclose(pfDst);
348
349		return bResult;
350		}

+0

-2

common/fileutil.h less more

26	26
27	27	bool DuplicateFile(FILE *lpFile, std::string &strFileName);
28	28
29		bool ConvertFileFromUCS2ToUTF8(const std::string &strSrcFileName, const std::string &strDstFileName);
30
31	29	#endif

+0

-1

common/include/kopano/ECDebug.h less more

65	65	std::string NotificationToString(ULONG cNotification, const NOTIFICATION *lpNotification);
66	66
67	67	std::string ProblemArrayToString(const SPropProblemArray *lpProblemArray);
68		std::string unicodetostr(const wchar_t *lpszW);
69	68
70	69	const char *MsgServiceContextToString(ULONG ulContext);
71	70	const char *ResourceTypeToString(ULONG ulResourceType);

+1

-5

common/include/kopano/ECLogger.h less more

259	259	/**
260	260	* Linux syslog logger. Output is whatever syslog does, probably LC_CTYPE.
261	261	*/
262		#ifdef LINUX
263	262	class ECLogger_Syslog _zcp_final : public ECLogger {
264	263	private:
265	264	char *m_ident;

274	273	virtual void Log(unsigned int loglevel, const char *format, ...) _zcp_override __LIKE_PRINTF(3, 4);
275	274	virtual void LogVA(unsigned int loglevel, const char *format, va_list &va) _zcp_override;
276	275	};
277		#endif
278
279		#ifdef LINUX
	276
280	277	/**
281	278	* Pipe Logger, only used by forked model processes. Redirects every
282	279	* log message to an ECLogger_File object. This ECLogger_Pipe object

301	298	};
302	299
303	300	ECLogger* StartLoggerProcess(ECConfig lpConfig, ECLogger lpFileLogger);
304		#endif
305	301
306	302	/**
307	303	* This class can be used if log messages need to go to

+0

-11

common/include/kopano/Trace.h less more

48	48	#define TRACE_STREAM TraceStream
49	49	#define TRACE_EXT TraceExt
50	50	#else
51		# ifdef LINUX
52	51	# define TRACE_MAPI(...)
53	52	# define TRACE_MAPILIB(...)
54	53	# define TRACE_ECMAPI(...)

57	56	# define TRACE_SOAP(...)
58	57	# define TRACE_STREAM(...)
59	58	# define TRACE_EXT(...)
60		# else
61		# define TRACE_MAPI __noop
62		# define TRACE_MAPILIB __noop
63		# define TRACE_ECMAPI __noop
64		# define TRACE_NOTIFY __noop
65		# define TRACE_INTERNAL __noop
66		# define TRACE_SOAP __noop
67		# define TRACE_STREAM __noop
68		# define TRACE_EXT __noop
69		# endif
70	59	#endif
71	60
72	61	#endif // TRACE_H

+0

-4

common/include/kopano/UnixUtil.h less more

16	16
17	17	#ifndef __UNIXUTIL_H
18	18	#define __UNIXUTIL_H
19
20		#ifdef LINUX
21	19
22	20	#include <sys/resource.h>
23	21

50	48	extern bool unix_system(const char szLogName, const char command, const char **env);
51	49
52	50	#endif
53
54		#endif

+0

-9

common/include/kopano/charset/utf16string.h less more

23	23
24	24	#include <kopano/charset/traits.h>
25	25
26		#ifdef LINUX
27	26	typedef unsigned short UTF16_CHAR;
28	27	typedef std::basic_string<unsigned short> utf16string;
29	28

150	149	static size_t rawsize(const unsigned short *from);
151	150	};
152	151
153		#else
154		typedef wchar_t UTF16_CHAR;
155
156		// The utf16string type
157		typedef std::wstring utf16string;
158
159		#endif
160
161	152	#endif //ndef utf16string_INCLUDED

+1

-4

common/include/kopano/platform.h less more

81	81	HRESULT UnixTimeToRTime(time_t unixtime, LONG *rtime);
82	82	HRESULT RTimeToUnixTime(LONG rtime, time_t *unixtime);
83	83	extern time_t SystemTimeToUnixTime(const SYSTEMTIME &);
84		SYSTEMTIME UnixTimeToSystemTime(time_t unixtime);
85	84	extern SYSTEMTIME TMToSystemTime(const struct tm &);
86		extern struct tm SystemTimeToTM(const SYSTEMTIME &);
87	85	double GetTimeOfDay();
88	86	ULONG CreateIntDate(ULONG day, ULONG month, ULONG year);
89	87	ULONG CreateIntTime(ULONG seconds, ULONG minutes, ULONG hours);
90	88	extern ULONG FileTimeToIntDate(const FILETIME &);
91	89	ULONG SecondsToIntTime(ULONG seconds);
92
93		int strcmp_ci(const char s1, const char s2);
94	90
95	91	inline double difftimeval(struct timeval ptstart, struct timeval ptend) {
96	92	return 1000000 * (ptend->tv_sec - ptstart->tv_sec) + (ptend->tv_usec - ptstart->tv_usec);

156	152
157	153	bool force_buffers_to_disk(const int fd);
158	154	extern int ec_relocate_fd(int);
	155	extern int kc_reexec_with_allocator(char *, const char );
159	156
160	157	#endif // PLATFORM_H

+2

-33

common/include/kopano/platform.linux.h less more

57	57	#define ASSERT assert
58	58	#define _ASSERT assert
59	59
60		#ifdef _DEBUG
61		#error _DEBUG is defined in linux, which should not be used!
62		#endif
63
64	60	#define _vsnprintf vsnprintf
65		#define _snprintf snprintf
66	61	#ifdef HAVE_VSNPRINTF_L
67	62	#define _vsnprintf_l vsnprintf_l
68	63	#else

85	80
86	81	#define STDAPI_(__type) __type __stdcall
87	82
88		/* Defines for some windows function that have a different name in Linux */
89		#define _snprintf snprintf
90		#define strnicmp strncasecmp
91		#define stricmp strcasecmp
92
93		#define _atoi64 atoll
94
95		#define CreateDir(dir, mode) mkdir(dir, mode)
96		#define closesocket(fd) close(fd)
97
98	83	/* base types */
99		#include <sys/types.h>
100	84	typedef void VOID;
101	85	typedef unsigned char BYTE;
102	86	typedef unsigned char UCHAR;

583	567	bool operator==(REFIID, const GUID &);
584	568	HRESULT CoCreateGuid(LPGUID);
585	569
586		__int64_t Int32x32To64(ULONG, ULONG);
587
588	570	void GetSystemTimeAsFileTime(FILETIME *ft);
589	571	DWORD GetTempPath(DWORD inLen, char *lpBuffer);
590		#define GetTempPathA GetTempPath
591
592		#define utf32len wcslen
593	572
594	573	/* Some wrappers to map Windows unicode functions */
595	574	static inline int lstrcmpW(LPCWSTR str1, LPCWSTR str2)

617	596	#define _tcslen strlen
618	597	#define _tcscpy strcpy
619	598	#define _tcscmp strcmp
620		#define _tcsicmp stricmp
621		#endif
622
623		inline int strcmp_ci(const char s1, const char s2) { return strcasecmp(s1, s2); }
	599	#define _tcsicmp strcasecmp
	600	#endif
624	601
625	602	void Sleep(unsigned int usec);
626	603

639	616	#endif
640	617	#define PATH_SEPARATOR '/'
641	618
642		// timezone compatability
643		#define _tzset tzset
644		#define _timezone timezone
645		#define _daylight daylight
646		#define _tzname tzname
647	619	// unavailable in linux
648	620	#define _dstbias 0
649	621

697	669	**/
698	670	#define __LIKE_PRINTF(_fmt, _va) __attribute__((format(printf, _fmt, _va)))
699	671
700		#define z_tms tms
701		#define z_times times
702
703	672	std::vector<std::string> get_backtrace();
704	673
705	674	#endif // PLATFORM_LINUX_H

+3

-4

common/include/kopano/stringutil.h less more

26	26	/*
27	27	* Comparison handler for case-insensitive keys in maps
28	28	*/
29		struct stricmp_comparison {
	29	struct strcasecmp_comparison {
30	30	bool operator()(const std::string &left, const std::string &right) const
31	31	{
32		return left.size() < right.size() \|\| (left.size() == right.size() && stricmp(left.c_str(), right.c_str()) < 0);
	32	return left.size() < right.size() \|\| (left.size() == right.size() && strcasecmp(left.c_str(), right.c_str()) < 0);
33	33	}
34	34	};
35	35

88	88
89	89	std::string GetServerNameFromPath(const char *szPath);
90	90	std::string GetServerPortFromPath(const char *szPath);
91		std::string ServerNamePortToURL(const char lpszType, const char lpszServerName, const char lpszServerPort, const char lpszExtra = "zarafa");
92	91
93	92	static inline bool parseBool(const std::string &s) {
94	93	return !(s == "0" \|\| s == "false" \|\| s == "no");

96	95
97	96	extern std::string shell_escape(const std::string &str);
98	97	extern std::string shell_escape(const std::wstring &wstr);
99		std::string forcealnum(const std::string& str, const char *additional = NULL);
100	98
101	99	std::vector<std::wstring> tokenize(const std::wstring &strInput, const WCHAR sep, bool bFilterEmpty = false);
102	100	std::vector<std::string> tokenize(const std::string &strInput, const char sep, bool bFilterEmpty = false);

180	178	}
181	179
182	180	std::string format(const char *const fmt, ...) __LIKE_PRINTF(1, 2);
	181	extern "C" char kc_strlcpy(char , const char *, size_t);
183	182
184	183	#endif

+0

-5

common/kcodes.cpp less more

18	18	#include <mapicode.h>
19	19	#include <kopano/kcodes.h>
20	20	#include <kopano/mapiext.h>
21
22		#ifdef _DEBUG
23		#define new DEBUG_NEW
24		#endif
25
26	21
27	22	/*
28	23	* Some helper functions to convert the SOAP-style objects

+71

-50

common/platform.cpp less more

15	15	*/
16	16
17	17	#include <kopano/platform.h>
	18	#include <cerrno>
	19	#include <cstdlib>
18	20	#include <fcntl.h>
19	21	#include <mapidefs.h>
20	22	#include <mapicode.h>
21	23	#include <climits>
22	24	#include <pthread.h>
	25	#include <unistd.h>
23	26
24	27	#include <sys/stat.h>
25	28	#include <sys/time.h> /* gettimeofday */
26
	29	#include <kopano/ECLogger.h>
27	30	#include "TmpPath.h"
28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32	31
33	32	HRESULT UnixTimeToFileTime(time_t t, FILETIME *ft)
34	33	{

140	139	return stime.wSecond + (stime.wMinute60) + ((stime.wHour)60*60);
141	140	}
142	141
143		SYSTEMTIME UnixTimeToSystemTime(time_t unixtime)
144		{
145		SYSTEMTIME stime = {0};
146		stime.wSecond = unixtime%60;
147		unixtime /= 60;
148		stime.wMinute = unixtime%60;
149		unixtime /= 60;
150		stime.wHour = unixtime;
151		return stime;
152		}
153
154	142	SYSTEMTIME TMToSystemTime(const struct tm &t)
155	143	{
156	144	SYSTEMTIME stime = {0};

165	153	return stime;
166	154	}
167	155
168		struct tm SystemTimeToTM(const SYSTEMTIME &stime)
169		{
170		// not quite, since we miss tm_yday
171		struct tm t = {0};
172		t.tm_year = stime.wYear;
173		t.tm_mon = stime.wMonth;
174		t.tm_wday = stime.wDayOfWeek;
175		t.tm_mday = stime.wDay;
176		t.tm_hour = stime.wHour;
177		t.tm_min = stime.wMinute;
178		t.tm_sec = stime.wSecond;
179		t.tm_isdst = -1;
180		return t;
181		}
182
183	156	/* The 'IntDate' and 'IntTime' date and time encoding are used for some CDO calculations. They
184	157	* are basically a date or time encoded in a bitshifted way, packed so that it uses the least amount
185	158	* of bits. Eg. a date (day,month,year) is encoded as 5 bits for the day (1-31), 4 bits for the month (1-12),

304	277
305	278	// SuSE 9.1 segfaults when putenv() is used in a detached thread on the next getenv() call.
306	279	// so use setenv() on linux, putenv() on others.
307
308		#ifdef LINUX
309	280	setenv("TZ", "UTC0", 1);
310	281	tzset();
311		#else
312		if(putenv("TZ=UTC0") != -1)
313		_tzset();
314		#endif
315
316	282	convert = mktime(t);
317
318		#ifdef LINUX
319	283	if (s_tz) {
320	284	setenv("TZ", s_tz, 1);
321	285	tzset();

323	287	unsetenv("TZ");
324	288	tzset();
325	289	}
326		#else
327		if (s_tz) {
328		putenv(s_tz);
329		_tzset();
330		} else {
331		putenv("TZ=");
332		_tzset();
333		}
334		#endif
335	290	free(s_tz);
336	291	return convert;
337	292	}

411	366	}
412	367
413	368	// Create the actual directory
414		int ret = CreateDir(createpath, 0700);
	369	int ret = mkdir(createpath, 0700);
415	370	free(path);
416	371	return ret;
417	372	}

499	454	// inserted
500	455	posix_fallocate(fd, 0, len);
501	456	}
	457
	458	/**
	459	* Restart the program with a new preloaded library.
	460	* @argv: full argv of current invocation
	461	* @lib: library to load via LD_PRELOAD
	462	*
	463	* As every program under Linux is linked to libc and symbol resolution is done
	464	* breadth-first, having just libkcserver.so linked to the alternate allocator
	465	* is not enough to ensure the allocator is being used in favor of libc malloc.
	466	*
	467	* A program built against glibc will have a record for e.g.
	468	* "malloc@GLIBC_2.2.5". The use of LD_PRELOAD appears to relax the version
	469	* requirement, though; the benefit would be that libtcmalloc's malloc will
	470	* take over _all_ malloc calls.
	471	*/
	472	int kc_reexec_with_allocator(char *argv, const char lib)
	473	{
	474	if (lib == NULL \|\| *lib == '\0')
	475	return 0;
	476	const char *s = getenv("KC_ALLOCATOR_DONE");
	477	if (s != NULL)
	478	/* avoid repeatedly reexecing ourselves */
	479	return 0;
	480	s = getenv("LD_PRELOAD");
	481	if (s == NULL)
	482	setenv("LD_PRELOAD", lib, true);
	483	else if (strstr(s, "/valgrind/") != NULL)
	484	/*
	485	* Within vg, everything is a bit different — since it catches
	486	* execve itself. Execing /proc/self/exe therefore won't work,
	487	* we would need to use argv[0]. But… don't bother.
	488	*/
	489	return 0;
	490	else
	491	setenv("LD_PRELOAD", (std::string(s) + ":" + lib).c_str(), true);
	492	void *handle = dlopen(lib, RTLD_LAZY \| RTLD_LOCAL);
	493	if (handle == NULL)
	494	/*
	495	* Ignore libraries that won't load anyway. This avoids
	496	* ld.so emitting a scary warning if we did re-exec.
	497	*/
	498	return 0;
	499	dlclose(handle);
	500	setenv("KC_ALLOCATOR_DONE", lib, true);
	501
	502	/* Resolve "exe" symlink before exec to please the sysadmin */
	503	std::vector<char> linkbuf(16);
	504	ssize_t linklen;
	505	while (true) {
	506	linklen = readlink("/proc/self/exe", &linkbuf[0], linkbuf.size());
	507	if (linklen < 0 \|\| static_cast<size_t>(linklen) < linkbuf.size())
	508	break;
	509	linkbuf.resize(linkbuf.size() * 2);
	510	}
	511	if (linklen < 0) {
	512	int ret = -errno;
	513	ec_log_warn("kc_reexec_with_allocator: readlink: %s", strerror(errno));
	514	return ret;
	515	}
	516	linkbuf[linklen] = '\0';
	517	ec_log_debug("Reexecing %s with %s", &linkbuf[0], lib);
	518	execv(&linkbuf[0], argv);
	519	int ret = -errno;
	520	ec_log_info("Failed to reexec self: %s. Continuing with standard allocator.", strerror(errno));
	521	return ret;
	522	}

+0

-4

common/platform.linux.cpp less more

101	101	#endif
102	102
103	103	return S_OK;
104		}
105
106		__int64_t Int32x32To64(ULONG a, ULONG b) {
107		return (__int64_t)a*(__int64_t)b;
108	104	}
109	105
110	106	void GetSystemTimeAsFileTime(FILETIME *ft) {

+0

-4

common/rtfutil.cpp less more

31	31	#include <sstream>
32	32
33	33	using namespace std;
34
35		#ifdef _DEBUG
36		#define new DEBUG_NEW
37		#endif
38	34
39	35	static const char szHex[] = "0123456789ABCDEF";
40	36

+7

-53

common/stringutil.cpp less more

20	20	#include <sstream>
21	21
22	22	#include <kopano/ECIConv.h>
23
24		#ifdef _DEBUG
25		#define new DEBUG_NEW
26		#endif
27	23
28	24	std::string stringify(unsigned int x, bool usehex, bool _signed) {
29	25	char szBuff[33];

255	251	path.erase(pos, std::string::npos);
256	252
257	253	return path.c_str();
258		}
259
260		std::string ServerNamePortToURL(const char lpszType, const char lpszServerName, const char lpszServerPort, const char lpszExtra) {
261		std::string strURL;
262
263		if (lpszType && lpszType[0]) {
264		strURL.append(lpszType);
265		strURL.append("://");
266		}
267
268		strURL.append(lpszServerName);
269
270		if (lpszServerPort && lpszServerPort[0]) {
271		strURL.append(":");
272		strURL.append(lpszServerPort);
273		}
274
275		if (strnicmp(lpszType,"http", 4) == 0 && lpszExtra && lpszExtra[0]) {
276		strURL.append("/");
277		strURL.append(lpszExtra);
278		}
279
280		return strURL;
281	254	}
282	255
283	256	std::string shell_escape(const std::string &str)

559	532	return output;
560	533	}
561	534
562
563	535	/**
564	536	* Convert a memory buffer with strings with Unix \n enters to DOS
565	537	* \r\n enters.

661	633	swap(strInOut, strOutput);
662	634	}
663	635
664
665		/**
666		* Force a string to contain alphanumerics only
667		*
668		* Replaces all other characters with _ unless they are in szAdditional
669		*
670		* @param[in] str Input string
671		* @param[in] szAdditional Additional characters to accept
672		* @return Modified string
673		*/
674		std::string forcealnum(const std::string& str, const char *szAdditional)
675		{
676		std::string out;
677
678		for (std::string::const_iterator i = str.begin(); i != str.end(); ++i)
679		if(isalnum(*i))
680		out += *i;
681		else if(szAdditional && strchr(szAdditional, *i) != NULL)
682		out += *i;
683		else
684		out += '_';
685
686		return out;
687		}
688
689	636	std::string format(const char *const fmt, ...) {
690	637	char *buffer = NULL;
691	638	va_list ap;

699	646
700	647	return result;
701	648	}
	649
	650	char kc_strlcpy(char dest, const char *src, size_t n)
	651	{
	652	strncpy(dest, src, n);
	653	dest[n-1] = '\0';
	654	return dest;
	655	}

+2

-14

common/ustringutil.cpp less more

87	87	#include <kopano/charset/convert.h>
88	88	#endif
89	89
90		#ifdef _DEBUG
91		#define new DEBUG_NEW
92		#endif
93
94	90	#ifndef ZCP_USES_ICU
95	91	ECSortKey::ECSortKey(const unsigned char *lpSortData, unsigned int cbSortData)
96	92	: m_lpSortData(lpSortData)

396	392	return strcasestr(haystack, needle) != NULL;
397	393	#endif
398	394	}
399
400
401	395
402	396	/**
403	397	* Check if two strings are canonical equivalent.

652	646	#endif
653	647	}
654	648
655
656
657
658	649	/**
659	650	* Check if two strings are canonical equivalent.
660	651	*

913	904	return wcs_icontains(ws1, ws2, locale);
914	905	#endif
915	906	}
916
917	907
918	908	/**
919	909	* Copy at most n characters from the utf8 string src to lpstrDest.

1229	1219	{"zu_ZA",1077,"Zulu_South Africa"},
1230	1220	};
1231	1221
1232
1233	1222	ECLocale createLocaleFromName(const char *lpszLocale)
1234	1223	{
1235	1224	#ifdef ZCP_USES_ICU

1250	1239	ASSERT(lpulLcid != NULL);
1251	1240
1252	1241	for (unsigned i = 0; !lpMapEntry && i < arraySize(localeMap); ++i)
1253		if (stricmp(localeMap[i].lpszLocaleID, lpszLocaleID) == 0)
	1242	if (strcasecmp(localeMap[i].lpszLocaleID, lpszLocaleID) == 0)
1254	1243	lpMapEntry = &localeMap[i];
1255	1244
1256	1245	if (lpMapEntry == NULL)

1283	1272	ASSERT(lppszLocaleName != NULL);
1284	1273
1285	1274	for (unsigned i = 0; !lpMapEntry && i < arraySize(localeMap); ++i)
1286		if (stricmp(localeMap[i].lpszLocaleID, lpszLocaleID) == 0)
	1275	if (strcasecmp(localeMap[i].lpszLocaleID, lpszLocaleID) == 0)
1287	1276	lpMapEntry = &localeMap[i];
1288	1277
1289	1278	if (lpMapEntry == NULL)

1432	1421	createSortKeyData(wstrTmp.c_str(), nCap, locale, lpcbKey, lppKey);
1433	1422	#endif
1434	1423	}
1435
1436	1424
1437	1425	/**
1438	1426	* Create a locale independant blob that can be used to sort

+9

-9

configure.ac less more

215	215	])
216	216	AC_SUBST([tmpfilesdir])
217	217
	218	dnl Not all files will be installed to ${prefix}, so we need to cheat a bit
	219	dnl to make "distcheck" succeed.
	220	AC_ARG_WITH([dcprefix],
	221	[AS_HELP_STRING([Extra path inserted for distcheck])],
	222	[dcprefix="$withval"])
	223	AC_SUBST([dcprefix])
	224
218	225	# stats client requires ncurses(w) for --top
219	226	# check wide version before non-wide version
220	227	AC_DEFUN([LIBNCURSES_WITH_CONFIG],[

241	248	])
242	249	LIBNCURSES_WITH_CONFIG
243	250
244		AC_CHECK_HEADERS([syslog.h sys/un.h sys/stat.h])
245		AC_CHECK_FUNCS([timegm getpeereid getpwnam_r vsyslog vsnprintf_l])
	251	AC_CHECK_HEADERS([syslog.h sys/un.h sys/stat.h malloc.h])
	252	AC_CHECK_FUNCS([mallinfo timegm getpeereid getpwnam_r vsyslog vsnprintf_l])
246	253
247	254
248	255	#

745	752	m4lcommon/include/kopano/Makefile
746	753	php-ext/Makefile php7-ext/Makefile
747	754	provider/Makefile
748		provider/client/Makefile
749		provider/contacts/Makefile
750		provider/common/Makefile
751	755	provider/include/Makefile
752		provider/libserver/Makefile
753		provider/plugins/Makefile
754		provider/server/Makefile
755		provider/soap/Makefile
756	756	inetmapi/Makefile
757	757	inetmapi/include/inetmapi/Makefile
758	758	spooler/Makefile

+1

-0

doc/Makefile.am less more

5	5	kopano-admin.8 \
6	6	kopano-archiver.8 kopano-archiver.cfg.5 \
7	7	kopano-autorespond.8 \
	8	kopano-cfgchecker.8 \
8	9	kopano-dagent.8 kopano-dagent.cfg.5 \
9	10	kopano-mr-accept.8 kopano-mr-process.8 \
10	11	kopano-fsck.1 \

+29

-5

doc/manual.xml less more

603	603	<title>Config</title>
604	604
605	605	<para>Normally, no configuration file is used or required. The
606		following options can be set in the configuation file:</para>
	606	following options can be set in the configuration file:</para>
607	607
608	608	<variablelist>
609	609	<varlistentry>

2728	2728	</para>
2729	2729	</listitem>
2730	2730	</varlistentry>
	2731
	2732	<varlistentry>
	2733	<term><option>--utf8</option></term>
	2734	<listitem>
	2735	<para>Force the current locale to UTF-8</para>
	2736	</listitem>
	2737	</varlistentry>
2731	2738	</variablelist>
2732	2739
2733	2740	<para>

2787	2794	checking is performed. This way, you can use any config file
2788	2795	from a kopano program, eg. kopano-spooler or kopano-dagent, to
2789	2796	load SSL settings.</para><para>The following options can be set in the
2790		configuation file:</para>
	2797	configuration file:</para>
2791	2798
2792	2799	<variablelist>
2793	2800	<varlistentry>

3922	3929	</listitem>
3923	3930	</varlistentry>
3924	3931
	3932	<varlistentry>
	3933	<term><option>allocator_library</option></term>
	3934	<listitem>
	3935
	3936	<para>This setting allows to preload a special library (such
	3937	as an allocator). On startup, the server will set the
	3938	LD_PRELOAD environment variable for itself and then
	3939	re-execute itself to get it loaded with high priority. If
	3940	this option is empty, the default system allocator (from
	3941	libc) will be used instead, which is probably a better choice
	3942	when debugging with gdb, valgrind or ASAN/UBSAN. The
	3943	environment variable KC_ALLOCATOR_DONE may also be set to a
	3944	non-empty value to disable re-exec.</para>
	3945
	3946	<para>Default: <replaceable>libtcmalloc_minimal.so.4</replaceable></para>
	3947	</listitem>
	3948	</varlistentry>
3925	3949	</variablelist>
3926	3950	</refsection>
3927	3951

4800	4824	<para>Retrieve the users and groups information
4801	4825	from the Linux password files. User information
4802	4826	will be read the /etc/passwd file. Passwords will
4803		be checked agains /etc/shadow. Group information
	4827	be checked against /etc/shadow. Group information
4804	4828	will read from /etc/group. Use the
4805	4829	<citerefentry><refentrytitle>kopano-admin</refentrytitle><manvolnum>8</manvolnum></citerefentry>
4806	4830	tool to set Kopano specific attributes on a

5541	5565	<para>An object is defined by this attribute what type
5542	5566	it is, eg. user, group, etc. Every object type should
5543	5567	have a unique value in this attribute in order to define
5544		what which enrty is.</para>
	5568	what which entry is.</para>
5545	5569	<para>The value of this attribute must be specified in the
5546	5570	ldap_*_type_attribute_value settings. Each of those settings
5547	5571	may specify multiple values for the type attribute, separated

6614	6638	<title>User attributes</title>
6615	6639
6616	6640	<para>Not all Kopano attributes can be used from the system
6617		files. The following attibutes are used from the system files:
	6641	files. The following attributes are used from the system files:
6618	6642	</para>
6619	6643
6620	6644	<variablelist>

+2

-36

gateway/Gateway.cpp less more

48	48	#include <kopano/ecversion.h>
49	49
50	50	#include "SSLUtil.h"
51		#include <kopano/stringutil.h>
52	51
53	52	#include "TmpPath.h"
54
55		#ifdef LINUX
56	53	#include <kopano/UnixUtil.h>
57		#endif
58
59	54	#ifdef ZCP_USES_ICU
60	55	#include <unicode/uclean.h>
61	56	#endif

80	75	quit = 1;
81	76	}
82	77
83		#ifdef LINUX
84	78	static void sighup(int sig)
85	79	{
86	80	// In Win32, the signal is sent in a separate, special signal thread. So this test is
87	81	// not needed or required.
88		#ifdef LINUX
89	82	if (bThreads && pthread_equal(pthread_self(), mainthread)==0)
90	83	return;
91		#endif
92	84	if (g_lpConfig) {
93	85	if (!g_lpConfig->ReloadSettings() && g_lpLogger)
94	86	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Unable to reload configuration file, continuing with current settings.");

119	111	generic_sigsegv_handler(g_lpLogger, "Gateway",
120	112	PROJECT_VERSION_GATEWAY_STR, signr, si, uc);
121	113	}
122		#endif
123	114
124	115	static HRESULT running_service(const char szPath, const char servicename);
125	116

161	152	// not required anymore
162	153	delete lpHandlerArgs;
163	154
164		#ifdef LINUX
165	155	// make sure the pipe logger does not exit when this handler exits, but only frees the memory.
166	156	if (dynamic_cast<ECLogger_Pipe*>(lpLogger) != NULL)
167	157	dynamic_cast<ECLogger_Pipe*>(lpLogger)->Disown();
168		#endif
169	158
170	159	std::string inBuffer;
171	160	HRESULT hr;

274	263	bool bIgnoreUnknownConfigOptions = false;
275	264
276	265	ssl_threading_setup();
277
278		#ifdef LINUX
279	266	const char *szConfig = ECConfig::GetDefaultPath("gateway.cfg");
280		#else
281		const char *szConfig = "gateway.cfg";
282		ECNTService ecNTService;
283		#endif
284
285	267	static const configsetting_t lpDefaults[] = {
286	268	{ "server_bind", "" },
287		#ifdef LINUX
288	269	{ "run_as_user", "kopano" },
289	270	{ "run_as_group", "kopano" },
290	271	{ "pid_file", "/var/run/kopano/gateway.pid" },
291	272	{ "running_path", "/var/lib/kopano" },
292	273	{ "process_model", "fork" },
293	274	{ "coredump_enabled", "no" },
294		#endif
295	275	{ "pop3_enable", "yes" },
296	276	{ "pop3_port", "110" },
297	277	{ "pop3s_enable", "no" },

478	458	pthread_attr_t ThreadAttr;
479	459	const char *const interface = g_lpConfig->GetSetting("server_bind");
480	460
481		#ifdef LINUX
482	461	// SIGSEGV backtrace support
483	462	stack_t st;
484	463	struct sigaction act;
485	464
486	465	memset(&st, 0, sizeof(st));
487	466	memset(&act, 0, sizeof(act));
488		#endif
489	467
490	468	if (bThreads) {
491	469	pthread_attr_init(&ThreadAttr);

493	471	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Can't set thread attribute to detached");
494	472	goto exit;
495	473	}
496		#ifdef LINUX
497	474	// 1Mb of stack space per thread
498	475	if (pthread_attr_setstacksize(&ThreadAttr, 1024 * 1024)) {
499	476	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Can't set thread stack size to 1Mb");
500	477	goto exit;
501	478	}
502		#endif
503	479	}
504	480
505	481	bListenPOP3 = (strcmp(g_lpConfig->GetSetting("pop3_enable"), "yes") == 0);
506	482	bListenPOP3s = (strcmp(g_lpConfig->GetSetting("pop3s_enable"), "yes") == 0);
507	483	bListenIMAP = (strcmp(g_lpConfig->GetSetting("imap_enable"), "yes") == 0);
508	484	bListenIMAPs = (strcmp(g_lpConfig->GetSetting("imaps_enable"), "yes") == 0);
509
510	485
511	486	// Setup ssl context
512	487	if ((bListenPOP3s \|\| bListenIMAPs) && ECChannel::HrSetCtx(g_lpConfig, g_lpLogger) != hrSuccess) {

550	525	// Setup signals
551	526	signal(SIGTERM, sigterm);
552	527	signal(SIGINT, sigterm);
553		#ifdef LINUX
554	528	signal(SIGHUP, sighup);
555	529	signal(SIGCHLD, sigchld);
556	530	signal(SIGPIPE, SIG_IGN);

566	540	sigaction(SIGSEGV, &act, NULL);
567	541	sigaction(SIGBUS, &act, NULL);
568	542	sigaction(SIGABRT, &act, NULL);
569		#endif
570
571		#ifdef LINUX
	543
572	544	// Set max open file descriptors to FD_SETSIZE .. higher than this number
573	545	// is a bad idea, as it will start breaking select() calls.
574	546	struct rlimit file_limit;

594	566	if (bThreads == false)
595	567	g_lpLogger = StartLoggerProcess(g_lpConfig, g_lpLogger); // maybe replace logger
596	568	ec_log_set(g_lpLogger);
597		#endif
	569
598	570	hr = MAPIInitialize(NULL);
599	571	if (hr != hrSuccess) {
600	572	g_lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to initialize MAPI: %s (%x)",

763	735
764	736	g_lpLogger->Log(EC_LOGLEVEL_ALWAYS, "POP3/IMAP Gateway will now exit");
765	737
766		#ifdef LINUX
767	738	// in forked mode, send all children the exit signal
768	739	if (bThreads == false) {
769	740	signal(SIGTERM, SIG_IGN);
770	741	kill(0, SIGTERM);
771	742	}
772		#endif
773	743
774	744	// wait max 10 seconds (init script waits 15 seconds)
775	745	for (int i = 10; nChildren != 0 && i != 0; --i) {

783	753	else
784	754	g_lpLogger->Log(EC_LOGLEVEL_NOTICE, "POP3/IMAP Gateway shutdown complete");
785	755
786
787	756	MAPIUninitialize();
788	757
789	758	exit:

793	762
794	763	if (bThreads)
795	764	pthread_attr_destroy(&ThreadAttr);
796
797		#ifdef LINUX
798	765	free(st.ss_sp);
799		#endif
800	766	#ifdef ZCP_USES_ICU
801	767	// cleanup ICU data so valgrind is happy
802	768	u_cleanup();

+4

-86

gateway/IMAP.cpp less more

79	79	return (strInput.compare(0, strPrefix.size(), strPrefix) == 0);
80	80	}
81	81
82		/**
83		* IMAP class constructor
84		*/
85	82	IMAP::IMAP(const char szServerPath, ECChannel lpChannel, ECLogger *lpLogger,
86	83	ECConfig *lpConfig) :
87	84	ClientProto(szServerPath, lpChannel, lpLogger, lpConfig)

115	112	pthread_mutex_init(&m_mIdleLock, NULL);
116	113	}
117	114
118		/**
119		* IMAP class destructor
120		*/
121	115	IMAP::~IMAP() {
122	116	if (m_lpTable)
123	117	m_lpTable->Release();

198	192	*/
199	193	bool IMAP::CaseCompare(const string& strA, const string& strB)
200	194	{
201		return stricmp(strA.c_str(), strB.c_str()) == 0;
	195	return strcasecmp(strA.c_str(), strB.c_str()) == 0;
202	196	}
203	197
204	198	/**

439	433	}
440	434
441	435	// process {} and end of line
442
443	436
444	437	if (strCommand.compare("CAPABILITY") == 0) {
445	438	if (!strvResult.empty()) {

824	817	return hr;
825	818	}
826	819
827
828	820	/**
829	821	* @brief Handles the STARTTLS command
830	822	*

1053	1045
1054	1046	m_lpsIMAPTags->aulPropTag[0] = PROP_ENVELOPE;
1055	1047	}
1056
1057	1048
1058	1049	hr = HrGetSubscribedList();
1059	1050	// ignore error, empty list of subscribed folder

2148	2139	HrSetOneProp(lpMessage, lpPropVal);
2149	2140	}
2150	2141
2151
2152	2142	hr = lpMessage->SaveChanges(KEEP_OPEN_READWRITE \| FORCE_SAVE);
2153	2143	if (hr != hrSuccess) {
2154	2144	hr2 = HrResponse(RESP_TAGGED_NO, strTag, "APPEND error saving message");

2691	2681	}
2692	2682
2693	2683	return strFlags;
2694		}
2695
2696		/**
2697		* Convert MAPI properties to a RFC-822 email address string, with optional fullname
2698		*
2699		* @param[in] lpProps Array of properties containing atleast the tags given in ulEmailPropTag and ulNamePropTag
2700		* @param[in] cValues The number of properties in lpProps
2701		* @param[in] ulEmailPropTag The PropTag to use for the email address
2702		* @param[in] ulNamePropTag The PropTag to use for the fullname
2703		*
2704		* @return String with email address, or empty
2705		*/
2706		std::string IMAP::PropsToEmailAddress(LPSPropValue lpProps, unsigned int cValues, ULONG ulEmailPropTag, ULONG ulNamePropTag)
2707		{
2708		const SPropValue *lpPropEmail = PpropFindProp(lpProps, cValues, ulEmailPropTag);
2709		const SPropValue *lpPropName = PpropFindProp(lpProps, cValues, ulNamePropTag);
2710		std::string strAddress;
2711
2712		if(lpPropEmail && lpPropName && strcmp(lpPropEmail->Value.lpszA, lpPropName->Value.lpszA) == 0) {
2713		strAddress = (string)"<" + lpPropEmail->Value.lpszA + ">";
2714		} else if(lpPropEmail && lpPropName) {
2715		strAddress = (string)"\"" + lpPropName->Value.lpszA + "\" <" + lpPropEmail->Value.lpszA + ">";
2716		} else if(lpPropEmail) {
2717		strAddress = (string)"<" + lpPropEmail->Value.lpszA + ">";
2718		} else {
2719		// Only a name ??
2720		}
2721
2722		return strAddress;
2723	2684	}
2724	2685
2725	2686	/**

2857	2818	enum { EID, IKEY, IMAPID, MESSAGE_FLAGS, FLAG_STATUS, MSG_STATUS, LAST_VERB, NUM_COLS };
2858	2819	SizedSPropTagArray(NUM_COLS, spt) = { NUM_COLS, {PR_ENTRYID, PR_INSTANCE_KEY, PR_EC_IMAP_ID, PR_MESSAGE_FLAGS, PR_FLAG_STATUS, PR_MSG_STATUS, PR_LAST_VERB_EXECUTED} };
2859	2820
2860
2861	2821	// Outlook (express) IDLEs without selecting a folder.
2862	2822	// When sending an error from this command, Outlook loops on the IDLE command forever :(
2863	2823	// Therefore, we can never return an HrResultBad() or ...No() here, so we always "succeed"

2907	2867	hr = HrResponse(RESP_CONTINUE, "waiting for notifications");
2908	2868
2909	2869	pthread_mutex_unlock(&m_mIdleLock);
2910
2911	2870
2912	2871	exit:
2913	2872	if (hr != hrSuccess \|\| hr2 != hrSuccess) {

3336	3295
3337	3296	hr = HrGetOneProp(lpPublicStore, PR_IPM_PUBLIC_FOLDERS_ENTRYID, &lpPropVal);
3338	3297	if (hr != hrSuccess) {
3339		lpLogger->Log(EC_LOGLEVEL_WARNING, "Public store is enabled in configuation, but Public Folders inside public store could not be found.");
	3298	lpLogger->Log(EC_LOGLEVEL_WARNING, "Public store is enabled in configuration, but Public Folders inside public store could not be found.");
3340	3299	hr = hrSuccess;
3341	3300	goto exit;
3342	3301	}

3344	3303	// make public folder folders list
3345	3304	hr = HrGetSubTree(lstFolders, lpPropVal->Value.bin, PUBLIC_FOLDERS_NAME, --lstFolders.end());
3346	3305	if (hr != hrSuccess) {
3347		lpLogger->Log(EC_LOGLEVEL_WARNING, "Public store is enabled in configuation, but Public Folders inside public store could not be found.");
	3306	lpLogger->Log(EC_LOGLEVEL_WARNING, "Public store is enabled in configuration, but Public Folders inside public store could not be found.");
3348	3307	hr = hrSuccess;
3349	3308	}
3350	3309

3352	3311	MAPIFreeBuffer(lpPropVal);
3353	3312	MAPIFreeBuffer(lpEntryID);
3354	3313	return hr;
3355		}
3356
3357		bool IMAP::IsSubscribed(BinaryArray sEntryId) {
3358		vector<BinaryArray>::const_iterator iFld;
3359
3360		iFld = find(m_vSubscriptions.begin(), m_vSubscriptions.end(), sEntryId);
3361		return iFld != m_vSubscriptions.end();
3362	3314	}
3363	3315
3364	3316	/**

4920	4872	return hr;
4921	4873	}
4922	4874
4923		/**
4924		* Returns the INTERNALDATE for a given message. The value comes
4925		* either from PR_MESSAGE_DELIVERY_TIME or PR_CLIENT_SUBMIT_TIME.
4926		*
4927		* @param[out] strResponse the INTERNALDATE reply for the given message
4928		* @param[in] lpMessage the MAPI message to get the date for
4929		*
4930		* @return MAPI Error code
4931		*/
4932		HRESULT IMAP::HrGetMessageInterDate(string &strResponse, LPMESSAGE lpMessage) {
4933		HRESULT hr = hrSuccess;
4934		LPSPropValue lpPropVal = NULL;
4935
4936		if (!lpMessage) {
4937		hr = MAPI_E_CALL_FAILED;
4938		goto exit;
4939		}
4940
4941		strResponse += "INTERNALDATE ";
4942		if (HrGetOneProp(lpMessage, PR_MESSAGE_DELIVERY_TIME, &lpPropVal) == hrSuccess
4943		\|\| HrGetOneProp(lpMessage, PR_CLIENT_SUBMIT_TIME, &lpPropVal) == hrSuccess) {
4944		strResponse += "\"";
4945		strResponse += FileTimeToString(lpPropVal->Value.ft);
4946		strResponse += "\"";
4947		} else {
4948		strResponse += "NIL";
4949		}
4950
4951		exit:
4952		MAPIFreeBuffer(lpPropVal);
4953		return hr;
4954		}
4955
4956	4875	/*
4957	4876	* RFC 3501, section 6.4.5:
4958	4877	*

6218	6137	lpExtraRestriction[1].res.resAnd.lpRes[1].res.resProperty.relop = RELOP_GT;
6219	6138	lpExtraRestriction[1].res.resAnd.lpRes[1].res.resProperty.ulPropTag = PR_MESSAGE_SIZE;
6220	6139	lpExtraRestriction[1].res.resAnd.lpRes[1].res.resProperty.lpProp = lpPropVal;
6221
6222	6140
6223	6141	ulStartCriteria += 2;
6224	6142	// NEW done with ALL

7787	7705	goto exit;
7788	7706	}
7789	7707
7790		result = stricmp(lpProp->Value.lpszA, "IPM") == 0 \|\| stricmp(lpProp->Value.lpszA, "IPF.NOTE") == 0;
	7708	result = strcasecmp(lpProp->Value.lpszA, "IPM") == 0 \|\| strcasecmp(lpProp->Value.lpszA, "IPF.NOTE") == 0;
7791	7709
7792	7710	exit:
7793	7711	MAPIFreeBuffer(lpProp);

+0

-3

gateway/IMAP.h less more

297	297
298	298	/* subscribed folders */
299	299	vector<BinaryArray> m_vSubscriptions;
300		bool IsSubscribed(BinaryArray sEntryId);
301	300	HRESULT HrGetSubscribedList();
302	301	HRESULT HrSetSubscribedList();
303	302	HRESULT ChangeSubscribeList(bool bSubscribe, ULONG cbEntryID, LPENTRYID lpEntryID);

319	318	std::string HrEnvelopeSender(LPMESSAGE lpMessage, ULONG ulTagName, ULONG ulTagEmail, std::string& strCharset, bool bIgnore);
320	319	HRESULT HrGetMessageEnvelope(string &strResponse, LPMESSAGE lpMessage);
321	320	HRESULT HrGetMessageFlags(string &strResponse, LPMESSAGE lpMessage, bool bRecent);
322		HRESULT HrGetMessageInterDate(string &strResponse, LPMESSAGE lpMessage);
323	321
324	322	HRESULT HrGetMessagePart(string &strMessagePart, string &strMessage, string strPartName);
325	323

363	361
364	362	// Various conversion functions
365	363	string PropsToFlags(LPSPropValue lpProps, unsigned int cValues, bool bRecent, bool bRead);
366		string PropsToEmailAddress(LPSPropValue lpProps, unsigned int cValues, ULONG ulEmailPropTag, ULONG ulNamePropTag);
367	364
368	365	void HrParseHeaders(const std::string &, std::list<std::pair<std::string, std::string> > &);
369	366	void HrGetSubString(string &strOutput, const std::string &strInput, const std::string &strBegin, const std::string &strEnd);

+1

-0

gateway/Makefile.am less more

7	7
8	8	sbin_PROGRAMS = kopano-gateway
9	9	noinst_DATA = kopano-gateway.ldx
	10	CLEANFILES = ${noinst_DATA}
10	11
11	12	kopano_gateway_LDADD = ${top_builddir}/inetmapi/libkcinetmapi.la \
12	13	${top_builddir}/mapi4linux/src/libmapi.la \

+2

-2

global.am less more

0	0	# -- Makefile --
1	1
2	2	.la.ldd:
3		${AM_V_GEN}${top_srcdir}/lddcheck $< $@
	3	${AM_V_GEN}${top_srcdir}/lddcheck ${top_builddir}/libtool $< $@
4	4
5	5	# There is no good POSIX syntax for the following one.. resort to GNUmake
6	6	%.ldx: %
7		${AM_V_GEN}${top_srcdir}/lddcheck $< $@
	7	${AM_V_GEN}${top_srcdir}/lddcheck ${top_builddir}/libtool $< $@

+0

-3

inetmapi/ECVMIMEUtils.cpp less more

161	161	return hr;
162	162	}
163	163
164
165	164	/**
166	165	* Takes a group entry of a recipient table and expands the recipients for the group recursively by adding them to the recipients list
167	166	*

315	314	return hr;
316	315	}
317	316
318
319	317	// This function does not catch the vmime exception
320	318	// it should be handled by the calling party.
321	319

386	384	if (mapiTransport && HrGetOneProp(lpMessage, PR_ORIGINATOR_DELIVERY_REPORT_REQUESTED, &ptrDeliveryReport) == hrSuccess && ptrDeliveryReport->Value.b == TRUE) {
387	385	mapiTransport->requestDSN(true, "");
388	386	}
389
390	387
391	388	// Generate the message, "stream" it and delegate the sending
392	389	// to the generic send() function.

+0

-14

inetmapi/MAPISMTPTransport.cpp less more

66	66	#include "vmime/net/tls/TLSSecuredConnectionInfos.hpp"
67	67	#endif // VMIME_HAVE_TLS_SUPPORT
68	68
69
70	69	// Helpers for service properties
71	70	#define GET_PROPERTY(type, prop) \
72	71	(getInfos().getPropertyValue <type>(getSession(), \

83	82	namespace net {
84	83	namespace smtp {
85	84
86
87	85	MAPISMTPTransport::MAPISMTPTransport(ref <session> sess, ref <security::authenticator> auth, const bool secured)
88	86	: transport(sess, getInfosInstance(), auth), m_socket(NULL),
89	87	m_authentified(false), m_extendedSMTP(false), m_timeoutHandler(NULL),

91	89	m_bDSNRequest(false)
92	90	{
93	91	}
94
95	92
96	93	MAPISMTPTransport::~MAPISMTPTransport()
97	94	{

215	212	m_authentified = true;
216	213	}
217	214
218
219	215	void MAPISMTPTransport::helo()
220	216	{
221	217	// First, try Extended SMTP (ESMTP)

280	276	}
281	277	}
282	278	}
283
284	279
285	280	void MAPISMTPTransport::authenticate()
286	281	{

327	322	// No other authentication method is possible
328	323	throw exceptions::authentication_error("All authentication methods failed");
329	324	}
330
331	325
332	326	#if VMIME_HAVE_SASL_SUPPORT
333	327

456	450
457	451	#endif // VMIME_HAVE_SASL_SUPPORT
458	452
459
460	453	#if VMIME_HAVE_TLS_SUPPORT
461	454
462	455	void MAPISMTPTransport::startTLS()

499	492
500	493	#endif // VMIME_HAVE_TLS_SUPPORT
501	494
502
503	495	bool MAPISMTPTransport::isConnected() const
504	496	{
505	497	return (m_socket && m_socket->isConnected() && m_authentified);

513	505	internalDisconnect();
514	506	}
515	507
516
517	508	void MAPISMTPTransport::internalDisconnect()
518	509	{
519	510	try

537	528	m_cntInfos = NULL;
538	529	}
539	530
540
541	531	void MAPISMTPTransport::noop()
542	532	{
543	533	if (!isConnected())

550	540	if (resp->getCode() != 250)
551	541	throw exceptions::command_error("NOOP", resp->getText());
552	542	}
553
554	543
555	544	//
556	545	// Only this function is altered, to return per recipient failure.

705	694	m_socket->send(buffer);
706	695	}
707	696
708
709	697	ref <SMTPResponse> MAPISMTPTransport::readResponse()
710	698	{
711	699	ref <SMTPResponse> resp = SMTPResponse::readResponse(m_socket, m_timeoutHandler);

714	702	return resp;
715	703	}
716	704
717
718
719	705	// Service infos
720	706
721	707	SMTPServiceInfos MAPISMTPTransport::sm_infos(false);

+16

-27

inetmapi/MAPIToVMIME.cpp less more

135	135	#define PR_EC_OUTLOOK_VERSION PROP_TAG(PT_STRING8, 0x81F4)
136	136
137	137	/**
138		* Default constructor
139		*
140	138	* Inits the class with empty/default values.
141	139	*/
142	140	MAPIToVMIME::MAPIToVMIME()

148	146	}
149	147
150	148	/**
151		* Constructor with parameters
152		*
153	149	* @param[in] lpSession current mapi session, used to open contact entryid's
154	150	* @param[in] lpAddrBook global addressbook
155	151	* @param[in] newlogger logger object

175	171	m_lpSession = lpSession;
176	172	}
177	173
178		/**
179		* Destructor
180		*/
181	174	MAPIToVMIME::~MAPIToVMIME()
182	175	{
183	176	lpLogger->Release();

344	337	std::string strBoundary;
345	338	bool bSendBinary = true;
346	339	MapiToICal *mapiical = NULL;
347
348	340
349	341	pPropAttachNum = PpropFindProp(lpRow->lpProps, lpRow->cValues, PR_ATTACH_NUM);
350	342	if (pPropAttachNum == NULL) {

649	641	strMedType = "video/x-msvideo";
650	642	}
651	643
652
653	644	else {
654	645	strMedType = "application/octet-stream";
655	646	}

823	814	std::string name = vmField->getName();
824	815
825	816	// Received checks start of string to accept Received-SPF
826		if (strnicmp(name.c_str(), vmime::fields::RECEIVED, strlen(vmime::fields::RECEIVED)) == 0 \|\|
827		stricmp(name.c_str(), vmime::fields::RETURN_PATH) == 0) {
	817	if (strncasecmp(name.c_str(), vmime::fields::RECEIVED, strlen(vmime::fields::RECEIVED)) == 0 \|\|
	818	strcasecmp(name.c_str(), vmime::fields::RETURN_PATH) == 0) {
828	819	// Insert in same order at start of headers
829	820	vmHeader->insertFieldBefore(j++, vmField);
830		} else if (strnicmp(name.c_str(), "list-", strlen("list-")) == 0 \|\|
831		stricmp(name.c_str(), "precedence") == 0) {
	821	} else if (strncasecmp(name.c_str(), "list-", strlen("list-")) == 0 \|\|
	822	strcasecmp(name.c_str(), "precedence") == 0) {
832	823	// Just append at the end of this list, order is not important
833	824	vmHeader->appendField(vmField->clone().dynamicCast<vmime::headerField>());
834	825	}

983	974	goto exit;
984	975	}
985	976
986		if(stricmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note.IPNNRN") == 0)
	977	if(strcasecmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note.IPNNRN") == 0)
987	978	dispo.setType(vmime::dispositionTypes::DELETED);
988		else // if(stricmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note.IPNRN") == 0)
	979	else // if(strcasecmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note.IPNRN") == 0)
989	980	dispo.setType(vmime::dispositionTypes::DISPLAYED);
990	981
991	982	strMDNText.clear();// Default Empty body

1124	1115	m_vmCharset = MAPI_CHARSET_STRING;
1125	1116	}
1126	1117
1127		if (strnicmp(lpMsgClass->Value.lpszA, "IPM.Note", 8) && strnicmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note", 15)) {
	1118	if (strncasecmp(lpMsgClass->Value.lpszA, "IPM.Note", 8) && strncasecmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note", 15)) {
1128	1119	// Outlook sets some other incorrect charset for meeting requests and such,
1129	1120	// so for non-email we upgrade this to utf-8
1130	1121	m_vmCharset = MAPI_CHARSET_STRING;

1138	1129
1139	1130	// Add iconv tag to convert non-exising chars without a fuss
1140	1131	m_strCharset = m_vmCharset.getName() + "//TRANSLIT";
1141		if ((stricmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note.IPNNRN") == 0 \|\|
1142		stricmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note.IPNRN") == 0)
	1132	if ((strcasecmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note.IPNNRN") == 0 \|\|
	1133	strcasecmp(lpMsgClass->Value.lpszA, "REPORT.IPM.Note.IPNRN") == 0)
1143	1134	)
1144	1135	{
1145	1136	// Create a read receipt message
1146	1137	hr = BuildMDNMessage(lpMessage, &vmMessage);
1147	1138	if(hr != hrSuccess)
1148	1139	goto exit;
1149		} else if ((stricmp(lpMsgClass->Value.lpszA, "IPM.Note.SMIME.MultiPartSigned") == 0) \|\|
1150		(stricmp(lpMsgClass->Value.lpszA, "IPM.Note.SMIME") == 0))
	1140	} else if ((strcasecmp(lpMsgClass->Value.lpszA, "IPM.Note.SMIME.MultiPartSigned") == 0) \|\|
	1141	(strcasecmp(lpMsgClass->Value.lpszA, "IPM.Note.SMIME") == 0))
1151	1142	{
1152	1143	// - find attachment, and convert to char, and place in lpszRawSMTP
1153	1144	// - normal convert the message, but only from/to headers and such .. nothing else

1218	1209	vmMessage->getHeader()->removeField(vmMessage->getHeader()->findField(vmime::fields::CONTENT_TYPE));
1219	1210	vmMessage->getHeader()->removeField(vmMessage->getHeader()->findField(vmime::fields::CONTENT_TRANSFER_ENCODING));
1220	1211
1221		if (stricmp(lpMsgClass->Value.lpszA, "IPM.Note.SMIME") != 0) {
	1212	if (strcasecmp(lpMsgClass->Value.lpszA, "IPM.Note.SMIME") != 0) {
1222	1213	std::string strRawSMTP = lpszRawSMTP;
1223	1214	vmime::ref<SMIMEMessage> vmSMIMEMessage = vmime::create<SMIMEMessage>();
1224	1215

1678	1669
1679	1670	// keep the original x-mailer header under a different name
1680	1671	// we still want to know that this mail was generated by kopano in the x-mailer header from handleExtraHeaders
1681		if (stricmp(str, "X-Mailer") == 0) {
	1672	if (strcasecmp(str, "X-Mailer") == 0) {
1682	1673	delete [] str;
1683	1674	str = new char[18];
1684	1675	strcpy(str, "X-Original-Mailer");

2077	2068	LPSPropTagArray lpNameTagArray = NULL;
2078	2069	LPSPropValue lpAddressProps = NULL;
2079	2070
2080
2081	2071	if (HrGetOneProp(lpMessage, PR_REPLY_RECIPIENT_ENTRIES, &lpReplyTo) != hrSuccess)
2082	2072	goto exit;
2083	2073
2084	2074	if (lpReplyTo->Value.bin.cb == 0)
2085	2075	goto exit;
2086
2087	2076
2088	2077	lpEntryList = (FLATENTRYLIST *)lpReplyTo->Value.bin.lpb;
2089	2078

2268	2257	strTnefReason = "Force TNEF on request";
2269	2258
2270	2259	// currently no task support for ical
2271		if (iUseTnef <= 0 && lpMessageClass && strnicmp("IPM.Task", lpMessageClass->Value.lpszA, 8) == 0) {
	2260	if (iUseTnef <= 0 && lpMessageClass && strncasecmp("IPM.Task", lpMessageClass->Value.lpszA, 8) == 0) {
2272	2261	iUseTnef = 1;
2273	2262	strTnefReason = "Force TNEF because of task request";
2274	2263	}

2293	2282	if (iUseTnef == 1 \|\|
2294	2283	(lpSendAsICal && lpSendAsICal->Value.b) \|\|
2295	2284	(lpSendAsICal && lpOutlookVersion && strcmp(lpOutlookVersion->Value.lpszA, "9.0") == 0) \|\|
2296		(lpMessageClass && (strnicmp("IPM.Note", lpMessageClass->Value.lpszA, 8) != 0) ) \|\|
	2285	(lpMessageClass && (strncasecmp("IPM.Note", lpMessageClass->Value.lpszA, 8) != 0) ) \|\|
2297	2286	bestBody == realRTF)
2298	2287	{
2299	2288	// Send either TNEF or iCal data

2305	2294	* Send TNEF information for this message if we really need to, or otherwise iCal
2306	2295	*/
2307	2296
2308		if (lstOLEAttach.size() == 0 && iUseTnef <= 0 && lpMessageClass && (strnicmp("IPM.Note", lpMessageClass->Value.lpszA, 8) != 0)) {
	2297	if (lstOLEAttach.size() == 0 && iUseTnef <= 0 && lpMessageClass && (strncasecmp("IPM.Note", lpMessageClass->Value.lpszA, 8) != 0)) {
2309	2298	// iCAL
2310	2299	string ical, method;
2311	2300	vmime::ref<mapiAttachment> vmAttach = NULL;

+3

-2

inetmapi/Makefile.am less more

6	6	-I$(top_srcdir)/mapi4linux/include -I$(top_srcdir)/provider/common \
7	7	-I${top_srcdir}/common -I${top_srcdir}/m4lcommon \
8	8	-I${top_srcdir}/libfreebusy -I${top_srcdir}/libicalmapi \
9		-I/usr/include/libxml2
	9	${XML2_CFLAGS}
10	10
11	11	lib_LTLIBRARIES = libkcinetmapi.la
12	12	noinst_DATA = libkcinetmapi.ldd
	13	CLEANFILES = ${noinst_DATA}
13	14
14	15	# Add '-z now' -> -Wl,-z, -Wl,now to LD flags so that we do early binding of symbols. This fixes
15	16	# a problem in which libvmime attempts to resolve a symbol in libinetmapi.so during the unload

30	31	#CXXLD=--tag=none gcc
31	32
32	33	libinetmapidir = $(includedir)/inetmapi
33		libinetmapi_HEADERS = ECMapiUtils.h ECVMIMEUtils.h \
	34	noinst_HEADERS = ECMapiUtils.h ECVMIMEUtils.h \
34	35	MAPIToVMIME.h VMIMEToMAPI.h \
35	36	outputStreamMAPIAdapter.h \
36	37	inputStreamMAPIAdapter.h \

+6

-21

inetmapi/VMIMEToMAPI.cpp less more

78	78	static const char im_charset_unspec[] = "unspecified";
79	79
80	80	/**
81		* VMIMEToMAPI default constructor
82		*
83	81	* Default empty constructor for the inetmapi library. Sets all member
84	82	* values to sane defaults.
85	83	*/

93	91	}
94	92
95	93	/**
96		* VMIMEToMAPI parameterized constructor.
97		*
98	94	* Adds user set addressbook (to minimize opens on this object) and delivery options.
99	95	*
100	96	* @param[in] lpAdrBook Addressbook of a user.

114	110	m_lpDefaultDir = NULL;
115	111	}
116	112
117		/**
118		* VMIMEToMAPI destructor.
119		*/
120	113	VMIMEToMAPI::~VMIMEToMAPI()
121	114	{
122	115	lpLogger->Release();

245	238	MAPI_CREATE\|MAPI_MODIFY, (LPUNKNOWN *)&lpStream);
246	239	if (hr != hrSuccess)
247	240	goto exit;
248
249	241
250	242	outputStreamMAPIAdapter os(lpStream);
251	243	// get the content-type string from the headers

1174	1166	return hr;
1175	1167	}
1176	1168
1177
1178	1169	/**
1179	1170	* Adds recipients from a vmime list to rows for the recipient
1180	1171	* table. Starts adding at offset in cEntries member of the lpRecipients

1380	1371	goto exit;
1381	1372	}
1382	1373
1383
1384	1374	if (!m_lpDefaultDir) {
1385	1375	hr = m_lpAdrBook->GetDefaultDir(&cbDDEntryID, &lpDDEntryID);
1386	1376	if (hr != hrSuccess)

1510	1500	}
1511	1501	++cValues;
1512	1502	}
1513
1514	1503
1515	1504	if (PROP_TYPE(lpPropsList->aulPropTag[6]) != PT_NULL) {
1516	1505	lpProp = PpropFindProp(lpAdrList->aEntries[0].rgPropVals, lpAdrList->aEntries[0].cValues, PR_SMTP_ADDRESS_W);

1771	1760	sAttProps[2].ulPropTag = PR_ATTACH_FLAGS;
1772	1761	sAttProps[2].Value.ul = 0;
1773	1762
1774		hr = ptrAttach->SetProps(3, (LPSPropValue)sAttProps, NULL);
	1763	hr = ptrAttach->SetProps(3, sAttProps, NULL);
1775	1764	if (hr != hrSuccess) {
1776	1765	lpLogger->Log(EC_LOGLEVEL_ERROR, "dissect_ical-1811: Unable to create message attachment for ical data: %s (%x)", GetMAPIErrorMessage(hr), hr);
1777	1766	goto exit;

2560	2549	return hr;
2561	2550	}
2562	2551
2563
2564	2552	/**
2565	2553	* Handle Attachments.. Now works for inlines and attachments...
2566	2554	*

2793	2781	static vmime::charset vtm_upgrade_charset(const vmime::charset &cset)
2794	2782	{
2795	2783	for (size_t i = 0; i < ARRAY_SIZE(charsetHelper::fixes); ++i)
2796		if (stricmp(charsetHelper::fixes[i].original, cset.getName().c_str()) == 0)
	2784	if (strcasecmp(charsetHelper::fixes[i].original, cset.getName().c_str()) == 0)
2797	2785	return charsetHelper::fixes[i].update;
2798	2786
2799	2787	return cset;

2842	2830	while (isspace(in)) / skip WS after ';' */
2843	2831	++in;
2844	2832	}
2845		if (strnicmp(in, "charset=", 8) == 0) {
	2833	if (strncasecmp(in, "charset=", 8) == 0) {
2846	2834	in += 8;
2847	2835	cset = in;
2848	2836	while (!isspace(in) && in != ';' && *in != '\0')

3078	3066	if (hr != hrSuccess)
3079	3067	goto exit;
3080	3068
3081		if (strnicmp(lpMessageClass->Value.lpszA, "IPM.Schedule.Meeting.", strlen( "IPM.Schedule.Meeting." )) == 0)
	3069	if (strncasecmp(lpMessageClass->Value.lpszA, "IPM.Schedule.Meeting.", strlen( "IPM.Schedule.Meeting." )) == 0)
3082	3070	{
3083	3071	// IPM.Schedule.Meeting.*
3084	3072

3479	3467
3480	3468	// ((cc),(cc))
3481	3469	try {
3482		list<string> lAddr;
3483	3470	vmime::ref<vmime::addressList> aList = vmHeader->Cc()->getValue().dynamicCast<vmime::addressList>();
3484	3471	int aCount = aList->getAddressCount();
3485	3472	for (int i = 0; i < aCount; ++i)

3492	3479
3493	3480	// ((bcc),(bcc))
3494	3481	try {
3495		list<string> lAddr;
3496	3482	vmime::ref<vmime::addressList> aList = vmHeader->Bcc()->getValue().dynamicCast<vmime::addressList>();
3497	3483	int aCount = aList->getAddressCount();
3498	3484	for (int i = 0; i < aCount; ++i)

3612	3598
3613	3599	lBodyStructure.clear();
3614	3600	lBodyStructure.push_back(strBodyStructure);
3615
3616	3601
3617	3602	// body:
3618	3603	// (<SUB> "subtype")

3871	3856	return lines;
3872	3857	}
3873	3858
3874
3875	3859	// options.h code
3876	3860	/**
3877	3861	* Set all members in the delivery_options struct to their defaults

3906	3890	sopt->charset_upgrade = const_cast<char *>("windows-1252");
3907	3891	sopt->allow_send_to_everyone = true;
3908	3892	sopt->enable_dsn = true;
3909		}
	3893	sopt->always_expand_distr_list = false;
	3894	}

+0

-1

inetmapi/inetmapi.cpp less more

217	217	return hr;
218	218	}
219	219
220
221	220	// Read properties from lpMessage object and to internet rfc2822 format message
222	221	// then send it using the provided ECSender object
223	222	INETMAPI_API HRESULT IMToINet(IMAPISession lpSession, IAddrBook lpAddrBook, IMessage lpMessage, ECSender mailer_base, sending_options sopt, ECLogger *lpLogger)

+0

-1

inetmapi/mapiAttachment.cpp less more

37	37	{
38	38	vmime::defaultAttachment::generatePart(part);
39	39
40
41	40	part->getHeader()->ContentDisposition().dynamicCast <vmime::contentDispositionField>()->setFilename(m_filename);
42	41
43	42	vmime::ref<vmime::contentTypeField> ctf = part->getHeader()->ContentType().dynamicCast <vmime::contentTypeField>();

+0

-14

inetmapi/mapiTextPart.cpp less more

51	51	#include "vmime/emptyContentHandler.hpp"
52	52	#include "vmime/stringContentHandler.hpp"
53	53
54
55	54	namespace vmime
56	55	{
57	56

82	81	else
83	82	return (mediaType(mediaTypes::TEXT, mediaTypes::TEXT_HTML));
84	83	}
85
86	84
87	85	int mapiTextPart::getPartCount() const
88	86	{

96	94	return count;
97	95	}
98	96
99
100	97	void mapiTextPart::generateIn(ref <bodyPart> /* message */, ref <bodyPart> parent) const
101	98	{
102	99	// Plain text

194	191	}
195	192	}
196	193
197
198	194	void mapiTextPart::findEmbeddedParts(const bodyPart& part,
199	195	std::vector <ref <const bodyPart> >& cidParts, std::vector <ref <const bodyPart> >& locParts)
200	196	{

227	223	findEmbeddedParts(*p, cidParts, locParts);
228	224	}
229	225	}
230
231	226
232	227	void mapiTextPart::addEmbeddedObject(const bodyPart& part, const string& id)
233	228	{

253	248	part.getBody()->getEncoding(), id, type, string(), string()));
254	249	}
255	250
256
257	251	void mapiTextPart::parse(ref <const bodyPart> message, ref <const bodyPart> parent, ref <const bodyPart> textPart)
258	252	{
259	253	// Search for possible embedded objects in the _whole_ message.

328	322	m_plainText = vmime::create <emptyContentHandler>();
329	323	}
330	324	}
331
332	325
333	326	bool mapiTextPart::findPlainTextPart(const bodyPart& part, const bodyPart& parent, const bodyPart& textPart)
334	327	{

462	455	throw exceptions::no_object_found();
463	456	}
464	457
465
466	458	bool mapiTextPart::hasObject(const string& id_) const
467	459	{
468	460	const string id = cleanId(id_);

477	469	return false;
478	470	}
479	471
480
481	472	const string mapiTextPart::addObject(ref <contentHandler> data,
482	473	const encoding& enc, const mediaType& type)
483	474	{

487	478	return "CID:" + addObject(data, enc, type, id);
488	479	}
489	480
490
491	481	const string mapiTextPart::addObject(ref <contentHandler> data, const mediaType& type)
492	482	{
493	483	return addObject(data, encoding::decide(data), type);
494	484	}
495
496	485
497	486	const string mapiTextPart::addObject(const string& data, const mediaType& type)
498	487	{

505	494	m_objects.push_back(vmime::create <embeddedObject>(data, enc, id, type, name, loc));
506	495	return (id);
507	496	}
508
509	497
510	498	// static
511	499	const string mapiTextPart::cleanId(const string& id)

524	512	}
525	513	}
526	514
527
528
529	515	//
530	516	// mapiTextPart::embeddedObject
531	517	//

+1

-13

inetmapi/tnef.cpp less more

82	82	static const char FindMAPIClassByScheduleClass(const char szSClass)
83	83	{
84	84	for (size_t i = 0; i < ARRAY_SIZE(sClassMap); ++i)
85		if(stricmp(szSClass, sClassMap[i].szScheduleClass) == 0) {
	85	if(strcasecmp(szSClass, sClassMap[i].szScheduleClass) == 0) {
86	86	return sClassMap[i].szMAPIClass;
87	87	}
88	88
89	89	return NULL;
90	90	}
91
92		#if 0
93		static const char FindScheduleClassByMAPIClass(const char szMAPIClass)
94		{
95		for (size_t i = 0; i < ARRAY_SIZE(sClassMap); ++i)
96		if(stricmp(szMAPIClass, sClassMap[i].szMAPIClass) == 0) {
97		return sClassMap[i].szScheduleClass;
98		}
99
100		return NULL;
101		}
102		#endif
103	91
104	92	/**
105	93	* Returns TRUE if the given property tag is in the given property tag array

+24

-8

installer/linux/Makefile.am less more

0	0	# -- Makefile --
1	1
2		systemunit_DATA = kopano-dagent.service kopano-gateway.service \
	2	systemunitdir = ${dcprefix}@systemunitdir@
	3	sysusersdir = ${dcprefix}@sysusersdir@
	4	tmpfilesdir = ${dcprefix}@tmpfilesdir@
	5
	6	dist_systemunit_DATA = kopano-dagent.service kopano-gateway.service \
3	7	kopano-ical.service kopano-monitor.service \
4	8	kopano-presence.service kopano-search.service \
5	9	kopano-server.service kopano-spooler.service
6		sysusers_DATA = kopano-sysusers.conf
7		tmpfiles_DATA = kopano-tmpfiles.conf
	10	dist_sysusers_DATA = kopano-sysusers.conf
	11	dist_tmpfiles_DATA = kopano-tmpfiles.conf
8	12
9	13	config_files = \
10	14	server.cfg unix.cfg ldap.propmap.cfg presence.cfg \

59	63	db-calc-storesize db-convert-attachments-to-files \
60	64	createuser.dotforward ssl-certificates.sh ldap-switch-sendas.pl \
61	65	audit-parse.pl db-remove-orphaned-attachments \
62		${top_srcdir}/tools/python-scripts/optimize-imap.py ${top_srcdir}/tools/python-scripts/update-resource-recipients
	66	${top_srcdir}/tools/python-scripts/update-resource-recipients
	67	kgwdocdir = ${docdir}/../kopano-gateway
	68	dist_kgwdoc_DATA = ${top_srcdir}/tools/python-scripts/optimize-imap.py
63	69
64	70	BUILT_SOURCES = ldap.openldap.cfg ldap.active-directory.cfg
65	71

89	95	sysconf_certdir = ${sysconfdir}/kopano/report-ca
90	96
91	97	config_files += $(BUILT_SOURCES)
92		EXTRA_DIST = $(BUILT_SOURCES) \
	98	EXTRA_DIST = ${BUILT_SOURCES} ldap.m4 \
93	99	$(rhel_initscript_files) $(suse_initscript_files) $(cbs4_initscript_files) $(alt_initscript_files) \
94	100	sysconfig.txt
95	101

107	113	newf=`echo "$$f" \| sed -e 's/$kopano-.$.init./\1/'`; \
108	114	mv -v "${DESTDIR}${sysconf_initdir}/$$f" "${DESTDIR}${sysconf_initdir}/$$newf"; \
109	115	done
110		mkdir -p ${DESTDIR}/${docdir}/../kopano-gateway
111		mv -v ${DESTDIR}/${docdir}/optimize-imap.py ${DESTDIR}/${docdir}/../kopano-gateway
112		rm -f ${DESTDIR}/${sysconf_configdir}/example-msr.cfg
	116
	117	uninstall-local:
	118	rm -f "${DESTDIR}${sysconf_rotatedir}/kopano" \
	119	"${DESTDIR}${sysconf_crondir}/kopano-client-update"
	120	if test ${DISTRO} = "sles" -o ${DISTRO} = "suse"; then \
	121	rm -f "${DESTDIR}${sysconf_sysconfigdir}/sysconfig.kopano"; \
	122	elif test ${DISTRO} = "rhel" -o ${DISTRO} = "alt"; then \
	123	rm -f "${DESTDIR}${sysconf_sysconfigdir}/kopano"; \
	124	fi
	125	for f in ${sysconf_init_SCRIPTS}; do \
	126	newf=$$(echo "$$f" \| sed -e 's/$kopano-.$.init./\1/'); \
	127	rm -f "${DESTDIR}${sysconf_initdir}/$$newf"; \
	128	done

+1

-1

installer/linux/kopano-presence.init.debi less more

63	63	$0 start
64	64	;;
65	65	status)
66		status_of_proc "$PRESENCE" "$NAME" && exit 0 \|\| exit $?
	66	status_of_proc -p $PIDFILE "$PRESENCE" "$NAME" && exit 0 \|\| exit $?
67	67	;;
68	68	reload\|force-reload)
69	69	log_begin_msg "Reloading $DESC: $NAME"

+1

-1

installer/linux/kopano-search.init.debi less more

62	62	$0 start
63	63	;;
64	64	status)
65		status_of_proc "$SEARCH" "$NAME" && exit 0 \|\| exit $?
	65	status_of_proc -p $PIDFILE "$SEARCH" "$NAME" && exit 0 \|\| exit $?
66	66	;;
67	67	reload\|force-reload)
68	68	log_begin_msg "Reloading $DESC: $NAME"

+0

-525

~~installer/linux/ldapms.active-directory.cfg~~ less more

0		##############################################################
1		# LDAP/ACTIVE DIRECTORY USER PLUGIN SETTINGS
2		#
3		# Any of these directives that are required, are only required if the
4		# userplugin parameter is set to ldap.
5
6		# LDAP host name/IP address
7		# Optional, default = localhost
8		#ldap_host =
9
10		# LDAP port
11		# Optional, default = 389
12		# Use 636 for ldaps
13		#ldap_port = 389
14
15		# LDAP protocol
16		# Optional, default = ldap
17		# use "ldaps" for SSL encryption. Make sure /etc/ldap/ldap.conf is
18		# configured correctly with TLS_CACERT
19		#ldap_protocol = ldap
20
21		# LDAP URI
22		# Optional, override ldap_host, ldap_port and ldap_protocol if set
23		# e.g. ldaps://servername:port. You may also specify multiple space-separated
24		# URIs
25		#ldap_uri =
26
27		# The charset that strings are stored in on the LDAP server. Normally this
28		# is utf-8, but this can differ according to your setup. The charset specified
29		# here must be supported by your iconv(1) setup. See iconv -l for all charset
30		#ldap_server_charset = utf-8
31
32		# The DN of the user to bind as for normal operations (not used for
33		# authentication if ldap_authentication_method is set to "bind"
34		# Optional, default = empty (anonymous bind)
35		# The userPassword attribute must be readable for this user if the
36		# ldap_authentication_method option is set to password.
37		#ldap_bind_user = cn=Administrator,cn=users,dc=kopano,dc=com
38
39		# LDAP bind password
40		# Optional, default = empty (no password)
41		#ldap_bind_passwd =
42
43		# The timeout for network operations in seconds
44		#ldap_network_timeout = 30
45
46		# When an object (user/group/company) is changed, this attribute will also change:
47		# Active directory: uSNChanged
48		# LDAP: modifyTimestamp
49		#ldap_last_modification_attribute = uSNChanged
50
51		# ldap_page_size limits the number of results from a query that will be downloaded at a time.
52		# Default ADS MaxPageSize is 1000.
53		#ldap_page_size = 1000
54
55		##########
56		# Object settings
57
58		# Top level search base, every object should be available under this tree
59		#ldap_search_base = dc=kopano,dc=com
60
61		# attribute name which is/(should: was) used in ldap_user_search_filter
62		#ldap_object_type_attribute = objectClass
63		#ldap_user_type_attribute_value = user
64		#ldap_group_type_attribute_value = group
65		#ldap_contact_type_attribute_value = contact
66		#ldap_company_type_attribute_value = organizationalUnit
67		#ldap_addresslist_type_attribute_value = kopanoAddresslist
68		#ldap_dynamicgroup_type_attribute_value = kopanoDynamicGroup
69		#ldap_server_type_attribute_value = computer
70
71		##########
72		# There should be no need to edit any values below this line
73		##########
74
75		##########
76		# User settings
77
78		# Extra search for users using this LDAP filter. See ldap_search(3) or RFC
79		# 2254 for details on the filter syntax.
80		#
81		# Hint: Use the kopanoAccount attribute in the filter to differentiate
82		# between non-kopano and kopano users.
83		#
84		# Note: This filter should include contacts.
85		#
86		# Optional, default = empty (match everything)
87		# For active directory, use:
88		# (objectCategory=Person)
89		# For LDAP with posix users:
90		# no need to use the search filter.
91		#ldap_user_search_filter = (objectCategory=Person)
92
93		# unique user id for find the user
94		# Required
95		# For active directory, use:
96		# objectGuid WARNING: This WAS: objectSid Updates WILL fail! **
97		# For LDAP with posixAccount, use:
98		# uidNumber
99		#ldap_user_unique_attribute = objectGuid
100
101		# Type of unique user id
102		# default: text
103		# For active directory, use:
104		# binary
105		# For LDAP with posix user, use:
106		# text
107		#ldap_user_unique_attribute_type = binary
108
109		# Optional, default = cn
110		# For active directory, use:
111		# cn or displayName
112		# For LDAP with posix user, use:
113		# cn
114		#ldap_fullname_attribute = cn
115
116		# Optional, default = uid
117		# Active directory: sAMAccountName
118		# LDAP: uid
119		#ldap_loginname_attribute = sAMAccountName
120
121		# Optional, default = userPassword
122		# Active directory: unicodePwd
123		# LDAP: userPassword
124		#ldap_password_attribute = unicodePwd
125
126		# If set to bind, users are authenticated by trying to bind to the
127		# LDAP tree using their username + password. Otherwise, the
128		# ldap_password_attribute is requested and checked.
129		# Optional, default = bind
130		# Choices: bind, password
131		# Active directory: bind
132		# LDAP: bind
133		#ldap_authentication_method = bind
134
135		# Optional, default = mail
136		# Active directory: mail
137		# LDAP: mail
138		#ldap_emailaddress_attribute = mail
139
140		# Optional, default = kopanoAliases
141		# Active directory: kopanoAliases
142		# LDAP: kopanoAliases
143		#ldap_emailaliases_attribute = otherMailbox
144
145		# Whether the user is an admin. The field is interpreted as a
146		# boolean, 0 and false (case insensitive) meaning no, all other values
147		# yes.
148		# Optional, default = kopanoAdmin
149		# Active directory: kopanoAdmin
150		# LDAP: kopanoAdmin
151		#ldap_isadmin_attribute = kopanoAdmin
152
153		# Whether a user is a non-active user. This means that the user will
154		# not count towards your user count, but the user will also not be
155		# able to log in
156		# Optional, default = kopanoSharedStoreOnly
157		# Active directory: kopanoSharedStoreOnly
158		# LDAP: kopanoSharedStoreOnly
159		#ldap_nonactive_attribute = kopanoSharedStoreOnly
160
161		# A nonactive store, or resource, can be specified to be a user, room or equipment.
162		# Set it to "room" or "equipment" to make such types. If set to empty,
163		# or wrong word, or "user" it will be a nonactive user.
164		# Optional, default = kopanoResourceType
165		# Active directory: kopanoResourceType
166		# LDAP: kopanoResourceType
167		#ldap_resource_type_attribute = kopanoResourceType
168
169		# Numeric resource capacity
170		# Optional, default = kopanoResourceCapacity
171		# Active directory: kopanoResourceCapacity
172		# LDAP: kopanoResourceCapacity
173		#ldap_resource_capacity_attribute = kopanoResourceCapacity
174
175		# Optional
176		# The attribute which indicates which users are allowed
177		# to send on behalf of the selected user
178		#ldap_sendas_attribute = kopanoSendAsPrivilege
179
180		# Optional, default = text
181		# Active directory: dn
182		# LDAP: text
183		#ldap_sendas_attribute_type = dn
184
185		# The attribute of the user and group which is listed in
186		# the ldap_sendas_attribute
187		# Empty default, using ldap_user_unique_attribute
188		#ldap_sendas_relation_attribute = distinguishedName
189
190		# Optional, default = userCertificate
191		# Active directory: userCertificate
192		# LDAP: userCertificate;binary
193		#ldap_user_certificate_attribute = userCertificate
194
195		# Load extra user properties from the propmap file
196		!propmap /etc/kopano/ldap.propmap.cfg
197
198		##########
199		# Group settings
200
201		# Search for groups using this LDAP filter. See ldap_search(3) for
202		# details on the filter syntax.
203		# Hint: Use the kopanoAccount attribute in the filter to differentiate
204		# between non-kopano and kopano groups.
205		# Optional, default = empty (match everything)
206		# For active directory, use:
207		# (objectCategory=Group)
208		# For LDAP with posix groups, use:
209		# no need to set the search filter
210		#ldap_group_search_filter = (objectCategory=Group)
211
212		# unique group id for find the group
213		# Required
214		# For active directory, use:
215		# objectSid
216		# For LDAP with posix group, use:
217		# gidNumber
218		#ldap_group_unique_attribute = objectSid
219
220		# Type of unique group id
221		# default: text
222		# For active directory, use:
223		# binary
224		# For LDAP with posix group, use:
225		# text
226		#ldap_group_unique_attribute_type = binary
227
228		# Optional, default = cn
229		# Active directory: cn
230		# LDAP: cn
231		#ldap_groupname_attribute = cn
232
233		# Optional, default = member
234		# Active directory: member
235		# LDAP: memberUid
236		#ldap_groupmembers_attribute = member
237
238		# Optional, default = text
239		# Active directory: dn
240		# LDAP: text
241		#ldap_groupmembers_attribute_type = dn
242
243		# The attribute of the user which is listed in ldap_groupmember_attribute
244		# Active directory: empty, matching DNs
245		# LDAP: uid, matching users in ldap_loginname_attribute
246		#ldap_groupmembers_relation_attribute =
247
248		# A group can also be used for security, eg. setting permissions on folders.
249		# This makes a group a security group. The kopanoSecurityGroup value is boolean.
250		# Optional, default = kopanoSecurityGroup
251		# Active directory = groupType
252		# LDAP: kopanoSecurityGroup
253		#ldap_group_security_attribute = groupType
254
255		# In ADS servers, a special bitmask action is required on the groupType field.
256		# This is actived by setting the ldap_group_security_attribute_type to "ads"
257		# Otherwise, just the presence of the field will make the group security enabled.
258		# Optional, default = boolean
259		# Active directory = ads
260		# LDAP: boolean
261		#ldap_group_security_attribute_type = ads
262
263		##########
264		# Company settings
265
266		# Search for companies using this LDAP filter.
267		# Hint: Use the kopanoAccount attribute in the filter to differentiate
268		# between non-kopano and kopano companies.
269		# Optional, default = empty (match everything)
270		# For active directory, use:
271		# (objectCategory=Company)
272		# For LDAP with posix users, use:
273		# no need to set the filter
274		#ldap_company_search_filter =
275
276		# unique company id for find the company
277		# Active directory: objectGUID
278		# LDAP: ou
279		#ldap_company_unique_attribute = objectGUID
280
281		# Optional, default = text
282		# Active directory: binary
283		# LDAP: text
284		#ldap_company_unique_attribute_type = binary
285
286		# Optional, default = ou
287		# Active directory: ou
288		# LDAP: ou
289		#ldap_companyname_attribute = ou
290
291		# Optional
292		# The attribute which indicates which companies are allowed
293		# to view the members of the selected company
294		#ldap_company_view_attribute = kopanoViewPrivilege
295
296		# Optional, default = text
297		#ldap_company_view_attribute_type = dn
298
299		# The attribute of the company which is listed in the
300		# ldap_company_view_attribute
301		# Empty default, using ldap_company_unique_attribute
302		#ldap_company_view_relation_attribute =
303
304		# Optional
305		# The attribute which indicates which users from different companies
306		# are administrator over the selected company.
307		#ldap_company_admin_attribute = kopanoAdminPrivilege
308
309		# Optional, default = text
310		# Active directory: dn
311		# LDAP: text
312		#ldap_company_admin_attribute_type = dn
313
314		# The attribute of the company which is listed in the
315		# ldap_company_admin_attribute
316		# Empty default, using ldap_user_unique_attribute
317		#ldap_company_admin_relation_attribute =
318
319		# The attribute which indicates which user is the system administrator
320		# for the specified company.
321		#ldap_company_system_admin_attribute = kopanoSystemAdmin
322
323		# Optional, default = text
324		# Active directory: dn
325		# LDAP: text
326		#ldap_company_system_admin_attribute_type = dn
327
328		# The attribute of the company which is listed in the
329		# ldap_company_system_admin attribute
330		# Empty default, using ldap_user_unique_attribute
331		#ldap_company_system_admin_relation_attribute =
332
333
334		##########
335		# Addresslist settings
336
337		# Add a filter to the addresslist search
338		# Hint: Use the kopanoAccount attribute in the filter to differentiate
339		# between non-kopano and kopano addresslists.
340		# Optional, default = empty (match everything)
341		#ldap_addresslist_search_filter =
342
343		# This is the unique attribute of a addresslist which is never going
344		# to change, unless the addresslist is removed from LDAP. When this
345		# value changes, Kopano will remove the previous addresslist from the
346		# database, and create a new addresslist with this unique value
347		#ldap_addresslist_unique_attribute = cn
348
349		# This value can be "text" or "binary". For OpenLDAP, only text is used.
350		#ldap_addresslist_unique_attribute_type = text
351
352		# This is the name of the attribute on the addresslist object that
353		# specifies the filter to be applied for this addresslist. All users
354		# matching this filter AND matching the default
355		# ldap_user_search_filter will be included in the addresslist
356		#ldap_addresslist_filter_attribute = kopanoFilter
357
358		# This is the name of the attribute on the addresslist object that
359		# specifies the search base to be applied for this addresslist.
360		#ldap_addresslist_search_base_attribute = kopanoBase
361
362		# The attribute containing the name of the addresslist
363		#ldap_addresslist_name_attribute = cn
364
365
366		##########
367		# Dynamicgroup settings
368
369		# Add a filter to the dynamicgroup search
370		# Hint: Use the kopanoAccount attribute in the filter to differentiate
371		# between non-kopano and kopano dynamic groups.
372		# Optional, default = empty (match everything)
373		#ldap_dynamicgroup_search_filter =
374
375		# This is the unique attribute of a dynamicgroup which is never going
376		# to change, unless the dynamicgroup is removed from LDAP. When this
377		# value changes, Kopano will remove the previous dynamicgroup from the
378		# database, and create a new dynamicgroup with this unique value
379		#ldap_dynamicgroup_unique_attribute = cn
380
381		# This value can be "text" or "binary". For OpenLDAP, only text is used.
382		#ldap_dynamicgroup_unique_attribute_type = text
383
384		# This is the name of the attribute on the dynamicgroup object that
385		# specifies the filter to be applied for this dynamicgroup. All users
386		# matching this filter AND matching the default
387		# ldap_user_search_filter will be included in the dynamicgroup
388		#ldap_dynamicgroup_filter_attribute = kopanoFilter
389
390		# This is the name of the attribute on the dynamicgroup object that
391		# specifies the search base to be applied for this dynamicgroup.
392		#ldap_dynamicgroup_search_base_attribute = kopanoBase
393
394		# The attribute containing the name of the dynamicgroup
395		#ldap_dynamicgroup_name_attribute = cn
396
397
398		##########
399		# Quota settings
400
401		# Optional
402		# The attribute which indicates which users (besides the user who exceeds his quota)
403		# should also receive a warning mail when a user exceeds his quota.
404		#ldap_quota_userwarning_recipients_attribute = kopanoQuotaUserWarningRecipients
405
406		# Optional, default = text
407		# Active directory: dn
408		# LDAP: text
409		#ldap_quota_userwarning_recipients_attribute_type = text
410
411		# Optional, default empty
412		#ldap_quota_userwarning_recipients_relation_attribute =
413
414		# Optional
415		# The attribute which indicates which users should receive a warning mail
416		# when a company exceeds his quota.
417		#ldap_quota_companywarning_recipients_attribute = kopanoQuotaCompanyWarningRecipients
418
419		# Optional, default = text
420		# Active directory: dn
421		# LDAP: text
422		#ldap_quota_companywarning_recipients_attribute_type = text
423
424		# Optional, default empty
425		#ldap_quota_companywarning_recipients_relation_attribute =
426
427		# Whether to override the system wide quota settings
428		#ldap_quotaoverride_attribute = kopanoQuotaOverride
429
430		#ldap_warnquota_attribute = kopanoQuotaWarn
431		#ldap_softquota_attribute = kopanoQuotaSoft
432		#ldap_hardquota_attribute = kopanoQuotaHard
433
434		# Whether to override the system wide quota settings for all users within the company
435		#ldap_userdefault_quotaoverride_attribute = kopanoUserDefaultQuotaOverride
436
437		#ldap_userdefault_warnquota_attribute = kopanoUserDefaultQuotaWarn
438		#ldap_userdefault_softquota_attribute = kopanoUserDefaultQuotaSoft
439		#ldap_userdefault_hardquota_attribute = kopanoUserDefaultQuotaHard
440
441		# Mapping from the quota attributes to a number of bytes. Qmail-LDAP
442		# schema uses bytes (1), ADS uses kilobytes (1024*1024).
443		#ldap_quota_multiplier = 1048576
444
445		##########
446		# Misc. settings
447
448		# Attribute which indicates if the user should be hidden from addressbook
449		#ldap_addressbook_hide_attribute = kopanoHidden
450
451		# LDAP object search filter. %s in this filter will be replaced with
452		# the object being searched.
453		# Hint: Use the kopanoAccount attribute in the filter to differentiate
454		# between non-kopano and kopano objects.
455		# Default: empty
456		# ADS recommended: (anr=%s)
457		# OpenLDAP optional: (\|(mail=%s)(uid=%s)(cn=%s)(fullname=%s)(givenname=%s)(lastname=%s)(sn=%s))
458		#ldap_object_search_filter = (anr=%s)
459
460		# If a request want more objects than this value, it will download the
461		# full ldap tree (from the base with the search filter) and discard
462		# wat was not required. This is faster for large requests.
463		# Default: 1000
464		#ldap_filter_cutoff_elements = 1000
465
466		##########
467		# Multi-server settings
468
469		# Users will be created on this named server
470		# Optional, default kopanoUserServer
471		#ldap_user_server_attribute = kopanoUserServer
472
473		# The public store of the company will be created on this named server
474		# Optional, default kopanoCompanyServer
475		#ldap_company_server_attribute = kopanoCompanyServer
476
477		# Optional
478		# Active directory: kopanoHostAddress
479		# LDAP: ipHostNumber
480		#ldap_server_address_attribute = kopanoHostAddress
481
482		# Optional, default = kopanoHttpPort
483		# Active directory: kopanoHttpPort
484		# LDAP: kopanoHttpPort
485		#ldap_server_http_port_attribute = kopanoHttpPort
486
487		# Optional, default = kopanoSslPort
488		# Active directory: kopanoSslPort
489		# LDAP: kopanoSslPort
490		#ldap_server_ssl_port_attribute = kopanoSslPort
491
492		# Optional, default = kopanoFilePath
493		# Active directory: kopanoFilePath
494		#LDAP: kopanoFilePath
495		#ldap_server_file_path_attribute = kopanoFilePath
496
497		# Determines if a server contains the public store of a non-hosted
498		# environment. Only one server is allowed to host the public store.
499		# Optional, default = kopanoContainsPublic
500		# Active directory: kopanoContainsPublic
501		# LDAP: kopanoContainsPublic
502		#ldap_server_contains_public_attribute = kopanoContainsPublic
503
504		# The Proxy URL of the node; the node must be available to clients
505		# using this Proxy URL if the server detects that original connection
506		# was received via a proxy. See server.cfg(5)'s proxy_header setting
507		#ldap_server_proxy_path_attribute = kopanoProxyURL
508
509		# Search for servers using this LDAP filter. See ldap_search(3) or RFC
510		# 2254 for details on the filter syntax.
511		# Optional, default = empty (match everything)
512		# For active directory, use:
513		# (objectCategory=Computer)
514		# For LDAP with posix users, use:
515		#
516		#ldap_server_search_filter = (objectCategory=Computer)
517
518		# Unique user id to find the server
519		# Required
520		# For active directory, use:
521		# CN
522		# For LDAP with posixAccount, use:
523		# cn
524		#ldap_server_unique_attribute = cn

+0

-528

~~installer/linux/ldapms.openldap.cfg~~ less more

0		##############################################################
1		# LDAP/ACTIVE DIRECTORY USER PLUGIN SETTINGS
2		#
3		# Any of these directives that are required, are only required if the
4		# userplugin parameter is set to ldap.
5
6		# LDAP host name/IP address
7		# Optional, default = localhost
8		#ldap_host = localhost
9
10		# LDAP port
11		# Optional, default = 389
12		# Use 636 for ldaps
13		#ldap_port = 389
14
15		# LDAP protocol
16		# Optional, default = ldap
17		# use 'ldaps' for SSL encryption. Make sure /etc/ldap/ldap.conf is
18		# configured correctly with TLS_CACERT
19		#ldap_protocol = ldap
20
21		# LDAP URI
22		# Optional, override ldap_host, ldap_port and ldap_protocol if set
23		# e.g. ldaps://servername:port. You may also specify multiple space-separated
24		# URI's
25		#ldap_uri =
26
27		# The charset that strings are stored in on the LDAP server. Normally this
28		# is utf-8, but this can differ according to your setup. The charset specified
29		# here must be supported by your iconv(1) setup. See iconv -l for all charset
30		#ldap_server_charset = utf-8
31
32		# The DN of the user to bind as for normal operations (not used for
33		# authentication if ldap_authentication_method is set to "bind"
34		# Optional, default = empty (anonymous bind)
35		# The userPassword attribute must be readable for this user if the
36		# ldap_authentication_method option is set to password.
37		#ldap_bind_user = cn=admin,cn=users,dc=kopano,dc=com
38
39		# LDAP bind password
40		# Optional, default = empty (no password)
41		#ldap_bind_passwd =
42
43		# The timeout for network operations in seconds
44		#ldap_network_timeout = 30
45
46		# When an object (user/group/company) is changed, this attribute will also change:
47		# Active directory: uSNChanged
48		# LDAP: modifyTimestamp
49		#ldap_last_modification_attribute = modifyTimestamp
50
51		# ldap_page_size limits the number of results from a query that will be downloaded at a time.
52		# Default ADS MaxPageSize is 1000.
53		#ldap_page_size = 1000
54
55		##########
56		# Object settings
57
58		# Top level search base, every object should be available under this tree
59		#ldap_search_base = dc=kopano,dc=com
60
61		# attribute name which is/(should: was) used in ldap_user_search_filter
62		#ldap_object_type_attribute = objectClass
63		#ldap_user_type_attribute_value = posixAccount
64		#ldap_group_type_attribute_value = posixGroup
65		#ldap_contact_type_attribute_value = kopano-contact
66		#ldap_company_type_attribute_value = organizationalUnit
67		#ldap_addresslist_type_attribute_value = kopano-addresslist
68		#ldap_dynamicgroup_type_attribute_value = kopano-dynamicgroup
69		#ldap_server_type_attribute_value = ipHost
70
71		##########
72		# There should be no need to edit any values below this line
73		##########
74
75		##########
76		# User settings
77
78		# Extra search for users using this LDAP filter. See ldap_search(3) or RFC
79		# 2254 for details on the filter syntax.
80		#
81		# Hint: Use the kopanoAccount attribute in the filter to differentiate
82		# between non-kopano and kopano users.
83		#
84		# Note: This filter should include contacts.
85		#
86		# Optional, default = empty (match everything)
87		# For active directory, use:
88		# (objectCategory=Person)
89		# For LDAP with posix users:
90		# no need to use the search filter.
91		#ldap_user_search_filter =
92
93		# unique user id for find the user
94		# Required
95		# For active directory, use:
96		# objectGuid WARNING: This WAS: objectSid Updates WILL fail! **
97		# For LDAP with posixAccount, use:
98		# uidNumber
99		# Note: contacts also use this field for uniqueness. If you change this,
100		# you might need to update the kopano.schema file too, and change
101		# the MUST uidNumber to whatever you set here.dnl
102		#ldap_user_unique_attribute = uidNumber
103
104		# Type of unique user id
105		# default: text
106		# For active directory, use:
107		# binary
108		# For LDAP with posix user, use:
109		# text
110		#ldap_user_unique_attribute_type = text
111
112		# Optional, default = cn
113		# For active directory, use:
114		# cn or displayName
115		# For LDAP with posix user, use:
116		# cn
117		#ldap_fullname_attribute = cn
118
119		# Optional, default = uid
120		# Active directory: sAMAccountName
121		# LDAP: uid
122		#ldap_loginname_attribute = uid
123
124		# Optional, default = userPassword
125		# Active directory: unicodePwd
126		# LDAP: userPassword
127		#ldap_password_attribute = userPassword
128
129		# If set to bind, users are authenticated by trying to bind to the
130		# LDAP tree using their username + password. Otherwise, the
131		# ldap_password_attribute is requested and checked.
132		# Optional, default = bind
133		# Choices: bind, password
134		# Active directory: bind
135		# LDAP: bind
136		#ldap_authentication_method = bind
137
138		# Optional, default = mail
139		# Active directory: mail
140		# LDAP: mail
141		#ldap_emailaddress_attribute = mail
142
143		# Optional, default = kopanoAliases
144		# Active directory: kopanoAliases
145		# LDAP: kopanoAliases
146		#ldap_emailaliases_attribute = kopanoAliases
147
148		# Whether the user is an admin. The field is interpreted as a
149		# boolean, 0 and false (case insensitive) meaning no, all other values
150		# yes.
151		# Optional, default = kopanoAdmin
152		# Active directory: kopanoAdmin
153		# LDAP: kopanoAdmin
154		#ldap_isadmin_attribute = kopanoAdmin
155
156		# Whether a user is a non-active user. This means that the user will
157		# not count towards your user count, but the user will also not be
158		# able to log in
159		# Optional, default = kopanoSharedStoreOnly
160		# Active directory: kopanoSharedStoreOnly
161		# LDAP: kopanoSharedStoreOnly
162		#ldap_nonactive_attribute = kopanoSharedStoreOnly
163
164		# A nonactive store, or resource, can be specified to be a user, room or equipment.
165		# Set it to 'room' or 'equipment' to make such types. If set to empty,
166		# or wrong word, or 'user' it will be a nonactive user.
167		# Optional, default = kopanoResourceType
168		# Active directory: kopanoResourceType
169		# LDAP: kopanoResourceType
170		#ldap_resource_type_attribute = kopanoResourceType
171
172		# Numeric resource capacity
173		# Optional, default = kopanoResourceCapacity
174		# Active directory: kopanoResourceCapacity
175		# LDAP: kopanoResourceCapacity
176		#ldap_resource_capacity_attribute = kopanoResourceCapacity
177
178		# Optional
179		# The attribute which indicates which users are allowed
180		# to send on behalf of the selected user
181		#ldap_sendas_attribute = kopanoSendAsPrivilege
182
183		# Optional, default = text
184		# Active directory: dn
185		# LDAP: text
186		#ldap_sendas_attribute_type = text
187
188		# The attribute of the user and group which is listed in
189		# the ldap_sendas_attribute
190		# Empty default, using ldap_user_unique_attribute
191		#ldap_sendas_relation_attribute =
192
193		# Optional, default = userCertificate
194		# Active directory: userCertificate
195		# LDAP: userCertificate;binary
196		#ldap_user_certificate_attribute = userCertificate;binary
197
198		# Load extra user properties from the propmap file
199		!propmap /etc/kopano/ldap.propmap.cfg
200
201		##########
202		# Group settings
203
204		# Search for groups using this LDAP filter. See ldap_search(3) for
205		# details on the filter syntax.
206		# Hint: Use the kopanoAccount attribute in the filter to differentiate
207		# between non-kopano and kopano groups.
208		# Optional, default = empty (match everything)
209		# For active directory, use:
210		# (objectCategory=Group)
211		# For LDAP with posix groups, use:
212		# no need to set the search filter
213		#ldap_group_search_filter =
214
215		# unique group id for find the group
216		# Required
217		# For active directory, use:
218		# objectSid
219		# For LDAP with posix group, use:
220		# gidNumber
221		#ldap_group_unique_attribute = gidNumber
222
223		# Type of unique group id
224		# default: text
225		# For active directory, use:
226		# binary
227		# For LDAP with posix group, use:
228		# text
229		#ldap_group_unique_attribute_type = text
230
231		# Optional, default = cn
232		# Active directory: cn
233		# LDAP: cn
234		#ldap_groupname_attribute = cn
235
236		# Optional, default = member
237		# Active directory: member
238		# LDAP: memberUid
239		#ldap_groupmembers_attribute = memberUid
240
241		# Optional, default = text
242		# Active directory: dn
243		# LDAP: text
244		#ldap_groupmembers_attribute_type = text
245
246		# The attribute of the user which is listed in ldap_groupmember_attribute
247		# Active directory: empty, matching dn's
248		# LDAP: uid, matching users in ldap_loginname_attribute
249		#ldap_groupmembers_relation_attribute = uid
250
251		# A group can also be used for security, eg. setting permissions on folders.
252		# This makes a group a security group. The kopanoSecurityGroup value is boolean.
253		# Optional, default = kopanoSecurityGroup
254		# Active directory = groupType
255		# LDAP: kopanoSecurityGroup
256		#ldap_group_security_attribute = kopanoSecurityGroup
257
258		# In ADS servers, a special bitmask action is required on the groupType field.
259		# This is actived by setting the ldap_group_security_attribute_type to `''ads`''
260		# Otherwise, just the presence of the field will make the group security enabled.
261		# Optional, default = boolean
262		# Active directory = ads
263		# LDAP: boolean
264		#ldap_group_security_attribute_type = boolean
265
266		##########
267		# Company settings
268
269		# Search for companies using this LDAP filter.
270		# Hint: Use the kopanoAccount attribute in the filter to differentiate
271		# between non-kopano and kopano companies.
272		# Optional, default = empty (match everything)
273		# For active directory, use:
274		# (objectCategory=Company)
275		# For LDAP with posix users, use:
276		# no need to set the filter
277		#ldap_company_search_filter =
278
279		# unique company id for find the company
280		# Active directory: objectGUID
281		# LDAP: ou
282		#ldap_company_unique_attribute = ou
283
284		# Optional, default = text
285		# Active directory: binary
286		# LDAP: text
287		#ldap_company_unique_attribute_type = text
288
289		# Optional, default = ou
290		# Active directory: ou
291		# LDAP: ou
292		#ldap_companyname_attribute = ou
293
294		# Optional
295		# The attribute which indicates which companies are allowed
296		# to view the members of the selected company
297		#ldap_company_view_attribute = kopanoViewPrivilege
298
299		# Optional, default = text
300		#ldap_company_view_attribute_type = text
301
302		# The attribute of the company which is listed in the
303		# ldap_company_view_attribute
304		# Empty default, using ldap_company_unique_attribute
305		#ldap_company_view_relation_attribute =
306
307		# Optional
308		# The attribute which indicates which users from different companies
309		# are administrator over the selected company.
310		#ldap_company_admin_attribute = kopanoAdminPrivilege
311
312		# Optional, default = text
313		# Active directory: dn
314		# LDAP: text
315		#ldap_company_admin_attribute_type = text
316
317		# The attribute of the company which is listed in the
318		# ldap_company_admin_attribute
319		# Empty default, using ldap_user_unique_attribute
320		#ldap_company_admin_relation_attribute =
321
322		# The attribute which indicates which user is the system administrator
323		# for the specified company.
324		#ldap_company_system_admin_attribute = kopanoSystemAdmin
325
326		# Optional, default = text
327		# Active directory: dn
328		# LDAP: text
329		#ldap_company_system_admin_attribute_type = text
330
331		# The attribute of the company which is listed in the
332		# ldap_company_system_admin attribute
333		# Empty default, using ldap_user_unique_attribute
334		#ldap_company_system_admin_relation_attribute =
335
336
337		##########
338		# Addresslist settings
339
340		# Add a filter to the addresslist search
341		# Hint: Use the kopanoAccount attribute in the filter to differentiate
342		# between non-kopano and kopano addresslists.
343		# Optional, default = empty (match everything)
344		#ldap_addresslist_search_filter =
345
346		# This is the unique attribute of a addresslist which is never going
347		# to change, unless the addresslist is removed from LDAP. When this
348		# value changes, Kopano will remove the previous addresslist from the
349		# database, and create a new addresslist with this unique value
350		#ldap_addresslist_unique_attribute = cn
351
352		# This value can be 'text' or 'binary'. For OpenLDAP, only text is used.
353		#ldap_addresslist_unique_attribute_type = text
354
355		# This is the name of the attribute on the addresslist object that
356		# specifies the filter to be applied for this addresslist. All users
357		# matching this filter AND matching the default
358		# ldap_user_search_filter will be included in the addresslist
359		#ldap_addresslist_filter_attribute = kopanoFilter
360
361		# This is the name of the attribute on the addresslist object that
362		# specifies the search base to be applied for this addresslist.
363		#ldap_addresslist_search_base_attribute = kopanoBase
364
365		# The attribute containing the name of the addresslist
366		#ldap_addresslist_name_attribute = cn
367
368
369		##########
370		# Dynamicgroup settings
371
372		# Add a filter to the dynamicgroup search
373		# Hint: Use the kopanoAccount attribute in the filter to differentiate
374		# between non-kopano and kopano dynamic groups.
375		# Optional, default = empty (match everything)
376		#ldap_dynamicgroup_search_filter =
377
378		# This is the unique attribute of a dynamicgroup which is never going
379		# to change, unless the dynamicgroup is removed from LDAP. When this
380		# value changes, Kopano will remove the previous dynamicgroup from the
381		# database, and create a new dynamicgroup with this unique value
382		#ldap_dynamicgroup_unique_attribute = cn
383
384		# This value can be 'text' or 'binary'. For OpenLDAP, only text is used.
385		#ldap_dynamicgroup_unique_attribute_type = text
386
387		# This is the name of the attribute on the dynamicgroup object that
388		# specifies the filter to be applied for this dynamicgroup. All users
389		# matching this filter AND matching the default
390		# ldap_user_search_filter will be included in the dynamicgroup
391		#ldap_dynamicgroup_filter_attribute = kopanoFilter
392
393		# This is the name of the attribute on the dynamicgroup object that
394		# specifies the search base to be applied for this dynamicgroup.
395		#ldap_dynamicgroup_search_base_attribute = kopanoBase
396
397		# The attribute containing the name of the dynamicgroup
398		#ldap_dynamicgroup_name_attribute = cn
399
400
401		##########
402		# Quota settings
403
404		# Optional
405		# The attribute which indicates which users (besides the user who exceeds his quota)
406		# should also receive a warning mail when a user exceeds his quota.
407		#ldap_quota_userwarning_recipients_attribute = kopanoQuotaUserWarningRecipients
408
409		# Optional, default = text
410		# Active directory: dn
411		# LDAP: text
412		#ldap_quota_userwarning_recipients_attribute_type = text
413
414		# Optional, default empty
415		#ldap_quota_userwarning_recipients_relation_attribute =
416
417		# Optional
418		# The attribute which indicates which users should receive a warning mail
419		# when a company exceeds his quota.
420		#ldap_quota_companywarning_recipients_attribute = kopanoQuotaCompanyWarningRecipients
421
422		# Optional, default = text
423		# Active directory: dn
424		# LDAP: text
425		#ldap_quota_companywarning_recipients_attribute_type = text
426
427		# Optional, default empty
428		#ldap_quota_companywarning_recipients_relation_attribute =
429
430		# Whether to override the system wide quota settings
431		#ldap_quotaoverride_attribute = kopanoQuotaOverride
432
433		#ldap_warnquota_attribute = kopanoQuotaWarn
434		#ldap_softquota_attribute = kopanoQuotaSoft
435		#ldap_hardquota_attribute = kopanoQuotaHard
436
437		# Whether to override the system wide quota settings for all users within the company
438		#ldap_userdefault_quotaoverride_attribute = kopanoUserDefaultQuotaOverride
439
440		#ldap_userdefault_warnquota_attribute = kopanoUserDefaultQuotaWarn
441		#ldap_userdefault_softquota_attribute = kopanoUserDefaultQuotaSoft
442		#ldap_userdefault_hardquota_attribute = kopanoUserDefaultQuotaHard
443
444		# Mapping from the quota attributes to a number of bytes. Qmail-LDAP
445		# schema uses bytes (1), ADS uses kilobytes (1024*1024).
446		#ldap_quota_multiplier = 1
447
448		##########
449		# Misc. settings
450
451		# Attribute which indicates if the user should be hidden from addressbook
452		#ldap_addressbook_hide_attribute = kopanoHidden
453
454		# LDAP object search filter. %s in this filter will be replaced with
455		# the object being searched.
456		# Hint: Use the kopanoAccount attribute in the filter to differentiate
457		# between non-kopano and kopano objects.
458		# Default: empty
459		# ADS recommended: (anr=%s)
460		# OpenLDAP optional: (\|(mail=%s)(uid=%s)(cn=%s)(fullname=%s)(givenname=%s)(lastname=%s)(sn=%s))
461		#ldap_object_search_filter =
462
463		# If a request want more objects than this value, it will download the
464		# full ldap tree (from the base with the search filter) and discard
465		# wat was not required. This is faster for large requests.
466		# Default: 1000
467		#ldap_filter_cutoff_elements = 1000
468
469		##########
470		# Multi-server settings
471
472		# Users will be created on this named server
473		# Optional, default kopanoUserServer
474		#ldap_user_server_attribute = kopanoUserServer
475
476		# The public store of the company will be created on this named server
477		# Optional, default kopanoCompanyServer
478		#ldap_company_server_attribute = kopanoCompanyServer
479
480		# Optional
481		# Active directory: kopanoHostAddress
482		# LDAP: ipHostNumber
483		#ldap_server_address_attribute = ipHostNumber
484
485		# Optional, default = kopanoHttpPort
486		# Active directory: kopanoHttpPort
487		# LDAP: kopanoHttpPort
488		#ldap_server_http_port_attribute = kopanoHttpPort
489
490		# Optional, default = kopanoSslPort
491		# Active directory: kopanoSslPort
492		# LDAP: kopanoSslPort
493		#ldap_server_ssl_port_attribute = kopanoSslPort
494
495		# Optional, default = kopanoFilePath
496		# Active directory: kopanoFilePath
497		#LDAP: kopanoFilePath
498		#ldap_server_file_path_attribute = kopanoFilePath
499
500		# Determines if a server contains the public store of a non-hosted
501		# environment. Only one server is allowed to host the public store.
502		# Optional, default = kopanoContainsPublic
503		# Active directory: kopanoContainsPublic
504		# LDAP: kopanoContainsPublic
505		#ldap_server_contains_public_attribute = kopanoContainsPublic
506
507		# The Proxy URL of the node; the node must be available to clients
508		# using this Proxy URL if the server detects that original connection
509		# was received via a proxy. See server.cfg(5)'s proxy_header setting
510		#ldap_server_proxy_path_attribute = kopanoProxyURL
511
512		# Search for servers using this LDAP filter. See ldap_search(3) or RFC
513		# 2254 for details on the filter syntax.
514		# Optional, default = empty (match everything)
515		# For active directory, use:
516		# (objectCategory=Computer)
517		# For LDAP with posix users, use:
518		#
519		#ldap_server_search_filter =
520
521		# Unique user id to find the server
522		# Required
523		# For active directory, use:
524		# CN
525		# For LDAP with posixAccount, use:
526		# cn
527		#ldap_server_unique_attribute = cn

+4

-0

installer/linux/server.cfg less more

55	55
56	56	# run server in this path (when not using the -F switch)
57	57	#running_path = /var/lib/kopano
	58
	59	# Use given allocator library. Values like libtcmalloc.so.4,
	60	# libtcmalloc_minimal.so.4 and libjemalloc.so.2 would work.
	61	#allocator_library = default
58	62
59	63	# create memory coredumps upon crash in the running_path directory
60	64	coredump_enabled = yes

+3

-3

installer/userscripts/Makefile.am less more

0	0	SUBDIRS = createcompany.d creategroup.d createuser.d deletecompany.d deletegroup.d deleteuser.d
1	1	dist_bin_SCRIPTS = createcompany creategroup createuser deletecompany deletegroup deleteuser
2		bindir = $(USERSCRIPTDIR)
	2	bindir = ${dcprefix}${USERSCRIPTDIR}
3	3	dist_data_DATA = users_common.sh groups_common.sh companies_common.sh
4		datadir = $(USERSCRIPTDIR)
	4	datadir = ${dcprefix}${USERSCRIPTDIR}
5	5
6	6	install-data-hook:
7	7	for dir in $(SUBDIRS); do \
8		mkdir -p $(DESTDIR)/$(USERSCRIPTDIR)/$$dir; \
	8	mkdir -p ${DESTDIR}/${dcprefix}${USERSCRIPTDIR}/$$dir; \
9	9	done

+1

-1

installer/userscripts/createcompany.d/Makefile.am less more

0	0	dist_bin_SCRIPTS = 00createpublic
1		bindir = $(USERSCRIPTDIR)/createcompany.d
	1	bindir = ${dcprefix}${USERSCRIPTDIR}/createcompany.d

+1

-1

installer/userscripts/creategroup.d/Makefile.am less more

0		bindir = $(USERSCRIPTDIR)/creategroup.d
	0	bindir = ${dcprefix}${USERSCRIPTDIR}/creategroup.d

+1

-1

installer/userscripts/createuser.d/Makefile.am less more

0	0	dist_bin_SCRIPTS = 00createstore
1		bindir = $(USERSCRIPTDIR)/createuser.d
	1	bindir = ${dcprefix}${USERSCRIPTDIR}/createuser.d

+1

-1

installer/userscripts/deletecompany.d/Makefile.am less more

0		bindir = $(USERSCRIPTDIR)/deletecompany.d
	0	bindir = ${dcprefix}${USERSCRIPTDIR}/deletecompany.d

+1

-1

installer/userscripts/deletegroup.d/Makefile.am less more

0		bindir = $(USERSCRIPTDIR)/deletegroup.d
	0	bindir = ${dcprefix}${USERSCRIPTDIR}/deletegroup.d

+1

-1

installer/userscripts/deleteuser.d/Makefile.am less more

0	0	dist_bin_SCRIPTS =
1		bindir = $(USERSCRIPTDIR)/deleteuser.d
	1	bindir = ${dcprefix}${USERSCRIPTDIR}/deleteuser.d

+4

-3

lddcheck less more

2	2	if [ -z "$1" ]; then
3	3	exit 0
4	4	fi
5		input="$1"
6		output="$2"
	5	libtool="$1"; shift
	6	input="$1"; shift
	7	output="$1"; shift
7	8
8	9	case "$input" in #((
9	10	*.la)

17	18	fi
18	19	;;
19	20	*)
20		if libtool --mode=execute ldd -r "$input" \| c++filt \| \
	21	if "${libtool}" --mode=execute ldd -r "$input" \| c++filt \| \
21	22	grep "undefined symbol"; then
22	23	exit 1
23	24	fi

+0

-8

libfreebusy/ECEnumFBBlock.cpp less more

19	19	#include "freebusyutil.h"
20	20	#include <kopano/stringutil.h>
21	21
22		#ifdef _DEBUG
23		#define new DEBUG_NEW
24		#endif
25
26	22	/**
27		* Constructor
28		*
29	23	* @param[in] lpFBBlock Pointer to a list of free/busy blocks
30	24	*/
31	25	ECEnumFBBlock::ECEnumFBBlock(ECFBBlockList* lpFBBlock)

43	37	*
44	38	* @param[in] lpFBBlock Pointer to a list of free/busy blocks
45	39	* @param[out] lppEnumFBBlock Address of the pointer that receives the object ECEnumFBBlock pointer
46		*
47		* @return HRESULT
48	40	*/
49	41	HRESULT ECEnumFBBlock::Create(ECFBBlockList* lpFBBlock, ECEnumFBBlock **lppEnumFBBlock)
50	42	{

+0

-4

libfreebusy/ECFBBlockList.cpp less more

16	16
17	17	#include <kopano/platform.h>
18	18	#include "ECFBBlockList.h"
19
20		#ifdef _DEBUG
21		#define new DEBUG_NEW
22		#endif
23	19
24	20	ECFBBlockList::ECFBBlockList(void)
25	21	{

+0

-4

libfreebusy/ECFreeBusyData.cpp less more

18	18	#include "ECFreeBusyData.h"
19	19
20	20	#include "ECEnumFBBlock.h"
21
22		#ifdef _DEBUG
23		#define new DEBUG_NEW
24		#endif
25	21
26	22	ECFreeBusyData::ECFreeBusyData(void)
27	23	{

+0

-7

libfreebusy/ECFreeBusySupport.cpp less more

26	26	#include "freebusyutil.h"
27	27	#include <kopano/mapi_ptr.h>
28	28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32
33	29	ECFreeBusySupport::ECFreeBusySupport(void)
34	30	{
35	31	m_lpSession = NULL;

108	104	}
109	105	#endif
110	106
111
112	107	// Hold the mapisession, the session will be released by function 'close' or
113	108	// on delete the class
114	109	hr = lpMAPISession->QueryInterface(IID_IMAPISession, (void**)&m_lpSession);

137	132
138	133	return hr;
139	134	}
140
141	135
142	136	HRESULT ECFreeBusySupport::Close()
143	137	{

278	272	if(lpMessage)
279	273	lpMessage->Release();
280	274
281
282	275	return hr;
283	276	}
284	277

+0

-3

libfreebusy/ECFreeBusySupport.h less more

32	32	#include <mapi.h>
33	33	#include <mapidefs.h>
34	34	#include <mapix.h>
35
36		#include "freebusy.h"
37		#include "freebusyguid.h"
38	35
39	36	#include <kopano/ECUnknown.h>
40	37	#include <kopano/Trace.h>

+0

-6

libfreebusy/ECFreeBusyUpdate.cpp less more

20	20
21	21	#include "freebusyutil.h"
22	22
23		#ifdef _DEBUG
24		#define new DEBUG_NEW
25		#endif
26
27	23	ECFreeBusyUpdate::ECFreeBusyUpdate(IMessage* lpMessage)
28	24	{
29	25	m_lpMessage = lpMessage;

52	48
53	49	return hr;
54	50	}
55
56	51
57	52	HRESULT ECFreeBusyUpdate::QueryInterface(REFIID refiid, void** lppInterface)
58	53	{

118	113	}
119	114	};
120	115
121
122	116	FileTimeToRTime(&ftStart, &rtmStart);
123	117	FileTimeToRTime(&ftEnd, &rtmEnd);
124	118

+1

-0

libfreebusy/Makefile.am less more

5	5
6	6	lib_LTLIBRARIES = libkcfreebusy.la
7	7	noinst_DATA = libkcfreebusy.ldd
	8	CLEANFILES = ${noinst_DATA}
8	9
9	10	libkcfreebusy_la_includedir = $(includedir)/libfreebusy
10	11

+0

-4

libfreebusy/PublishFreeBusy.cpp less more

34	34
35	35	#define START_TIME 0
36	36	#define END_TIME 1
37
38		#ifdef _DEBUG
39		#define new DEBUG_NEW
40		#endif
41	37
42	38	/**
43	39	* Publish free/busy information from the default calendar

+3

-22

libfreebusy/freebusy.h less more

334	334	* use of Outlook and are subject to change. Free/busy providers must implement them only
335	335	* as specified, returning only the specified return values.
336	336	*/
337		#ifndef LINUX
338		MIDL_INTERFACE("00067066-0000-0000-C000-000000000046")
339		#else
340		class
341		#endif
342		IFreeBusyData : public IUnknown
343		{
344
	337	class IFreeBusyData : public IUnknown {
345	338	public:
346	339
347	340	/**

444	437	* only as specified, returning only the specified return values.
445	438	*
446	439	*/
447		#ifndef LINUX
448		MIDL_INTERFACE("00067067-0000-0000-C000-000000000046")
449		#else
450		class
451		#endif
452		IFreeBusySupport : public IUnknown
453		{
	440	class IFreeBusySupport : public IUnknown {
454	441	public:
455	442
456	443	/**

669	656	* Missing call is CleanTombstone. This is not support in outlook 2000
670	657	*
671	658	*/
672		#ifndef LINUX
673		MIDL_INTERFACE("00067067-0000-0000-C000-000000000046")
674		#else
675		class
676		#endif
677		IFreeBusySupportOutlook2000 : public IUnknown
678		{
	659	class IFreeBusySupportOutlook2000 : public IUnknown {
679	660	public:
680	661
681	662	/! @copydoc IFreeBusySupport::Open /

+0

-9

libfreebusy/freebusyutil.cpp less more

27	27	#include "freebusytags.h"
28	28	#include <kopano/mapiext.h>
29	29	#include <edkmdb.h>
30
31		#ifdef _DEBUG
32		#define new DEBUG_NEW
33		#endif
34	30
35	31	BOOL leapyear(short year)
36	32	{

95	91
96	92	enum eFreeBusyPos{ FBPOS_FREE_BUSY_FOR_LOCAL_SITE_ENTRYID};
97	93
98
99	94	// Get freebusy properies
100	95	hr = lpPublicStore->GetProps((LPSPropTagArray)&sPropsFreeBusy, 0, &cValuesFreeBusy, &lpPropArrayFreeBusy);
101	96	if (FAILED(hr))

173	168	hr = MAPI_E_INVALID_ENTRYID;
174	169	goto exit;
175	170	}
176
177
178	171
179	172	// GetFreeBusyFolder
180	173	hr = GetFreeBusyFolder(lpPublicStore, &lpFreeBusyFolder);

509	502	if(FAILED(hr))
510	503	goto exit;
511	504
512
513	505	// Get busy data
514	506	if(lpPropArrayFBData[FBDATA_BUSY_EVENTS].ulPropTag == PR_FREEBUSY_BUSY_EVENTS &&
515	507	lpPropArrayFBData[FBDATA_BUSY_MONTHS].ulPropTag == PR_FREEBUSY_BUSY_MONTHS)

552	544	MAPIFreeBuffer(lpPropArrayFBData);
553	545	return hr;
554	546	}
555
556	547
557	548	unsigned int DiffYearMonthToMonth( struct tm tm1, struct tm tm2)
558	549	{

+0

-12

libfreebusy/recurrence.cpp less more

31	31	#include <algorithm>
32	32	using namespace std;
33	33
34		#ifdef _DEBUG
35		#define new DEBUG_NEW
36		#endif
37
38	34	recurrence::recurrence() {
39	35	m_ulMonth = 0x0;
40	36	}

297	293	return hr;
298	294	}
299	295
300
301	296	time_t recurrence::getEndDateTime()
302	297	{
303	298	time_t tStart;

305	300	RTimeToUnixTime(m_sRecState.ulEndDate, &tStart);
306	301	return tStart + (m_sRecState.ulEndTimeOffset*60);
307	302	}
308
309	303
310	304	HRESULT recurrence::setEndDateTime(time_t t)
311	305	{

317	311
318	312	return hr;
319	313	}
320
321	314
322	315	ULONG recurrence::getCount()
323	316	{

459	452	return hrSuccess;
460	453	}
461	454
462
463	455	// only valid in monthly type 0x3 and 0xb
464	456	UCHAR recurrence::getWeekNumber()
465	457	{

500	492	std::vector<unsigned int> lstDeletedInstanceDates;
501	493	std::vector<unsigned int>::iterator d;
502	494	std::vector<RecurrenceState::Exception>::const_iterator iExceptions;
503
504	495
505	496	// make copy of struct info
506	497	lstDeletedInstanceDates = m_sRecState.lstDeletedInstanceDates;

1109	1100	// Go the the correct month day
1110	1101	tStart += (m_sRecState.ulDayOfMonth-1) * 246060;
1111	1102
1112
1113	1103	// If the previous calculation gave us a start date before the original start date, then we need to skip to the next occurrence
1114	1104	if (m_sRecState.ulRecurFrequency == RF_MONTHLY &&
1115	1105	static_cast<int>(m_sRecState.ulDayOfMonth) < tm.tm_mday) {

1242	1232
1243	1233	if (m_sRecState.ulEndType != ET_NUMBER)
1244	1234	return getEndDateTime();
1245
1246	1235
1247	1236	tStart = getStartDateTime();
1248	1237	tEnd = tStart;

1928	1917	return false;
1929	1918	}
1930	1919
1931
1932	1920	ULONG recurrence::countDaysOfMonth(time_t tsDate)
1933	1921	{
1934	1922	ULONG ulYear = 0;

+3

-3

libicalmapi/MAPIToICal.cpp less more

154	154	if (hr != hrSuccess)
155	155	goto exit;
156	156
157		if (stricmp(lpMessageClass->Value.lpszA, "IPM.Task") == 0) {
	157	if (strcasecmp(lpMessageClass->Value.lpszA, "IPM.Task") == 0) {
158	158	hr = HrGetTzStruct(strSrvTZ, &ttTZinfo);
159	159	if(hr == hrSuccess)
160	160	m_tzMap[strSrvTZ] = ttTZinfo; // keep timezone pointer for tasks
161	161	}
162	162
163		if (stricmp(lpMessageClass->Value.lpszA, "IPM.Task") == 0) {
	163	if (strcasecmp(lpMessageClass->Value.lpszA, "IPM.Task") == 0) {
164	164	lpVEC = new VTodoConverter(m_lpAdrBook, &m_tzMap, m_lpNamedProps, m_strCharset, blCensor, false, NULL);
165		} else if (stricmp(lpMessageClass->Value.lpszA, "IPM.Appointment") == 0 \|\| strnicmp(lpMessageClass->Value.lpszA, "IPM.Schedule", strlen("IPM.Schedule")) == 0) {
	165	} else if (strcasecmp(lpMessageClass->Value.lpszA, "IPM.Appointment") == 0 \|\| strncasecmp(lpMessageClass->Value.lpszA, "IPM.Schedule", strlen("IPM.Schedule")) == 0) {
166	166	lpVEC = new VEventConverter(m_lpAdrBook, &m_tzMap, m_lpNamedProps, m_strCharset, blCensor, false, NULL);
167	167	} else {
168	168	hr = MAPI_E_TYPE_NO_SUPPORT;

+2

-1

libicalmapi/Makefile.am less more

1	1
2	2	lib_LTLIBRARIES = libkcicalmapi.la
3	3	noinst_DATA = libkcicalmapi.ldd
	4	CLEANFILES = ${noinst_DATA}
4	5
5	6	AM_CPPFLAGS = ${ZCPPFLAGS} $(DEBUGFLAGS) $(BOOST_CPPFLAGS) \
6	7	$(ICAL_CFLAGS) \

9	10	-I$(top_srcdir)/libfreebusy
10	11
11	12	libkcicalmapi_la_LDFLAGS = ${AM_LDFLAGS} \
12		-version-info 0:0:0 \
	13	-no-undefined -version-info 0:0:0 \
13	14	-Wl,--version-script=${top_builddir}/default.sym
14	15	EXTRA_libkcicalmapi_la_DEPENDENCIES = ${top_builddir}/default.sym
15	16

+0

-2

libicalmapi/icalrecurrence.cpp less more

240	240	UnixTimeToFileTime(dtUTCUntil, &sPropVal.Value.ft);
241	241	sPropVal.ulPropTag = CHANGE_PROP_TYPE(lpNamedProps->aulPropTag[PROP_RECURRENCE_END], PT_SYSTIME);
242	242	lpIcalItem->lstMsgProps.push_back(sPropVal);
243
244	243
245	244	// find EXDATE properties, add to delete exceptions
246	245	lpicProp = icalcomponent_get_first_property(lpicEvent, ICAL_EXDATE_PROPERTY);

808	807
809	808	icalcomponent_add_property(lpicEvent, icalproperty_new_rrule(icRRule));
810	809
811
812	810	// all delete exceptions are in the delete list,
813	811	lstExceptions = lpRecurrence->getDeletedExceptions();
814	812	if (!lstExceptions.empty()) {

+0

-5

libicalmapi/valarm.cpp less more

29	29	#include <kopano/CommonUtil.h>
30	30	#include <kopano/Util.h>
31	31	#include <kopano/stringutil.h>
32
33		#ifdef _DEBUG
34		#define new DEBUG_NEW
35		#endif
36	32
37	33	/**
38	34	* Generates ical VALARM component from reminderbefore minutes.

104	100	time_t ttReminderTime = 0;
105	101	bool bReminderSet = false;
106	102
107
108	103	lpTrigger = icalcomponent_get_first_property(lpicAlarm, ICAL_TRIGGER_PROPERTY);
109	104	lpAction = icalcomponent_get_first_property(lpicAlarm, ICAL_ACTION_PROPERTY);
110	105

+5

-9

libicalmapi/vconverter.cpp less more

80	80	}
81	81
82	82	/**
83		* Default constructor
84	83	* @param[in] lpAdrBook Mapi addresss book
85	84	* @param[in] mapTimeZones std::map containing timezone names and corresponding timezone structures
86	85	* @param[in] lpNamedProps Named property tag array

307	306	// Caller sets .ulPropTag
308	307	sPropValue.Value.bin.cb = strBinUid.size();
309	308	if ((hr = MAPIAllocateMore(sPropValue.Value.bin.cb, base, (void**)&sPropValue.Value.bin.lpb)) != hrSuccess)
310		goto exit;
	309	return hr;
311	310	memcpy(sPropValue.Value.bin.lpb, strBinUid.data(), sPropValue.Value.bin.cb);
312	311
313	312	// set return value
314		*lpPropValue = sPropValue;
315
316		exit:
317		return hr;
	313	lpPropValue->Value.bin.cb = sPropValue.Value.bin.cb;
	314	lpPropValue->Value.bin.lpb = sPropValue.Value.bin.lpb;
	315	return hrSuccess;
318	316	}
319	317
320	318	/**

2438	2436	icalcomponent_add_property(lpEvent, lpProp);
2439	2437	icalvalue_free(lpicValue);
2440	2438
2441
2442	2439	lpPropVal = PpropFindProp(lpMsgProps, ulMsgProps, PR_RTF_COMPRESSED);
2443	2440	if (lpPropVal && Util::GetBestBody(lpMsgProps, ulMsgProps, fMapiUnicode) == PR_RTF_COMPRESSED) {
2444	2441	string rtf;

2460	2457	lpStream ->Release();
2461	2458	}
2462	2459	}
2463
2464	2460
2465	2461	return hrSuccess;
2466	2462	}

2814	2810	goto exit;
2815	2811
2816	2812	if ((PROP_TYPE(lpSpropArray[0].ulPropTag) != PT_ERROR)
2817		&& (stricmp(lpSpropArray[0].Value.lpszA, "IPM.Task") == 0)) {
	2813	&& (strcasecmp(lpSpropArray[0].Value.lpszA, "IPM.Task") == 0)) {
2818	2814	ulRecurrenceStateTag = CHANGE_PROP_TYPE(m_lpNamedProps->aulPropTag[PROP_TASK_RECURRSTATE], PT_BINARY);
2819	2815	lpSPropRecVal = &lpSpropArray[5];
2820	2816	ulFlag = RECURRENCE_STATE_TASKS;

+0

-1

libicalmapi/vevent.cpp less more

218	218	sPropVal.ulPropTag = PR_MESSAGE_CLASS_W;
219	219	lstMsgProps->push_back(sPropVal);
220	220	}
221
222	221
223	222	if (icMethod == ICAL_METHOD_CANCEL \|\| icMethod == ICAL_METHOD_REQUEST)
224	223	{

+1

-2

libicalmapi/vfreebusy.cpp less more

58	58	lpicProp = icalcomponent_get_first_property(lpFbcomp, ICAL_ATTENDEE_PROPERTY);
59	59	while (lpicProp) {
60	60	strEmail = icalproperty_get_attendee(lpicProp);
61		if (strnicmp(strEmail.c_str(), "mailto:", 7) == 0) {
	61	if (strncasecmp(strEmail.c_str(), "mailto:", 7) == 0) {
62	62	strEmail.erase(0, 7);
63	63	}
64	64	lstUsers->push_back(strEmail);

94	94	time_t tEnd = 0;
95	95	std::string strEmail;
96	96
97
98	97	lpFbComp = icalcomponent_new(ICAL_VFREEBUSY_COMPONENT);
99	98	if (!lpFbComp) {
100	99	hr = MAPI_E_INVALID_PARAMETER;

+0

-2

libicalmapi/vtodo.cpp less more

143	143	sPropVal.Value.ul = ulStatus;
144	144	lplstMsgProps->push_back(sPropVal);
145	145
146
147	146	sPropVal.ulPropTag = PR_ICON_INDEX;
148	147	// 1280: task
149	148	// 1281: recurring task

286	285	{
287	286	HRESULT hr = hrSuccess;
288	287	LPSPropValue lpPropVal = NULL;
289
290	288
291	289	hr = VConverter::HrSetTimeProperties(lpMsgProps, ulMsgProps, lpicTZinfo, strTZid, lpEvent);
292	290	if (hr != hrSuccess)

+0

-4

libsync/ECOfflineABImporter.cpp less more

27	27	#include <edkmdb.h>
28	28
29	29	#include <list>
30
31		#ifdef _DEBUG
32		#define new DEBUG_NEW
33		#endif
34	30
35	31	static inline bool operator==(const ECENTRYID& lhs, const ECENTRYID& rhs)
36	32	{

+1

-2

libsync/ECResyncSet.cpp less more

28	28	{
29	29	return m_map.erase(array_type(sbinSourceKey.lpb, sbinSourceKey.lpb + sbinSourceKey.cb)) == 1;
30	30	}
31
32	31
33	32	ECResyncSetIterator::ECResyncSetIterator(ECResyncSet &resyncSet)
34	33	: m_lpResyncSet(&resyncSet)

77	76	++m_iterator;
78	77	}
79	78
80		const FILETIME ECResyncSetIterator::s_nullTime = {0, 0};⏎
	79	const FILETIME ECResyncSetIterator::s_nullTime = {0, 0};

+0

-27

libsync/ECSyncContext.cpp less more

45	45	typedef mapi_object_ptr<IECChangeAdviseSink, IID_IECChangeAdviseSink> ECChangeAdviseSinkPtr;
46	46	//DEFINEMAPIPTR(ECChangeAdviseSink);
47	47
48		#ifdef _DEBUG
49		#define new DEBUG_NEW
50		#endif
51
52	48	#define EC_SYNC_STATUS_VERSION 1
53
54	49
55	50	#define CALL_MEMBER_FN(object,ptrToMember) ((object).*(ptrToMember))
56	51	class ECChangeAdviseSink _zcp_final : public ECUnknown

58	53	public:
59	54	typedef ULONG(ECSyncContext::*NOTIFYCALLBACK)(ULONG,LPENTRYLIST);
60	55
61		// Constructor
62	56	ECChangeAdviseSink(ECSyncContext *lpsSyncContext, NOTIFYCALLBACK fnCallback)
63	57	: m_lpsSyncContext(lpsSyncContext)
64	58	, m_fnCallback(fnCallback)

144	138	return hr;
145	139	}
146	140
147
148
149	141	ECSyncContext::ECSyncContext(LPMDB lpStore, ECLogger *lpLogger)
150	142	: m_lpStore(lpStore)
151	143	, m_lpLogger(lpLogger)

177	169	pthread_mutex_destroy(&m_hMutex);
178	170	}
179	171
180
181	172	HRESULT ECSyncContext::HrGetMsgStore(LPMDB *lppMsgStore)
182	173	{
183	174	HRESULT hr = hrSuccess;

197	188	exit:
198	189	return hr;
199	190	}
200
201	191
202	192	HRESULT ECSyncContext::HrGetReceiveFolder(LPMAPIFOLDER *lppInboxFolder)
203	193	{

224	214	return hr;
225	215	}
226	216
227
228	217	HRESULT ECSyncContext::HrGetChangeAdvisor(IECChangeAdvisor **lppChangeAdvisor)
229	218	{
230	219	HRESULT hr = hrSuccess;

306	295	return hr;
307	296	}
308	297
309
310	298	HRESULT ECSyncContext::HrGetChangeAdviseSink(IECChangeAdviseSink **lppChangeAdviseSink)
311	299	{
312	300	ASSERT(m_lpChangeAdviseSink != NULL);
313	301	return m_lpChangeAdviseSink->QueryInterface(IID_IECChangeAdviseSink, (void**)lppChangeAdviseSink);
314	302	}
315
316	303
317	304	HRESULT ECSyncContext::HrQueryHierarchyTable(LPSPropTagArray lpsPropTags, LPSRowSet *lppRows)
318	305	{

345	332	return hr;
346	333	}
347	334
348
349	335	HRESULT ECSyncContext::HrOpenRootFolder(LPMAPIFOLDER lppRootFolder, LPMDB lppMsgStore)
350	336	{
351	337	HRESULT hr = hrSuccess;

374	360	return hr;
375	361	}
376	362
377
378	363	HRESULT ECSyncContext::HrOpenFolder(SBinary lpsEntryID, LPMAPIFOLDER lppFolder)
379	364	{
380	365	HRESULT hr = hrSuccess;

398	383	return hr;
399	384	}
400	385
401
402	386	HRESULT ECSyncContext::HrNotifyNewMail(LPNOTIFICATION lpNotification)
403	387	{
404	388	return m_lpStore->NotifyNewMail(lpNotification);
405	389	}
406
407	390
408	391	HRESULT ECSyncContext::HrGetSteps(SBinary lpEntryID, SBinary lpSourceKey, ULONG ulSyncFlags, ULONG *lpulSteps)
409	392	{

526	509	return hr;
527	510	}
528	511
529
530	512	HRESULT ECSyncContext::HrUpdateChangeId(LPSTREAM lpStream)
531	513	{
532	514	HRESULT hr = hrSuccess;

540	522	if (hr != hrSuccess)
541	523	goto exit;
542	524
543
544	525	pthread_mutex_lock(&m_hMutex);
545	526
546	527	if (m_mapNotifiedSyncIds[ulSyncId] <= ulChangeId)

564	545	exit:
565	546	return hr;
566	547	}
567
568	548
569	549	HRESULT ECSyncContext::HrGetSyncStateFromSourceKey(SBinary lpSourceKey, SSyncState lpsSyncState)
570	550	{

582	562	goto exit;
583	563	}
584	564
585
586	565	// Try to get the information from the status stream.
587	566	hr = HrGetSyncStatusStream(lpSourceKey, &lpStream);
588	567	if (FAILED(hr))

613	592	return !m_mapSyncStatus.empty();
614	593	}
615	594
616
617	595	HRESULT ECSyncContext::HrClearSyncStatus()
618	596	{
619	597	m_mapSyncStatus.clear();
620	598	return hrSuccess;
621	599	}
622
623	600
624	601	HRESULT ECSyncContext::HrLoadSyncStatus(SBinary *lpsSyncState)
625	602	{

687	664	exit:
688	665	return hr;
689	666	}
690
691	667
692	668	HRESULT ECSyncContext::HrSaveSyncStatus(LPSPropValue *lppSyncStatusProp)
693	669	{

758	734	return hr;
759	735	}
760	736
761
762	737	HRESULT ECSyncContext::HrGetSyncStatusStream(LPMAPIFOLDER lpFolder, LPSTREAM *lppStream)
763	738	{
764	739	HRESULT hr = hrSuccess;

776	751	MAPIFreeBuffer(lpPropVal);
777	752	return hr;
778	753	}
779
780	754
781	755	HRESULT ECSyncContext::HrGetSyncStatusStream(SBinary lpsSourceKey, LPSTREAM lppStream)
782	756	{

808	782
809	783	return hr;
810	784	}
811
812	785
813	786	HRESULT ECSyncContext::GetResyncID(ULONG *lpulResyncID)
814	787	{

+0

-16

libsync/ECSyncContext.h less more

67	67	* Pointer to a IMsgStore pointer, which will contain
68	68	* a pointer to the requested messages store upon successful
69	69	* completion.
70		* @return HRESULT
71	70	*/
72	71	HRESULT HrGetMsgStore(LPMDB *lppMsgStore);
73	72

79	78	* @param[out] lppInboxFolder
80	79	* Pointer to a IMAPIFolder pointer, which will contain a
81	80	* pointer to the requested folder upon successful completion.
82		* @return HRESULT
83	81	*/
84	82	HRESULT HrGetReceiveFolder(LPMAPIFOLDER *lppInboxFolder);
85	83

109	107	* @param[out] lppChangeAdviseSink
110	108	* Pointer to a IECChangeAdviseSInk pointer, which will contain a
111	109	* pointer to the change advise sink upon successful completion.
112		* @return HRESULT.
113	110	*/
114	111	HRESULT HrGetChangeAdviseSink(IECChangeAdviseSink **lppChangeAdviseSink);
115	112

123	120	* Pointer to a SRowSet pointer, which will be populated with
124	121	* the rows from the hierarchy table. Needs to be freed with
125	122	* FreePRows by the caller.
126		* @return HRESULT
127	123	*/
128	124	HRESULT HrQueryHierarchyTable(LPSPropTagArray lpsPropTags, LPSRowSet *lppRows);
129	125

137	133	* Pointer to a IMsgStore pointer that will contain a pointer to
138	134	* the message store upon successful completion. Passing NULL will
139	135	* cause no MsgStore pointer to be returned.
140		* @return HRESULT
141	136	*/
142	137	HRESULT HrOpenRootFolder(LPMAPIFOLDER lppRootFolder, LPMDB lppMsgStore = NULL);
143	138

150	145	* @param[out] lppFolder
151	146	* Pointer to a IMAPIFolder pointer that will contain a pointer to
152	147	* the requested folder upon successful completion.
153		* @return HRESULT
154	148	*/
155	149	HRESULT HrOpenFolder(SBinary lpsEntryID, LPMAPIFOLDER lppFolder);
156	150

160	154	* @Param[in] lpNotification
161	155	* Pointer to a NOTIFICATION structure that will be send as the
162	156	* new mail notification.
163		* @return HRESULT
164	157	*/
165	158	HRESULT HrNotifyNewMail(LPNOTIFICATION lpNotification);
166	159

179	172	* Pointer to a ULONG variable that will contain the number of steps
180	173	* to complete a synchronization on the selected folder upon successful
181	174	* completion.
182		* @return HRESULT
183	175	*/
184	176	HRESULT HrGetSteps(SBinary lpEntryID, SBinary lpSourceKey, ULONG ulSyncFlags, ULONG *lpulSteps);
185	177

192	184	* @param[in] lpStream
193	185	* The state stream from which the sync id and change id will be
194	186	* extracted.
195		* @return HRESULT
196	187	*/
197	188	HRESULT HrUpdateChangeId(LPSTREAM lpStream);
198	189

205	196
206	197	/**
207	198	* Clear the sync status streams.
208		*
209		* @return HRESULT
210	199	*/
211	200	HRESULT HrClearSyncStatus();
212	201

215	204	*
216	205	* @param[in] lpsSyncState
217	206	* The SBinary structure containing the data to be decoded.
218		* @return HRESULT
219	207	*/
220	208	HRESULT HrLoadSyncStatus(SBinary *lpsSyncState);
221	209

225	213	* @param[in] lppSyncStatusProp
226	214	* Pointer to a SPropValue pointer that will be populated with
227	215	* the binary data that's made out of the status streams.
228		* @return HRESULT
229	216	*/
230	217	HRESULT HrSaveSyncStatus(LPSPropValue *lppSyncStatusProp);
231	218

237	224	* @param[out] lppStream
238	225	* Pointer to a IStream pointer that will contain the
239	226	* sync status stream on successful completion.
240		* @return HRESULT
241	227	*/
242	228	HRESULT HrGetSyncStatusStream(LPMAPIFOLDER lpFolder, LPSTREAM *lppStream);
243	229

250	236	* @param[out] lppStream
251	237	* Pointer to a IStream pointer that will contain the
252	238	* sync status stream on successful completion.
253		* @return HRESULT
254	239	*/
255	240	HRESULT HrGetSyncStatusStream(SBinary lpsSourceKey, LPSTREAM lppStream);
256	241

311	296	* @param[out] lpsSyncState
312	297	* Pointer to a SSyncState structure that will be populated
313	298	* with the retrieved sync state.
314		* @return HRESULT
315	299	*/
316	300	HRESULT HrGetSyncStateFromSourceKey(SBinary lpSourceKey, SSyncState lpsSyncState);
317	301

+1

-6

libsync/ECSyncLog.cpp less more

25	25	#include <cstdlib>
26	26	#include <mapidefs.h>
27	27
28		#ifdef _DEBUG
29		#define new DEBUG_NEW
30		#endif
31
32	28	// for LOG_MAIL
33	29	#include <syslog.h>
34	30

46	42	if (lpSettings->SyncLogEnabled()) {
47	43	char dummy[MAX_PATH + 1] = { 0 };
48	44
49		if (GetTempPathA(sizeof dummy, dummy) >= sizeof dummy)
	45	if (GetTempPath(sizeof dummy, dummy) >= sizeof dummy)
50	46	dummy[0] = 0x00;
51	47
52	48	std::string strPath = dummy + std::string("/");

109	105	pthread_mutex_t ECSyncLog::s_hMutex;
110	106	ECLogger *ECSyncLog::s_lpLogger = NULL;
111	107
112
113	108	ECSyncLog::__initializer::__initializer() {
114	109	pthread_mutex_init(&ECSyncLog::s_hMutex, NULL);
115	110	}

+0

-8

libsync/ECSyncSettings.cpp less more

21	21	#include <mapix.h>
22	22
23	23	#include <kopano/ECLogger.h>
24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28
29	24
30	25	ECSyncSettings* ECSyncSettings::GetInstance()
31	26	{

188	183	return ulPrev;
189	184	}
190	185
191
192
193	186	pthread_mutex_t ECSyncSettings::s_hMutex;
194	187	ECSyncSettings* ECSyncSettings::s_lpInstance = NULL;
195
196	188
197	189	ECSyncSettings::__initializer::__initializer() {
198	190	pthread_mutex_init(&ECSyncSettings::s_hMutex, NULL);

+0

-4

libsync/ECSyncUtil.cpp less more

19	19	#include <kopano/mapi_ptr.h>
20	20
21	21	#include <mapix.h>
22
23		#ifdef _DEBUG
24		#define new DEBUG_NEW
25		#endif
26	22
27	23	HRESULT HrDecodeSyncStateStream(LPSTREAM lpStream, ULONG lpulSyncId, ULONG lpulChangeId, PROCESSEDCHANGESSET *lpSetProcessChanged)
28	24	{

+1

-0

libsync/Makefile.am less more

6	6
7	7	lib_LTLIBRARIES = libkcsync.la
8	8	noinst_DATA = libkcsync.ldd
	9	CLEANFILES = ${noinst_DATA}
9	10
10	11	libkcsync_la_LIBADD = \
11	12	${top_builddir}/common/libkcmapi.la \

+0

-8

m4lcommon/CommonUtil.cpp less more

59	59	#include <netdb.h>
60	60
61	61	using namespace std;
62
63		#ifdef _DEBUG
64		#define new DEBUG_NEW
65		#endif
66	62
67	63	#define PROFILEPREFIX "ec-adm-"
68	64

731	727	hr = lpMsgServiceAdmin->AdminProviders((MAPIUID *)lpProviderUID->Value.bin.lpb, 0, lppProviderAdmin);
732	728	if(hr != hrSuccess)
733	729	goto exit;
734
735	730
736	731	exit:
737	732	if(lpServiceTable)

2821	2816	return hr;
2822	2817	}
2823	2818
2824
2825	2819	/**
2826	2820	* Converts a wrapped message store's entry identifier to a message store entry identifier.
2827	2821	*

3074	3068
3075	3069	return hr;
3076	3070	}
3077
3078	3071
3079	3072	/*
3080	3073	* Get local free/busy message to get delegate information

3246	3239	return hr;
3247	3240	}
3248	3241
3249
3250	3242	/**
3251	3243	* Set proccessing meeting request options of a user
3252	3244	*

+2

-7

m4lcommon/ECFeatures.cpp less more

31	31	bool isFeature(const char* feature)
32	32	{
33	33	for (size_t i = 0; i < arraySize(kopano_features); ++i)
34		if (stricmp(feature, kopano_features[i]) == 0)
	34	if (strcasecmp(feature, kopano_features[i]) == 0)
35	35	return true;
36	36	return false;
37	37	}

50	50	return MAPI_E_INVALID_PARAMETER;
51	51
52	52	for (ULONG i = 0; i < lpProps->Value.MVszA.cValues; ++i)
53		if (stricmp(lpProps->Value.MVszA.lppszA[i], feature) == 0)
	53	if (strcasecmp(lpProps->Value.MVszA.lppszA[i], feature) == 0)
54	54	return hrSuccess;
55	55	return MAPI_E_NOT_FOUND;
56	56	}

144	144	return hr == hrSuccess;
145	145	}
146	146
147		bool isFeatureEnabled(const char* feature, IAddrBook lpAddrBook, IMsgStore lpStore)
148		{
149		return checkFeature(feature, lpAddrBook, lpStore, PR_EC_ENABLED_FEATURES_A);
150		}
151
152	147	bool isFeatureDisabled(const char* feature, IAddrBook lpAddrBook, IMsgStore lpStore)
153	148	{
154	149	return checkFeature(feature, lpAddrBook, lpStore, PR_EC_DISABLED_FEATURES_A);

+0

-1

m4lcommon/ECFeatures.h less more

29	29	HRESULT hasFeature(const WCHAR* feature, LPSPropValue lpProps);
30	30	std::set<std::string> getFeatures();
31	31
32		bool isFeatureEnabled(const char* feature, IAddrBook lpAddrBook, IMsgStore lpUser);
33	32	bool isFeatureDisabled(const char* feature, IAddrBook lpAddrBook, IMsgStore lpUser);
34	33
35	34	#endif

+0

-7

m4lcommon/ECIterators.cpp less more

19	19	#include <kopano/ECRestriction.h>
20	20	#include "HrException.h"
21	21
22		/**
23		* ECHierarchyIteratorBase implementation
24		*/
25	22	ECHierarchyIteratorBase::ECHierarchyIteratorBase(LPMAPICONTAINER lpContainer, ULONG ulFlags, ULONG ulDepth)
26	23	: m_ptrContainer(lpContainer, true)
27	24	, m_ulFlags(ulFlags)

102	99	throw HrException(hr); // @todo: Fix this
103	100	}
104	101
105
106		/**
107		* ECContentsIteratorBase implementation
108		*/
109	102	ECContentsIteratorBase::ECContentsIteratorBase(LPMAPICONTAINER lpContainer, LPSRestriction lpRestriction, ULONG ulFlags, bool bOwnRestriction)
110	103	: m_ptrContainer(lpContainer, true)
111	104	, m_ulFlags(ulFlags)

+1

-21

m4lcommon/ECMemTable.cpp less more

33	33
34	34	#include <kopano/ECDebug.h>
35	35	#include <algorithm>
36
37		#ifdef LINUX
38	36	// needed for htons()
39	37	#include <netdb.h>
40		#endif
41
42		#ifdef _DEBUG
43		#define new DEBUG_NEW
44		#endif
45	38
46	39	using namespace std;
47	40
48		SSortOrderSet sSortDefault = {0, 0};
	41	static SSortOrderSet sSortDefault = {0, 0};
49	42
50	43	class FixStringType _zcp_final {
51	44	public:

270	263
271	264	map<unsigned int, ECTableEntry>::iterator iterRows;
272	265	map<unsigned int, ECTableEntry>::iterator iterNext;
273
274	266
275	267	pthread_mutex_lock(&m_hDataMutex);
276	268

745	737	return hr;
746	738	}
747	739
748
749	740	HRESULT ECMemTableView::SetColumns(LPSPropTagArray lpPropTagArray, ULONG ulFlags)
750	741	{
751	742	HRESULT hr = hrSuccess;

851	842	return hr;
852	843	}
853	844
854
855	845	HRESULT ECMemTableView::SeekRow(BOOKMARK bkOrigin, LONG lRowCount, LONG *lplRowsSought)
856	846	{
857	847	HRESULT hr = hrSuccess;

869	859	exit:
870	860	return hr;
871	861	}
872
873	862
874	863	HRESULT ECMemTableView::SeekRowApprox(ULONG ulNumerator, ULONG ulDenominator)
875	864	{

890	879	return hr;
891	880	}
892	881
893
894	882	HRESULT ECMemTableView::QueryPosition(ULONG lpulRow, ULONG lpulNumerator, ULONG *lpulDenominator)
895	883	{
896	884	HRESULT hr = hrSuccess;

916	904	exit:
917	905	return hr;
918	906	}
919
920	907
921	908	HRESULT ECMemTableView::FindRow(LPSRestriction lpRestriction, BOOKMARK bkOrigin, ULONG ulFlags)
922	909	{

1028	1015	exit:
1029	1016	return hr;
1030	1017	}
1031
1032	1018
1033	1019	HRESULT ECMemTableView::FreeBookmark(BOOKMARK bkPosition)
1034	1020	{

1136	1122	return hr;
1137	1123	}
1138	1124
1139
1140	1125	HRESULT ECMemTableView::SortTable(LPSSortOrderSet lpSortCriteria, ULONG ulFlags)
1141	1126	{
1142	1127	HRESULT hr = hrSuccess;

1222	1207	}
1223	1208	}
1224	1209
1225
1226	1210	// Get all the sort columns and package them as binary keys
1227	1211	for (j = 0; j < lpsSortOrderSet->cSorts; ++j) {
1228	1212	lpsSortID = PpropFindProp(iterData->second.lpsPropVal, iterData->second.cValues, lpsSortOrderSet->aSort[j].ulPropTag);

1262	1246
1263	1247	memcpy(lpSortCriteria, lpsSortOrderSet, CbSSortOrderSet(lpsSortOrderSet));
1264	1248
1265
1266	1249	*lppSortCriteria = lpSortCriteria;
1267	1250	exit:
1268	1251	return hr;

1311	1294	if(hr != hrSuccess)
1312	1295	goto exit;
1313	1296
1314
1315	1297	hr = QueryRowData(&sRowList, lppRows);
1316	1298	if (hr != hrSuccess)
1317	1299	goto exit;
1318	1300	exit:
1319
1320	1301
1321	1302	return hr;
1322	1303	}

1333	1314	ECObjectTableList::const_iterator iterRowList;
1334	1315
1335	1316	convert_context converter;
1336
1337	1317
1338	1318	if (lpsRowList == NULL \|\| lppRows == NULL) {
1339	1319	hr = MAPI_E_INVALID_PARAMETER;

+0

-17

m4lcommon/ECRestriction.cpp less more

22	22	#include <mapicode.h>
23	23	#include <mapix.h>
24	24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28
29	25	/**
30	26	* Allocate and populate a MAPI SRestriction structure based on the current
31	27	* ECRestriction object.

180	176
181	177	inline void ECRestriction::DummyFree(LPVOID) {}
182	178
183
184	179	/**
185	180	* ECAndRestriction
186	181	*/

227	222	return lpNew;
228	223	}
229	224
230
231	225	/**
232	226	* ECOrRestriction
233	227	*/

274	268	return lpNew;
275	269	}
276	270
277
278	271	/**
279	272	* ECNotRestriction
280	273	*/

307	300	ECRestriction *ECNotRestriction::Clone() const {
308	301	return new ECNotRestriction(m_ptrRestriction);
309	302	}
310
311	303
312	304	/**
313	305	* ECContentRestriction

366	358	return new ECContentRestriction(m_ulFuzzyLevel, m_ulPropTag, m_ptrProp);
367	359	}
368	360
369
370	361	/**
371	362	* ECBitMaskRestriction
372	363	*/

390	381	ECRestriction *ECBitMaskRestriction::Clone() const {
391	382	return new ECBitMaskRestriction(m_relBMR, m_ulPropTag, m_ulMask);
392	383	}
393
394	384
395	385	/**
396	386	* ECPropertyRestriction

449	439	return new ECPropertyRestriction(m_relop, m_ulPropTag, m_ptrProp);
450	440	}
451	441
452
453	442	/**
454	443	* ECComparePropsRestriction
455	444	*/

474	463	return new ECComparePropsRestriction(m_relop, m_ulPropTag1, m_ulPropTag2);
475	464	}
476	465
477
478	466	/**
479	467	* ECSizeRestriction
480	468	*/

499	487	return new ECSizeRestriction(m_relop, m_ulPropTag, m_cb);
500	488	}
501	489
502
503	490	/**
504	491	* ECExistRestriction
505	492	*/

521	508	ECRestriction *ECExistRestriction::Clone() const {
522	509	return new ECExistRestriction(m_ulPropTag);
523	510	}
524
525	511
526	512	/**
527	513	* ECSubRestriction

560	546	ECRestriction *ECSubRestriction::Clone() const {
561	547	return new ECSubRestriction(m_ulSubObject, m_ptrRestriction);
562	548	}
563
564	549
565	550	/**
566	551	* ECCommentRestriction

583	568	, m_ptrProp(ptrProp)
584	569	{ }
585	570
586
587	571	HRESULT ECCommentRestriction::GetMAPIRestriction(LPVOID lpBase, LPSRestriction lpRestriction, ULONG ulFlags) const {
588	572	HRESULT hr = hrSuccess;
589	573	SRestriction restriction = {0};

627	611	return new ECCommentRestriction(m_ptrRestriction, m_cValues, m_ptrProp);
628	612	}
629	613
630
631	614	/**
632	615	* ECRawRestriction
633	616	*/

+0

-6

m4lcommon/IECChangeAdvisor.h less more

40	40	* @param[in] ulFlags
41	41	* - SYNC_CATCHUP Update the internal state, but don't perform any operations
42	42	* on the server.
43		* @return HRESULT
44	43	*/
45	44	virtual HRESULT __stdcall Config(LPSTREAM lpStream, LPGUID lpGUID, IECChangeAdviseSink *lpAdviseSink, ULONG ulFlags) = 0;
46	45

49	48	*
50	49	* @param[in] lpStream
51	50	* The stream in which the current state will be stored.
52		* @return HRESULT
53	51	*/
54	52	virtual HRESULT __stdcall UpdateState(LPSTREAM lpStream) = 0;
55	53

61	59	* block of data. The first 4 bytes specify the sync id of the folder to
62	60	* monitor. The second 4 bytes apecify the change id of the folder to monitor.
63	61	* Use the SSyncState structure to easily create and access this data.
64		* @return HRESULT
65	62	*/
66	63	virtual HRESULT __stdcall AddKeys(LPENTRYLIST lpEntryList) = 0;
67	64

71	68	* @param[in] lpEntryList
72	69	* A list of keys specifying the folders to monitor. See AddKeys for
73	70	* information about the key format.
74		* @return HRESULT
75	71	*/
76	72	virtual HRESULT __stdcall RemoveKeys(LPENTRYLIST lpEntryList) = 0;
77	73

94	90	* The syncid for which to update the changeid.
95	91	* @param[in] ulChangeId
96	92	* The new changeid for the specified syncid.
97		*
98		* @return HRESULT
99	93	*/
100	94	virtual HRESULT __stdcall UpdateSyncState(ULONG ulSyncId, ULONG ulChangeId) = 0;
101	95	};

+0

-8

m4lcommon/RecurrenceState.cpp less more

37	37	#endif
38	38	#else
39	39	// Testing for both WIN32 && LINUX makes no f sense
40		#ifdef LINUX
41	40	#define DEBUGPRINT(...)
42		#else
43		#define DEBUGPRINT __noop
44		#endif
45		#endif
46
47		#ifdef _DEBUG
48		#define new DEBUG_NEW
49	41	#endif
50	42
51	43	class BinReader _zcp_final {

+1

-17

m4lcommon/Util.cpp less more

53	53
54	54	#include <kopano/ECGetText.h>
55	55
56		#ifdef _DEBUG
57		#define new DEBUG_NEW
58		#endif
59
60	56	// HACK: prototypes may differ depending on the compiler and/or system (the
61	57	// second parameter may or may not be 'const'). This redeclaration is a hack
62	58	// to have a common prototype "iconv_cast".

71	67	private:
72	68	const char** m_ptr;
73	69	};
74
75	70
76	71	class PropTagCompare _zcp_final {
77	72	public:

84	79	};
85	80
86	81	typedef std::set<ULONG,PropTagCompare> PropTagSet;
87
88	82
89	83	/**
90	84	* Add or replaces a prop value in a an SPropValue array

1261	1255	if (lpProp1->Value.MVszA.cValues == lpProp2->Value.MVszA.cValues) {
1262	1256	for (i = 0; i < lpProp1->Value.MVszA.cValues; ++i) {
1263	1257	if (lpProp1->Value.MVszA.lppszA[i] && lpProp2->Value.MVszA.lppszA[i])
1264		nCompareResult = stricmp(lpProp1->Value.MVszA.lppszA[i], lpProp2->Value.MVszA.lppszA[i]);
	1258	nCompareResult = strcasecmp(lpProp1->Value.MVszA.lppszA[i], lpProp2->Value.MVszA.lppszA[i]);
1265	1259	else
1266	1260	nCompareResult = lpProp1->Value.MVszA.lppszA[i] != lpProp2->Value.MVszA.lppszA[i];
1267	1261

1711	1705
1712	1706	return -1;
1713	1707	}
1714
1715	1708
1716	1709	/**
1717	1710	* Return a human readable string for a specified HRESULT code. You

2440	2433	if (hr != hrSuccess)
2441	2434	goto exit;
2442	2435
2443
2444	2436	hr = hex2bin(input, len, buffer);
2445	2437	if(hr != hrSuccess)
2446	2438	goto exit;

2453	2445	exit:
2454	2446	return hr;
2455	2447	}
2456
2457	2448
2458	2449	/**
2459	2450	* Converts a string containing hexidecimal numbers into binary

2483	2474	exit:
2484	2475	return hr;
2485	2476	}
2486
2487	2477
2488	2478	/**
2489	2479	* Return the original body property tag of a message, or PR_NULL when unknown.

2987	2977	if (hr != hrSuccess)
2988	2978	goto exit;
2989	2979
2990
2991	2980	hr = lpSrc->GetHierarchyTable(MAPI_UNICODE, &lpTable);
2992	2981	if (hr != hrSuccess)
2993	2982	goto exit;

3092	3081	ULONG ulObj;
3093	3082	LPMESSAGE lpSrcMessage = NULL, lpDestMessage = NULL;
3094	3083	LPENTRYLIST lpDeleteEntries = NULL;
3095
3096	3084
3097	3085	hr = lpSrc->GetContentsTable(MAPI_UNICODE \| ulWhat, &lpTable);
3098	3086	if (hr != hrSuccess)

3346	3334	goto exit;
3347	3335	}
3348	3336
3349
3350	3337	hr = FindInterface(&IID_IMAPIProp, ciidExclude, rgiidExclude);
3351	3338	if (hr == hrSuccess) {
3352	3339	hr = MAPI_E_INTERFACE_NOT_SUPPORTED;

3354	3341	}
3355	3342
3356	3343	// end sanity checks
3357
3358	3344
3359	3345	// check message, folder, attach, recipients, stream, mapitable, ... ?
3360	3346

3388	3374	if (hr != hrSuccess)
3389	3375	bPartial = true;
3390	3376	}
3391
3392	3377
3393	3378	} else if (*lpSrcInterface == IID_IMessage) {
3394	3379	// recipients & attachments

3841	3826	}
3842	3827	}
3843	3828
3844
3845	3829	hr = lpSrcProp->GetProps(lpIncludeProps, 0, &cValues, &lpProps);
3846	3830	if (FAILED(hr))
3847	3831	goto exit;

+4

-86

m4lcommon/favoritesutil.cpp less more

29	29	#include <string>
30	30	using namespace std;
31	31
32		#ifdef _DEBUG
33		#define new DEBUG_NEW
34		#endif
35
36
37		SizedSPropTagArray(SHORTCUT_NUM, sPropsShortcuts) = {SHORTCUT_NUM, { PR_INSTANCE_KEY, PR_FAV_PUBLIC_SOURCE_KEY, PR_FAV_PARENT_SOURCE_KEY, PR_FAV_DISPLAY_NAME, PR_FAV_DISPLAY_ALIAS, PR_FAV_LEVEL_MASK, PR_FAV_CONTAINER_CLASS}};
38
	32	static SizedSPropTagArray(SHORTCUT_NUM, sPropsShortcuts) = {SHORTCUT_NUM, {
	33	PR_INSTANCE_KEY, PR_FAV_PUBLIC_SOURCE_KEY, PR_FAV_PARENT_SOURCE_KEY,
	34	PR_FAV_DISPLAY_NAME, PR_FAV_DISPLAY_ALIAS, PR_FAV_LEVEL_MASK,
	35	PR_FAV_CONTAINER_CLASS}};
39	36
40	37	LPSPropTagArray GetShortCutTagArray() {
41	38	return (LPSPropTagArray)&sPropsShortcuts;

225	222
226	223	if (lpRows->cRows == 0)
227	224	goto exit; // Folder already removed
228
229	225
230	226	hr = MAPIAllocateBuffer(sizeof(ENTRYLIST), (void**)&lpsMsgList);
231	227	if (hr != hrSuccess)

528	524	MAPIFreeBuffer(lpsPropArray);
529	525	return hr;
530	526	}
531
532		/**
533		* Check if the favorite is exist. If the favorite is exist, it will returns the favorite data
534		* @param ulFlags unicode flag (unused, since SetColumns always sets the correct tags)
535		*/
536		HRESULT GetFavorite(IMAPIFolder lpShortcutFolder, ULONG ulFlags, IMAPIFolder lpMapiFolder, ULONG lpcValues, LPSPropValue lppShortCutPropValues)
537		{
538		HRESULT hr = hrSuccess;
539		LPSPropValue lpPropSourceKey = NULL;
540
541		LPMAPITABLE lpTable = NULL;
542
543		LPSPropValue lpShortCutPropValues = NULL;
544		ULONG cShortCutValues = 0;
545
546		LPSRestriction lpRestriction = NULL;
547
548		SRowSet *lpRows = NULL;
549
550		if (lpShortcutFolder == NULL \|\| lpMapiFolder == NULL) {
551		hr = MAPI_E_INVALID_PARAMETER;
552		goto exit;
553		}
554
555		hr = HrGetOneProp(lpMapiFolder, PR_SOURCE_KEY, &lpPropSourceKey);
556		if (hr != hrSuccess) {
557		hr = MAPI_E_CORRUPT_DATA;
558		goto exit;
559		}
560
561		// Check for duplicates
562		hr = lpShortcutFolder->GetContentsTable(ulFlags, &lpTable);
563		if (hr != hrSuccess)
564		goto exit;
565
566		hr = lpTable->SetColumns(GetShortCutTagArray(), 0);
567		if(hr != hrSuccess)
568		goto exit;
569
570		// build restriction
571		CREATE_RESTRICTION(lpRestriction);
572		CREATE_RES_AND(lpRestriction, lpRestriction, 1);
573		DATA_RES_PROPERTY(lpRestriction, lpRestriction->res.resAnd.lpRes[0], RELOP_EQ, PR_FAV_PUBLIC_SOURCE_KEY, lpPropSourceKey);
574
575		hr = lpTable->FindRow(lpRestriction, BOOKMARK_BEGINNING, 0);
576		if (hr != hrSuccess)
577		goto exit;
578
579		// Favorite is exist, get the information
580
581		hr = lpTable->QueryRows (1, 0, &lpRows);
582		if (hr != hrSuccess)
583		goto exit;
584
585		if (lpRows->cRows == 0) {
586		hr = MAPI_E_NOT_FOUND;
587		goto exit; // Folder gone?
588		}
589
590		cShortCutValues = 0;
591		hr = Util::HrCopyPropertyArray(lpRows->aRow[0].lpProps, lpRows->aRow[0].cValues, &lpShortCutPropValues, &cShortCutValues, true);
592		if (hr != hrSuccess)
593		goto exit;
594
595
596		*lppShortCutPropValues = lpShortCutPropValues;
597		*lpcValues = cShortCutValues;
598		exit:
599		if (hr != hrSuccess)
600		MAPIFreeBuffer(lpShortCutPropValues);
601		MAPIFreeBuffer(lpPropSourceKey);
602		if (lpTable)
603		lpTable->Release();
604
605		FREE_RESTRICTION(lpRestriction);
606
607		return hr;
608		}

+0

-2

m4lcommon/favoritesutil.h less more

42	42	HRESULT AddToFavorite(IMAPIFolder *lpShortcutFolder, ULONG ulLevel, LPCTSTR lpszAliasName, ULONG ulFlags, ULONG cValues, LPSPropValue lpPropArray);
43	43	HRESULT GetShortcutFolder(LPMAPISESSION lpSession, LPTSTR lpszFolderName, LPTSTR lpszFolderComment, ULONG ulFlags, LPMAPIFOLDER* lppShortcutFolder);
44	44	HRESULT CreateShortcutFolder(IMsgStore lpMsgStore, LPTSTR lpszFolderName, LPTSTR lpszFolderComment, ULONG ulFlags, LPMAPIFOLDER lppShortcutFolder);
45		HRESULT GetFavorite(IMAPIFolder lpShortcutFolder, ULONG ulFlags, IMAPIFolder lpMapiFolder, ULONG lpcValues, LPSPropValue lppShortCutPropValues);
46
47	45	HRESULT DelFavoriteFolder(IMAPIFolder *lpShortcutFolder, LPSPropValue lpPropSourceKey);
48	46	HRESULT AddFavoriteFolder(IMAPIFolder *lpShortcutFolder, LPMAPIFOLDER lpFolder, LPCTSTR lpszAliasName, ULONG ulFlags);
49	47

+3

-3

m4lcommon/include/kopano/CommonUtil.h less more

43	43	const char GetServerUnixSocket(const char szPreferred = NULL);
44	44	std::string GetServerFQDN();
45	45
46		HRESULT HrOpenECAdminSession(ECLogger const lpLogger, IMAPISession lppSession, const char const app_version, const char const app_misc, const char szPath = NULL, ULONG ulProfileFlags = 0, const char sslkey_file = NULL, const char sslkey_password = NULL);
	46	HRESULT __attribute__((nonnull(1))) HrOpenECAdminSession(ECLogger const lpLogger, IMAPISession lppSession, const char const app_version, const char const app_misc, const char szPath = NULL, ULONG ulProfileFlags = 0, const char sslkey_file = NULL, const char sslkey_password = NULL);
47	47
48		HRESULT HrOpenECSession(ECLogger const lpLogger, IMAPISession lppSession, const char const app_version, const char const app_misc, const WCHAR szUsername, const WCHAR szPassword, const char szPath = NULL, ULONG ulProfileFlags = 0, const char sslkey_file = NULL, const char sslkey_password = NULL, const char *profname = NULL);
	48	HRESULT __attribute__((nonnull(1))) HrOpenECSession(ECLogger const lpLogger, IMAPISession lppSession, const char const app_version, const char const app_misc, const WCHAR szUsername, const WCHAR szPassword, const char szPath = NULL, ULONG ulProfileFlags = 0, const char sslkey_file = NULL, const char sslkey_password = NULL, const char *profname = NULL);
49	49
50	50	HRESULT HrSearchECStoreEntryId(IMAPISession lpMAPISession, BOOL bPublic, ULONG lpcbEntryID, LPENTRYID *lppEntryID);
51	51

75	75
76	76	HRESULT GetClientVersion(unsigned int* ulVersion);
77	77
78		HRESULT CreateProfileTemp(ECLogger const lpLogger, const WCHAR username, const WCHAR password, const char path, const char* szProfName, ULONG ulProfileFlags, const char sslkey_file, const char sslkey_password, const char app_version, const char app_misc);
	78	HRESULT __attribute__((nonnull(1))) CreateProfileTemp(ECLogger const lpLogger, const WCHAR username, const WCHAR password, const char path, const char* szProfName, ULONG ulProfileFlags, const char sslkey_file, const char sslkey_password, const char app_version, const char app_misc);
79	79	HRESULT DeleteProfileTemp(char *szProfName);
80	80
81	81	HRESULT OpenSubFolder(LPMDB lpMDB, const WCHAR folder, WCHAR psep, ECLogger lpLogger, bool bIsPublic, bool bCreateFolder, LPMAPIFOLDER *lppSubFolder);

+0

-9

m4lcommon/include/kopano/mapi_ptr/mapi_array_ptr.h less more

48	48
49	49	enum { element_size = sizeof(_T) };
50	50
51		// Constructors
52	51	mapi_array_ptr() : m_lpObject(NULL) {}
53	52
54	53	mapi_array_ptr(pointer lpObject) : m_lpObject(lpObject) {}
55
56
57		// Destructor
58	54	~mapi_array_ptr() {
59	55	MAPIFreeBuffer(m_lpObject);
60	56	m_lpObject = NULL;
61	57	}
62	58
63
64		// Assignment
65	59	mapi_array_ptr& operator=(pointer lpObject) {
66	60	if (m_lpObject != lpObject) {
67	61	mapi_array_ptr tmp(lpObject);

70	64	return *this;
71	65	}
72	66
73
74		// Dereference
75	67	reference operator() { return m_lpObject; }
76	68	const_reference operator() const { return m_lpObject; }
77	69
78
79	70	// Utility
80	71	void swap(mapi_array_ptr &other) {
81	72	std::swap(m_lpObject, other.m_lpObject);

+0

-9

m4lcommon/include/kopano/mapi_ptr/mapi_memory_ptr.h less more

49	49	typedef const _T& const_reference;
50	50	typedef mapi_memory_proxy<_T> proxy;
51	51
52
53		// Constructors
54	52	mapi_memory_ptr() : m_lpMemory(NULL) {}
55	53
56	54	mapi_memory_ptr(pointer lpObject) : m_lpMemory(lpObject) {}
57
58
59		// Destructor
60	55	~mapi_memory_ptr() {
61	56	MAPIFreeBuffer(m_lpMemory);
62	57	m_lpMemory = NULL;
63	58	}
64	59
65
66		// Assignment
67	60	mapi_memory_ptr& operator=(pointer lpObject) {
68	61	if (m_lpMemory != lpObject) {
69	62	mapi_memory_ptr tmp(lpObject);

72	65	return *this;
73	66	}
74	67
75
76		// Dereference
77	68	pointer operator->() { return m_lpMemory; }
78	69	const_pointer operator->() const { return m_lpMemory; }
79	70

+0

-5

m4lcommon/include/kopano/mapi_ptr/mapi_object_ptr.h less more

56	56	typedef const _T& const_reference;
57	57	typedef mapi_object_proxy<_T,_R> proxy;
58	58
59		// Constructors
60	59	mapi_object_ptr() : m_lpObject(NULL) {}
61	60
62	61	explicit mapi_object_ptr(pointer lpObject, bool bAddRef = true) : m_lpObject(lpObject) {

69	68	m_lpObject->AddRef();
70	69	}
71	70
72
73		// Destructor
74	71	~mapi_object_ptr() {
75	72	if (m_lpObject) {
76	73	m_lpObject->Release();

78	75	}
79	76	}
80	77
81
82		// Assignment
83	78	mapi_object_ptr& operator=(const mapi_object_ptr &other) {
84	79	if (this != &other) {
85	80	mapi_object_ptr tmp(other);

+0

-3

m4lcommon/include/kopano/userutil.h less more

25	25	#include <mapix.h>
26	26	class ECLogger;
27	27
28		HRESULT ValidateArchivedUserCount(ECLogger lpLogger, IMAPISession lpMapiSession, const char lpSSLKey, const char lpSSLPass, unsigned int lpulArchivedUsers, unsigned int lpulMaxUsers);
29		HRESULT GetArchivedUserCount(ECLogger lpLogger, IMAPISession lpMapiSession, const char lpSSLKey, const char lpSSLPass, unsigned int *lpulArchivedUsers);
30
31	28	HRESULT GetArchivedUserList(ECLogger lpLogger, IMAPISession lpMapiSession, const char lpSSLKey, const char lpSSLPass, std::list<std::string> *lplstUsers, bool bLocalOnly = false);
32	29	HRESULT GetArchivedUserList(ECLogger lpLogger, IMAPISession lpMapiSession, const char lpSSLKey, const char lpSSLPass, std::list<std::wstring> *lplstUsers, bool bLocalOnly = false);
33	30

+0

-63

m4lcommon/userutil.cpp less more

67	67	static HRESULT GetMailboxDataPerServer(ECLogger lpLogger, IMAPISession lpSession, const char lpszPath, DataCollector lpCollector);
68	68	static HRESULT UpdateServerList(ECLogger lpLogger, IABContainer lpContainer, std::set<servername> &listServers);
69	69
70
71	70	class UserCountCollector _zcp_final : public DataCollector
72	71	{
73	72	public:

96	95	std::list<string_type> m_lstUsers;
97	96	MAPISessionPtr m_ptrSession;
98	97	};
99
100	98
101	99	HRESULT DataCollector::GetRequiredPropTags(LPMAPIPROP /lpProp/, LPSPropTagArray *lppPropTagArray) const {
102	100	static SizedSPropTagArray(1, sptaDefaultProps) = {1, {PR_DISPLAY_NAME}};

131	129	return hr;
132	130	}
133	131
134
135
136	132	UserCountCollector::UserCountCollector(): m_ulUserCount(0) {}
137	133
138	134	HRESULT UserCountCollector::CollectData(LPMAPITABLE lpStoreTable) {

152	148	inline unsigned int UserCountCollector::result() const {
153	149	return m_ulUserCount;
154	150	}
155
156	151
157	152	template<typename string_type, ULONG prAccount>
158	153	UserListCollector<string_type, prAccount>::UserListCollector(IMAPISession *lpSession): m_ptrSession(lpSession, true) {}

213	208	template<>
214	209	void UserListCollector<std::wstring, PR_ACCOUNT_W>::push_back(LPSPropValue lpPropAccount) {
215	210	m_lstUsers.push_back(lpPropAccount->Value.lpszW);
216		}
217
218
219
220		HRESULT ValidateArchivedUserCount(ECLogger lpLogger, IMAPISession lpMapiSession, const char lpSSLKey, const char lpSSLPass, unsigned int lpulArchivedUsers, unsigned int lpulMaxUsers)
221		{
222		HRESULT hr = S_OK;
223		unsigned int ulArchivedUsers = 0;
224		unsigned int ulMaxUsers = 0;
225		MsgStorePtr ptrStore;
226		ECLicensePtr ptrLicense;
227
228		hr = GetArchivedUserCount(lpLogger, lpMapiSession, lpSSLKey, lpSSLPass, &ulArchivedUsers);
229		if (hr != hrSuccess)
230		goto exit;
231
232		//@todo use PR_EC_OBJECT property
233		hr = HrOpenDefaultStore(lpMapiSession, &ptrStore);
234		if(hr != hrSuccess) {
235		lpLogger->Log(EC_LOGLEVEL_CRIT, "Unable to open default store: 0x%08X", hr);
236		goto exit;
237		}
238
239		hr = ptrStore->QueryInterface(IID_IECLicense, &ptrLicense);
240		if(hr != hrSuccess)
241		goto exit;
242
243		// Do no check the return value, possible the license server isn't running!
244		ptrLicense->LicenseUsers(1/SERVICE_TYPE_ARCHIVE/, &ulMaxUsers);
245
246
247		*lpulArchivedUsers = ulArchivedUsers;
248		*lpulMaxUsers = ulMaxUsers;
249
250		exit:
251		return hr;
252		}
253
254		/**
255		* Get the archived users
256		*
257		* @param[out] lpulArchivedUsers Get archived user count
258		*
259		* @return MAPI error codes
260		*/
261		HRESULT GetArchivedUserCount(ECLogger lpLogger, IMAPISession lpMapiSession, const char lpSSLKey, const char lpSSLPass, unsigned int *lpulArchivedUsers)
262		{
263		HRESULT hr = hrSuccess;
264		UserCountCollector collector;
265
266		hr = GetMailboxData(lpLogger, lpMapiSession, lpSSLKey, lpSSLPass, false, &collector);
267		if (hr != hrSuccess)
268		goto exit;
269
270		*lpulArchivedUsers = collector.result();
271
272		exit:
273		return hr;
274	211	}
275	212
276	213	HRESULT GetArchivedUserList(ECLogger lpLogger, IMAPISession lpMapiSession, const char lpSSLKey, const char lpSSLPass, std::list<std::string> *lplstUsers, bool bLocalOnly)

+5

-0

mapi4linux/src/Makefile.am less more

8	8
9	9	lib_LTLIBRARIES = libmapi.la libkchl.la
10	10	noinst_DATA = libmapi.ldd libkchl.ldd
	11	CLEANFILES = ${noinst_DATA}
11	12
12	13	libmapi_la_LDFLAGS = ${AM_LDFLAGS} -no-undefined -version-info 1:0:0 \
13	14	-Wl,--version-script=libmapi.sym ${BOOST_FILESYSTEM_LDFLAGS}

28	29
29	30	libkchl_la_SOURCES = hl.cpp
30	31	libkchl_la_LIBADD = libmapi.la
	32	libkchl_la_LDFLAGS = ${AM_LDFLAGS} -no-undefined -version-info 0:0:0 \
	33	-Wl,--version-script=${top_builddir}/default.sym
	34	EXTRA_libkchl_la_DEPENDENCIES = ${top_builddir}/default.sym
	35
31	36
32	37	check-syntax:
33	38	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \

+0

-1

mapi4linux/src/common.cpp less more

20	20	#include <mapidefs.h>
21	21	#include <mapiguid.h>
22	22
23		// IUnknown implementation
24	23	M4LUnknown::M4LUnknown() {
25	24	ref = 0;
26	25	pthread_mutex_init(&mutex, NULL);

+0

-4

mapi4linux/src/m4l.debug.h less more

99	99	#ifdef DEBUG
100	100	#define ORIG_TRACE_MAPILIB TraceMapiLib
101	101	#else
102		#ifdef LINUX
103	102	#define ORIG_TRACE_MAPILIB(...)
104		#else
105		#define ORIG_TRACE_MAPILIB __noop
106		#endif
107	103	#endif
108	104	#undef TRACE_MAPILIB
109	105

+1

-2

mapi4linux/src/m4l.mapisvc.cpp less more

231	231	HRESULT hr;
232	232	SPropValue sProp;
233	233
	234	memset(&sProp, 0, sizeof(sProp));
234	235	sProp.ulPropTag = DefinitionFromString(strTag, true);
235	236	switch (PROP_TYPE(sProp.ulPropTag)) {
236	237	case PT_LONG:

317	318	{
318	319	HRESULT hr;
319	320	inf_section::const_iterator iSection;
320		vector<string> prop;
321	321
322	322	hr = MAPIAllocateBuffer(sizeof(SPropValue) * infProvider->size(), (void**)&m_lpProps);
323	323	if (hr != hrSuccess)

330	330	++m_cValues;
331	331	return hrSuccess;
332	332	}
333
334	333
335	334	SVCService::SVCService()
336	335	{

+0

-5

mapi4linux/src/mapidefs.cpp less more

352	352	return hr;
353	353	}
354	354
355
356	355	// ---
357	356	// IProfSect
358	357	// ---

360	359	M4LProfSect::M4LProfSect(BOOL bGlobalProf) {
361	360	this->bGlobalProf = bGlobalProf;
362	361	}
363
364	362
365	363	HRESULT M4LProfSect::ValidateState(ULONG ulUIParam, ULONG ulFlags) {
366	364	TRACE_MAPILIB(TRACE_ENTRY, "M4LProfSect::ValidateState", "");

456	454	TRACE_MAPILIB1(TRACE_RETURN, "M4LProfSect::QueryInterface", "0x%08x", hr);
457	455	return hr;
458	456	}
459
460	457
461	458	// ---
462	459	// IMAPITable

928	925	return hr;
929	926	}
930	927
931
932	928	//
933	929	// IMAPIAdviseSink
934	930	//

941	937	ULONG M4LMAPIAdviseSink::OnNotify(ULONG cNotif, LPNOTIFICATION lpNotifications) {
942	938	return this->lpFn(this->lpContext, cNotif, lpNotifications);
943	939	}
944
945	940
946	941	// iunknown passthru
947	942	ULONG M4LMAPIAdviseSink::AddRef() {

+0

-2

mapi4linux/src/mapispi.cpp less more

333	333	LPENTRYLIST lpDeleteEntries = NULL;
334	334	bool bPartial = false;
335	335	ULONG i;
336
337	336
338	337	if (!lpSrcInterface \|\| !lpSrcFolder \|\| !lpDestFolder \|\| !lpMsgList) {
339	338	hr = MAPI_E_INVALID_PARAMETER;

603	602	if (_tcscmp(lpAddrType->Value.LPSZ, _T("MAPIPDL")))
604	603	continue;
605	604
606
607	605	lpDLEntryID = PpropFindProp(ptrRow[0].lpProps, ptrRow[0].cValues, PR_ENTRYID);
608	606	if (!lpDLEntryID)
609	607	continue;

+0

-4

mapi4linux/src/mapiutil.cpp less more

355	355	return hr;
356	356	}
357	357
358
359	358	//--- php-ext used functions
360	359	HRESULT __stdcall HrQueryAllRows(LPMAPITABLE lpTable, LPSPropTagArray lpPropTags, LPSRestriction lpRestriction, LPSSortOrderSet lpSortOrderSet, LONG crowsMax, LPSRowSet *lppRows) {
361	360	TRACE_MAPILIB1(TRACE_ENTRY, "HrQueryAllRows", "%s", PropNameFromPropTagArray(lpPropTags).c_str());

447	446	return (hr == hrSuccess);
448	447	}
449	448
450
451	449	/* Actually not part of MAPI */
452		#ifdef LINUX
453	450	HRESULT __stdcall CreateStreamOnHGlobal(void hGlobal, BOOL fDeleteOnRelease, IStream *lppStream)
454	451	{
455	452	HRESULT hr = hrSuccess;

473	470
474	471	return hr;
475	472	}
476		#endif
477	473
478	474	HRESULT __stdcall OpenStreamOnFile(LPALLOCATEBUFFER lpAllocateBuffer, LPFREEBUFFER lpFreeBuffer, ULONG ulFlags,
479	475	LPTSTR lpszFileName, LPTSTR lpszPrefix, LPSTREAM FAR * lppStream)

+0

-9

mapi4linux/src/mapix.cpp less more

518	518	return *i;
519	519	return NULL;
520	520	}
521
522	521
523	522	HRESULT M4LMsgServiceAdmin::GetLastError(HRESULT hResult, ULONG ulFlags, LPMAPIERROR* lppMAPIError) {
524	523	TRACE_MAPILIB(TRACE_ENTRY, "M4LMsgServiceAdmin::GetLastError", "");

976	975	PR_DISPLAY_NAME_A, PR_OBJECT_TYPE, PR_PROVIDER_UID, PR_RESOURCE_TYPE,
977	976	PR_PROVIDER_DISPLAY_A, PR_SERVICE_UID}};
978	977
979
980	978	pthread_mutex_lock(&m_mutexserviceadmin);
981	979
982	980	for (j = services.begin(); j != services.end(); ++j) {

1082	1080	TRACE_MAPILIB1(TRACE_RETURN, "M4LMsgServiceAdmin::QueryInterface", "0x%08x", hr);
1083	1081	return hr;
1084	1082	}
1085
1086	1083
1087	1084	// ---
1088	1085	// M4LMAPISession

1887	1884	return hr;
1888	1885	}
1889	1886
1890
1891	1887	// ---
1892	1888	// M4LAddrBook
1893	1889	// ---

2006	2002
2007	2003	return hr;
2008	2004	}
2009
2010	2005
2011	2006	//
2012	2007	// How it works:

2713	2708	return hr;
2714	2709	}
2715	2710
2716
2717	2711	// imapiprop passthru
2718	2712	// maybe not all functions should be passed though?
2719	2713	HRESULT M4LAddrBook::GetLastError(HRESULT hResult, ULONG ulFlags, LPMAPIERROR* lppMAPIError) {

2799	2793	return hr;
2800	2794	}
2801	2795
2802
2803	2796	// iunknown passthru
2804	2797	ULONG M4LAddrBook::AddRef() {
2805	2798	TRACE_MAPILIB(TRACE_ENTRY, "M4LAddrBook::AddRef", "");

2828	2821	TRACE_MAPILIB1(TRACE_RETURN, "M4LAddrBook::QueryInterface", "0x%08x", hr);
2829	2822	return hr;
2830	2823	}
2831
2832
2833	2824
2834	2825	// ---------------------------------------
2835	2826

+0

-2

php-ext/ECImportContentsChangesProxy.cpp less more

36	36	#include "ext/standard/php_string.h"
37	37	}
38	38
39
40
41	39	// A very, very nice PHP #define that causes link errors in MAPI when you have multiple
42	40	// files referencing MAPI....
43	41	#undef inline

+0

-2

php-ext/ECImportHierarchyChangesProxy.cpp less more

36	36	#include "ext/standard/php_string.h"
37	37	}
38	38
39
40
41	39	// A very, very nice PHP #define that causes link errors in MAPI when you have multiple
42	40	// files referencing MAPI....
43	41	#undef inline

+0

-6

php-ext/ECRulesTableProxy.cpp less more

24	24
25	25	#include <mapix.h>
26	26
27
28	27	/* conversion from unicode to string8 for rules table data */
29	28	static HRESULT ConvertUnicodeToString8(LPSRestriction lpRes, void *base, convert_context &converter);
30	29	static HRESULT ConvertUnicodeToString8(const ACTIONS lpActions, void base, convert_context &converter);
31
32	30
33	31	ECRulesTableProxy::ECRulesTableProxy(LPMAPITABLE lpTable)
34	32	: m_lpTable(lpTable)

63	61	exit:
64	62	return hr;
65	63	}
66
67	64
68	65	HRESULT ECRulesTableProxy::QueryInterface(REFIID refiid, void **lppInterface)
69	66	{

230	227	METHOD_PROLOGUE_(ECRulesTableProxy, MAPITable);
231	228	return pThis->Release();
232	229	}
233
234	230
235	231	DEF_HRMETHOD(TRACE_MAPI, ECRulesTableProxy, MAPITable, QueryInterface, (REFIID, refiid), (void **, lppInterface))
236	232	DEF_HRMETHOD(TRACE_MAPI, ECRulesTableProxy, MAPITable, GetLastError, (HRESULT, hResult), (ULONG, ulFlags), (LPMAPIERROR *, lppMAPIError))

257	253	DEF_HRMETHOD(TRACE_MAPI, ECRulesTableProxy, MAPITable, GetCollapseState, (ULONG, ulFlags), (ULONG, cbInstanceKey, LPBYTE, lpbInstanceKey), (ULONG , lpcbCollapseState, LPBYTE , lppbCollapseState))
258	254	DEF_HRMETHOD(TRACE_MAPI, ECRulesTableProxy, MAPITable, SetCollapseState, (ULONG, ulFlags), (ULONG, cbCollapseState, LPBYTE, pbCollapseState), (BOOKMARK *, lpbkLocation))
259	255
260
261
262	256	static HRESULT ConvertUnicodeToString8(const WCHAR lpszW, char *lppszA,
263	257	void *base, convert_context &converter)
264	258	{

+3

-3

php-ext/Makefile.am less more

7	7	$(PHP_INCLUDES)
8	8	AM_CXXFLAGS = ${ZCXXFLAGS} ${ZPHPCXXFLAGS}
9	9
10		lib_LTLIBRARIES = mapi.la
	10	phplib_LTLIBRARIES = mapi.la
11	11
12		libdir=$(PHP_EXTENSION_DIR)
	12	phplibdir = ${dcprefix}${PHP_EXTENSION_DIR}
13	13
14	14	mapi_la_LDFLAGS = ${AM_LDFLAGS} -module -avoid-version \
15	15	$(PHP_LDFLAGS)

36	36	# If we install our config file into that location, it will only be available
37	37	# to only apache2-mod_php5 and not php-cli, php-fpm, etc.
38	38	#
39		sysconfdir = ${PHP_SYSCONF_DIR}
	39	sysconfdir = ${dcprefix}${PHP_SYSCONF_DIR}
40	40	dist_sysconf_DATA = mapi.ini
41	41
42	42	sampleconfdir = ${docdir}/example-config

+3

-3

php-ext/include/mapi/class.baseexception.php less more

95	95	}
96	96
97	97	/**
98		* @return string returns file name and line number combined where exception occured.
	98	* @return string returns file name and line number combined where exception occurred.
99	99	*/
100	100	public function getFileLine()
101	101	{

135	135	}
136	136
137	137	/**
138		* @return string returns base path of the file where exception occured.
	138	* @return string returns base path of the file where exception occurred.
139	139	*/
140	140	public function getBaseFile()
141	141	{

191	191
192	192	// @TODO getTrace and getTraceAsString
193	193	}
194		?>⏎
	194	?>

+0

-1

php-ext/include/mapi/class.baserecurrence.php less more

55	55	var $tz;
56	56
57	57	/**
58		* Constructor
59	58	* @param resource $store MAPI Message Store Object
60	59	* @param resource $message the MAPI (appointment) message
61	60	* @param array $properties the list of MAPI properties the message has.

+0

-2

php-ext/include/mapi/class.freebusypublish.php less more

31	31	var $proptags;
32	32
33	33	/**
34		* Constuctor
35		*
36	34	* @param mapi_session $session MAPI Session
37	35	* @param mapi_folder $calendar Calendar to publish
38	36	* @param string $entryid AddressBook Entry ID for the user we're publishing for

+3

-5

php-ext/include/mapi/class.meetingrequest.php less more

105	105	var $errorSetResource;
106	106
107	107	/**
108		* Constructor
109		*
110	108	* Takes a store and a message. The message is an appointment item
111	109	* that should be converted into a meeting request or an incoming
112	110	* e-mail message that is a meeting request.

841	839
842	840	if ($move) {
843	841	// All we have to do is open the default calendar,
844		// set the mesage class correctly to be an appointment item
	842	// set the message class correctly to be an appointment item
845	843	// and move it to the calendar folder
846	844	$sourcefolder = $this->openParentFolder();
847	845

2359	2357	$this->includesResources = true;
2360	2358	}else{
2361	2359	/**
2362		* If no other errors occured and you have no access to the
	2360	* If no other errors occurred and you have no access to the
2363	2361	* folder of the resource, throw an error=1.
2364	2362	*/
2365	2363	if(!$this->errorSetResource){

2845	2843	$result = true;
2846	2844	}
2847	2845	} else {
2848		// we are not able to find exception, could mean that a significant change has occured on series
	2846	// we are not able to find exception, could mean that a significant change has occurred on series
2849	2847	// and it deleted all exceptions, so compare with series
2850	2848	if ((isset($calendarItemProps[$this->proptags['updatecounter']]) && $props[$this->proptags['updatecounter']] < $calendarItemProps[$this->proptags['updatecounter']])
2851	2849	\|\| (isset($calendarItemProps[$this->proptags['owner_critical_change']]) && $props[$this->proptags['owner_critical_change']] < $calendarItemProps[$this->proptags['owner_critical_change']])) {

+0

-1

php-ext/include/mapi/class.recurrence.php less more

59	59	);
60	60
61	61	/**
62		* Constructor
63	62	* @param resource $store MAPI Message Store Object
64	63	* @param resource $message the MAPI (appointment) message
65	64	*/

+1

-1

php-ext/include/mapi/class.taskrecurrence.php less more

174	174	$this->action['startdate'] = $props[$this->proptags['startdate']] = $nextOccurrence[$this->proptags['startdate']];
175	175	$this->action['commonstart'] = $props[$this->proptags['commonstart']] = $nextOccurrence[$this->proptags['startdate']];
176	176
177		// If current task as been mark as 'Complete' then next occurrence should be uncomplete.
	177	// If current task as been mark as 'Complete' then next occurrence should be incomplete.
178	178	if (isset($this->action['complete']) && $this->action['complete'] == 1) {
179	179	$this->action['status'] = $props[$this->proptags["status"]] = olTaskNotStarted;
180	180	$this->action['complete'] = $props[$this->proptags["complete"]] = false;

+1

-2

php-ext/include/mapi/class.taskrequest.php less more

86	86	// All recipient properties
87	87	var $recipprops = Array(PR_ENTRYID, PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_RECIPIENT_ENTRYID, PR_RECIPIENT_TYPE, PR_SEND_INTERNET_ENCODING, PR_SEND_RICH_INFO, PR_RECIPIENT_DISPLAY_NAME, PR_ADDRTYPE, PR_DISPLAY_TYPE, PR_RECIPIENT_TRACKSTATUS, PR_RECIPIENT_TRACKSTATUS_TIME, PR_RECIPIENT_FLAGS, PR_ROWID, PR_SEARCH_KEY);
88	88
89		/* Constructor
90		*
	89	/*
91	90	* Constructs a TaskRequest object for the specified message. This can be either the task request
92	91	* message itself (in the inbox) or the task in the tasks folder, depending on the action to be performed.
93	92	*

+1

-18

php-ext/include/mapi/mapi.util.php less more

36	36	*/
37	37	function makeGuid($guid)
38	38	{
39		// remove the { and } from the string and explode it into an array
40		$guidArray = explode('-', substr($guid, 1,strlen($guid)-2));
41
42		// convert to hex!
43		$data1[0] = intval(substr($guidArray[0], 0, 4),16); // we need to split the unsigned long
44		$data1[1] = intval(substr($guidArray[0], 4, 4),16);
45		$data2 = intval($guidArray[1], 16);
46		$data3 = intval($guidArray[2], 16);
47
48		$data4[0] = intval(substr($guidArray[3], 0, 2),16);
49		$data4[1] = intval(substr($guidArray[3], 2, 2),16);
50
51		for($i=0; $i < 6; $i++)
52		{
53		$data4[] = intval(substr($guidArray[4], $i*2, 2),16);
54		}
55
56		return pack("vvvvCCCCCCCC", $data1[1], $data1[0], $data2, $data3, $data4[0],$data4[1],$data4[2],$data4[3],$data4[4],$data4[5],$data4[6],$data4[7]);
	39	return pack("vvvv", hexdec(substr($guid, 5, 4)), hexdec(substr($guid, 1, 4)), hexdec(substr($guid, 10, 4)), hexdec(substr($guid, 15, 4))) . hex2bin(substr($guid, 20, 4)) . hex2bin(substr($guid, 25, 12));
57	40	}
58	41
59	42	/**

+5

-51

php-ext/main.cpp less more

115	115	#include "php_globals.h"
116	116	#include "php_ini.h"
117	117
118		#if PHP_MAJOR_VERSION >= 5
119		#define SUPPORT_EXCEPTIONS 1
120		#else
121		#define SUPPORT_EXCEPTIONS 0
122		#endif
123
124		#if SUPPORT_EXCEPTIONS
125	118	#include "zend_exceptions.h"
126		#endif
127	119	#include "ext/standard/info.h"
128	120	#include "ext/standard/php_string.h"
129	121	}

143	135	ZEND_END_ARG_INFO()
144	136	#endif
145	137
146
147	138	#define LOG_BEGIN() { \
148	139	if (mapi_debug & 1) { \
149	140	php_error_docref(NULL TSRMLS_CC, E_NOTICE, "[IN] %s", __FUNCTION__); \

198	189	#include "util.h"
199	190	#include "rtfutil.h"
200	191	#include <kopano/CommonUtil.h>
201		#include <kopano/ECLogger.h>
202	192
203	193	#include "ECImportContentsChangesProxy.h"
204	194	#include "ECImportHierarchyChangesProxy.h"

453	443	ZEND_FE(mapi_inetmapi_imtoinet, NULL)
454	444	ZEND_FE(mapi_inetmapi_imtomapi, NULL)
455	445
456		#if SUPPORT_EXCEPTIONS
457	446	ZEND_FE(mapi_enable_exceptions, NULL)
458		#endif
459	447
460	448	ZEND_FE(mapi_feature, NULL)
461	449

524	512
525	513	static int LoadSettingsFile(void)
526	514	{
527		#ifdef LINUX
528	515	const char *const cfg_file = ECConfig::GetDefaultPath("php-mapi.cfg");
529		#else
530		const char *const cfg_file = "php-mapi.cfg";
531		#endif
532
533	516	struct stat st;
534	517	if (stat(cfg_file, &st) == 0) {
535	518	static const configsetting_t settings[] = {

554	537	const char *temp = cfg->GetSetting(CE_PHP_MAPI_PERFORMANCE_TRACE_FILE);
555	538	if (temp != NULL) {
556	539	perf_measure_file = strdup(temp);
557		lpLogger->Log(EC_LOGLEVEL_INFO, "Performance measuring enabled");
	540	lpLogger->Log(EC_LOGLEVEL_INFO, "PHP-MAPI Performance measuring enabled");
558	541	}
559	542
560	543	temp = cfg->GetSetting(CE_PHP_MAPI_DEBUG);

569	552	if (lpLogger == NULL)
570	553	return FAILURE;
571	554
572		lpLogger->Log(EC_LOGLEVEL_INFO, "PHP-Mapi instantiated " PROJECT_VERSION_EXT_STR);
	555	lpLogger->Log(EC_LOGLEVEL_INFO, "PHP-MAPI instantiated " PROJECT_VERSION_EXT_STR);
573	556
574	557	ec_log_set(lpLogger);
575	558	if (mapi_debug)

625	608	}
626	609
627	610	// Used at the end of each MAPI call to throw exceptions if mapi_enable_exceptions() has been called
628		#if SUPPORT_EXCEPTIONS
629	611	#define THROW_ON_ERROR() \
630	612	if (FAILED(MAPI_G(hr))) { \
631	613	if (lpLogger) \

634	616	if (MAPI_G(exceptions_enabled)) \
635	617	zend_throw_exception(MAPI_G(exception_ce), "MAPI error ", MAPI_G(hr) TSRMLS_CC); \
636	618	}
637		#else
638		#define THROW_ON_ERROR() \
639		if (FAILED(MAPI_G(hr)) && lpLogger) \
640		lpLogger->Log(EC_LOGLEVEL_ERROR, "MAPI error: %s (%x) (method: %s, line: %d)", GetMAPIErrorMessage(MAPI_G(hr)), MAPI_G(hr), __FUNCTION__, __LINE__);
641		#endif
642	619
643	620	/**
644	621	*

652	629	perf_measure_file = NULL;
653	630
654	631	if (lpLogger)
655		lpLogger->Log(EC_LOGLEVEL_INFO, "php-mapi shutdown");
	632	lpLogger->Log(EC_LOGLEVEL_INFO, "PHP-MAPI shutdown");
656	633
657	634	MAPIUninitialize();
658	635	lpLogger->Release();

719	696	LPUNKNOWN lpObj = (LPUNKNOWN)rsrc->ptr;
720	697	if (lpObj) lpObj->Release();
721	698	}
722
723	699
724	700	static HRESULT GetECObject(LPMAPIPROP lpMapiProp,
725	701	IECUnknown **lppIECUnknown TSRMLS_DC)

1147	1123	LPADRBOOK lpAddrBook;
1148	1124	// local
1149	1125
1150
1151	1126	RETVAL_FALSE;
1152	1127	MAPI_G(hr) = MAPI_E_INVALID_PARAMETER;
1153	1128

1290	1265	THROW_ON_ERROR();
1291	1266	}
1292	1267
1293
1294	1268	/**
1295	1269	* mapi_getstores
1296	1270	* Gets the table with the messagestores available

1743	1717	THROW_ON_ERROR();
1744	1718	}
1745	1719
1746
1747	1720	ZEND_FUNCTION(mapi_folder_emptyfolder)
1748	1721	{
1749	1722	PMEASURE_FUNC;

1817	1790	LOG_END();
1818	1791	THROW_ON_ERROR();
1819	1792	}
1820
1821	1793
1822	1794	/**
1823	1795	* mapi_msgstore_createentryid

1868	1840	LOG_END();
1869	1841	THROW_ON_ERROR();
1870	1842	}
1871
1872	1843
1873	1844	/**
1874	1845	* mapi_msgstore_getearchiveentryid

1920	1891	THROW_ON_ERROR();
1921	1892	}
1922	1893
1923
1924	1894	/**
1925	1895	* mapi_openentry
1926	1896	* Opens the msgstore to get the root folder.

2259	2229	}
2260	2230	}
2261	2231
2262
2263	2232	MAPI_G(hr) = lpTable->QueryRows(lRowCount, 0, &pRowSet);
2264	2233
2265	2234	if (FAILED(MAPI_G(hr)))

2863	2832	THROW_ON_ERROR();
2864	2833	}
2865	2834
2866
2867	2835	ZEND_FUNCTION(mapi_message_createattach)
2868	2836	{
2869	2837	PMEASURE_FUNC;

3095	3063	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) return;
3096	3064
3097	3065	ZEND_FETCH_RESOURCE_C(pStream, LPSTREAM, &res, -1, name_istream, le_istream);
3098
3099	3066
3100	3067	MAPI_G(hr) = pStream->Stat(&stg,STATFLAG_NONAME);
3101	3068	if(MAPI_G(hr) != hrSuccess)

3340	3307
3341	3308	if(guidArray)
3342	3309	guidHash = Z_ARRVAL_P(guidArray);
3343
3344	3310
3345	3311	// get the number of items in the array
3346	3312	hashTotal = zend_hash_num_elements(targetHash);

3557	3523	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown resource type");
3558	3524	goto exit;
3559	3525	}
3560
3561	3526
3562	3527	MAPI_G(hr) = lpSrcObj->CopyTo(cExcludeIIDs, lpExcludeIIDs, lpExcludeProps, 0, NULL, lpInterface, lpDstObj, flags, NULL);
3563	3528

4324	4289	THROW_ON_ERROR();
4325	4290	}
4326	4291
4327
4328	4292	ZEND_FUNCTION(mapi_zarafa_setuser)
4329	4293	{
4330	4294	PMEASURE_FUNC;

4424	4388
4425	4389	ZEND_FETCH_RESOURCE_C(lpMsgStore, LPMDB, &res, -1, name_mapi_msgstore, le_mapi_msgstore);
4426	4390
4427
4428	4391	MAPI_G(hr) = GetECObject(lpMsgStore, &lpUnknown TSRMLS_CC);
4429	4392	if(MAPI_G(hr) != hrSuccess) {
4430	4393	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Specified object is not a kopano store");

4738	4701	THROW_ON_ERROR();
4739	4702	}
4740	4703
4741
4742	4704	/**
4743	4705	* Retrieve user information
4744	4706	* @param logged on msgstore

5275	5237	if(MAPI_G(hr) != hrSuccess)
5276	5238	goto exit;
5277	5239
5278
5279	5240	array_init(return_value);
5280	5241	for (i = 0; i < ulGroups; ++i) {
5281	5242	MAKE_STD_ZVAL(zval_data_value);

5370	5331	IECUnknown *lpUnknown = NULL;
5371	5332	IECServiceAdmin *lpServiceAdmin = NULL;
5372	5333	ULONG ulUsers;
5373		ECUSER *lpsUsers;
	5334	ECUSER *lpsUsers = NULL;
5374	5335	unsigned int i;
5375	5336
5376	5337	RETVAL_FALSE;

6852	6813	THROW_ON_ERROR();
6853	6814	}
6854	6815
6855
6856	6816	ZEND_FUNCTION(mapi_freebusyenumblock_skip)
6857	6817	{
6858	6818	PMEASURE_FUNC;

6977	6937
6978	6938	zend_hash_move_forward(target_hash);
6979	6939	}
6980
6981	6940
6982	6941	MAPI_G(hr) = lpFBUpdate->PublishFreeBusy(lpBlocks, cBlocks);
6983	6942	if(MAPI_G(hr) != hrSuccess)

7588	7547	THROW_ON_ERROR();
7589	7548	}
7590	7549
7591
7592	7550	ZEND_FUNCTION(mapi_importhierarchychanges_importfolderdeletion)
7593	7551	{
7594	7552	PMEASURE_FUNC;

7624	7582	LOG_END();
7625	7583	THROW_ON_ERROR();
7626	7584	}
7627
7628
7629	7585
7630	7586	/*
7631	7587	* This function needs some explanation as it is not just a one-to-one MAPI function. This function

7794	7750	return;
7795	7751	}
7796	7752
7797		#if SUPPORT_EXCEPTIONS
7798	7753	ZEND_FUNCTION(mapi_enable_exceptions)
7799	7754	{
7800	7755	PMEASURE_FUNC;

7816	7771	LOG_END();
7817	7772	return;
7818	7773	}
7819		#endif
7820	7774
7821	7775	// Can be queried by client applications to check whether certain API features are supported or not.
7822	7776	ZEND_FUNCTION(mapi_feature)

7833	7787	if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &szFeature, &cbFeature) == FAILURE) return;
7834	7788
7835	7789	for (unsigned int i = 0; i < arraySize(features); ++i)
7836		if(stricmp(features[i], szFeature) == 0) {
	7790	if(strcasecmp(features[i], szFeature) == 0) {
7837	7791	RETVAL_TRUE;
7838	7792	break;
7839	7793	}

+0

-2

php-ext/main.h less more

296	296	ZEND_FUNCTION(mapi_inetmapi_imtoinet);
297	297	ZEND_FUNCTION(mapi_inetmapi_imtomapi);
298	298
299		#if SUPPORT_EXCEPTIONS
300	299	ZEND_FUNCTION(mapi_enable_exceptions);
301		#endif
302	300
303	301	ZEND_FUNCTION(mapi_feature);
304	302

+0

-7

php-ext/typeconversion.cpp less more

67	67	PHPTag = (LONG)ulPropTag;
68	68	return PHPTag;
69	69	}
70
71	70
72	71	/*
73	72	* Converts a PHP Array into a SBinaryArray. This is the same as an ENTRYLIST which

292	291	exit:
293	292	return MAPI_G(hr);
294	293	}
295
296	294
297	295	/*
298	296	* Converts an PHP property value array to a MAPI property value structure

460	458	lpPropValue[cvalues].Value.mapimvmember.mapilpmember[j] = dataEntry[0]->value.phpmember; \
461	459	zend_hash_move_forward(dataHash); \
462	460	}
463
464	461
465	462	case PT_MV_I2:
466	463	COPY_MV_PROPS(long, MVi, lpi, lval);

1527	1524	add_assoc_zval(ret, "1", array);
1528	1525	break;
1529	1526
1530
1531	1527	case RES_CONTENT:
1532	1528	MAPI_G(hr) = PropValueArraytoPHPArray(1, lpRes->res.resContent.lpProp, &props TSRMLS_CC);
1533	1529	if (MAPI_G(hr) != hrSuccess)

1713	1709	char pulproptag[16];
1714	1710
1715	1711	pPropValue = &pPropValueArray[col];
1716
1717	1712
1718	1713	/*
1719	1714	* PHP wants a string as array key. PHP will transform this to zval integer when possible.

2001	1996	return MAPI_G(hr);
2002	1997	}
2003	1998
2004
2005	1999	/*
2006	2000	* Convert from READSTATE array to PHP. Returns a list of arrays, each containing "sourcekey" and "flags" per entry
2007	2001	*/

2111	2105	int i = 0;
2112	2106	zval **ppentry = NULL;
2113	2107	zval *pentry = NULL;
2114
2115	2108
2116	2109	MAPI_G(hr) = hrSuccess;
2117	2110

+0

-2

php7-ext/ECImportContentsChangesProxy.cpp less more

38	38	#include "ext/standard/php_string.h"
39	39	}
40	40
41
42
43	41	// A very, very nice PHP #define that causes link errors in MAPI when you have multiple
44	42	// files referencing MAPI....
45	43	#undef inline

+0

-1

php7-ext/ECImportHierarchyChangesProxy.cpp less more

38	38	#include "ext/standard/php_string.h"
39	39	}
40	40
41
42	41	// A very, very nice PHP #define that causes link errors in MAPI when you have multiple
43	42	// files referencing MAPI....
44	43	#undef inline

+0

-6

php7-ext/ECRulesTableProxy.cpp less more

24	24
25	25	#include <mapix.h>
26	26
27
28	27	/* conversion from unicode to string8 for rules table data */
29	28	static HRESULT ConvertUnicodeToString8(LPSRestriction lpRes, void *base, convert_context &converter);
30	29	static HRESULT ConvertUnicodeToString8(const ACTIONS lpActions, void base, convert_context &converter);
31
32	30
33	31	ECRulesTableProxy::ECRulesTableProxy(LPMAPITABLE lpTable)
34	32	: m_lpTable(lpTable)

63	61	exit:
64	62	return hr;
65	63	}
66
67	64
68	65	HRESULT ECRulesTableProxy::QueryInterface(REFIID refiid, void **lppInterface)
69	66	{

230	227	METHOD_PROLOGUE_(ECRulesTableProxy, MAPITable);
231	228	return pThis->Release();
232	229	}
233
234	230
235	231	DEF_HRMETHOD(TRACE_MAPI, ECRulesTableProxy, MAPITable, QueryInterface, (REFIID, refiid), (void **, lppInterface))
236	232	DEF_HRMETHOD(TRACE_MAPI, ECRulesTableProxy, MAPITable, GetLastError, (HRESULT, hResult), (ULONG, ulFlags), (LPMAPIERROR *, lppMAPIError))

257	253	DEF_HRMETHOD(TRACE_MAPI, ECRulesTableProxy, MAPITable, GetCollapseState, (ULONG, ulFlags), (ULONG, cbInstanceKey, LPBYTE, lpbInstanceKey), (ULONG , lpcbCollapseState, LPBYTE , lppbCollapseState))
258	254	DEF_HRMETHOD(TRACE_MAPI, ECRulesTableProxy, MAPITable, SetCollapseState, (ULONG, ulFlags), (ULONG, cbCollapseState, LPBYTE, pbCollapseState), (BOOKMARK *, lpbkLocation))
259	255
260
261
262	256	static HRESULT ConvertUnicodeToString8(const WCHAR lpszW, char *lppszA,
263	257	void *base, convert_context &converter)
264	258	{

+4

-4

php7-ext/Makefile.am less more

7	7	$(PHP_INCLUDES)
8	8	AM_CXXFLAGS = ${ZCXXFLAGS} ${ZPHPCXXFLAGS}
9	9
10		lib_LTLIBRARIES = mapi.la
	10	phplib_LTLIBRARIES = mapi.la
11	11
12		libdir=$(PHP_EXTENSION_DIR)
	12	phplibdir = ${dcprefix}${PHP_EXTENSION_DIR}
13	13
14	14	mapi_la_LDFLAGS = ${AM_LDFLAGS} -module -avoid-version \
15	15	$(PHP_LDFLAGS)

36	36	# If we install our config file into that location, it will only be available
37	37	# to only apache2-mod_php5 and not php-cli, php-fpm, etc.
38	38	#
39		sysconfdir = ${PHP_SYSCONF_DIR}
40		dist_sysconf_DATA = mapi.ini
	39	phpconfdir = ${dcprefix}${PHP_SYSCONF_DIR}
	40	dist_phpconf_DATA = mapi.ini
41	41
42	42	sampleconfdir = ${docdir}/example-config
43	43	sampleconf_DATA = mapi.ini

+0

-1

php7-ext/include/mapi/class.baserecurrence.php less more

55	55	var $tz;
56	56
57	57	/**
58		* Constructor
59	58	* @param resource $store MAPI Message Store Object
60	59	* @param resource $message the MAPI (appointment) message
61	60	* @param array $properties the list of MAPI properties the message has.

+0

-2

php7-ext/include/mapi/class.freebusypublish.php less more

31	31	var $proptags;
32	32
33	33	/**
34		* Constuctor
35		*
36	34	* @param mapi_session $session MAPI Session
37	35	* @param mapi_folder $calendar Calendar to publish
38	36	* @param string $entryid AddressBook Entry ID for the user we're publishing for

+1

-3

php7-ext/include/mapi/class.meetingrequest.php less more

105	105	var $errorSetResource;
106	106
107	107	/**
108		* Constructor
109		*
110	108	* Takes a store and a message. The message is an appointment item
111	109	* that should be converted into a meeting request or an incoming
112	110	* e-mail message that is a meeting request.

841	839
842	840	if ($move) {
843	841	// All we have to do is open the default calendar,
844		// set the mesage class correctly to be an appointment item
	842	// set the message class correctly to be an appointment item
845	843	// and move it to the calendar folder
846	844	$sourcefolder = $this->openParentFolder();
847	845

+0

-1

php7-ext/include/mapi/class.recurrence.php less more

59	59	);
60	60
61	61	/**
62		* Constructor
63	62	* @param resource $store MAPI Message Store Object
64	63	* @param resource $message the MAPI (appointment) message
65	64	*/

+1

-1

php7-ext/include/mapi/class.taskrecurrence.php less more

174	174	$this->action['startdate'] = $props[$this->proptags['startdate']] = $nextOccurrence[$this->proptags['startdate']];
175	175	$this->action['commonstart'] = $props[$this->proptags['commonstart']] = $nextOccurrence[$this->proptags['startdate']];
176	176
177		// If current task as been mark as 'Complete' then next occurrence should be uncomplete.
	177	// If current task as been mark as 'Complete' then next occurrence should be incomplete.
178	178	if (isset($this->action['complete']) && $this->action['complete'] == 1) {
179	179	$this->action['status'] = $props[$this->proptags["status"]] = olTaskNotStarted;
180	180	$this->action['complete'] = $props[$this->proptags["complete"]] = false;

+1

-2

php7-ext/include/mapi/class.taskrequest.php less more

86	86	// All recipient properties
87	87	var $recipprops = Array(PR_ENTRYID, PR_DISPLAY_NAME, PR_EMAIL_ADDRESS, PR_RECIPIENT_ENTRYID, PR_RECIPIENT_TYPE, PR_SEND_INTERNET_ENCODING, PR_SEND_RICH_INFO, PR_RECIPIENT_DISPLAY_NAME, PR_ADDRTYPE, PR_DISPLAY_TYPE, PR_RECIPIENT_TRACKSTATUS, PR_RECIPIENT_TRACKSTATUS_TIME, PR_RECIPIENT_FLAGS, PR_ROWID, PR_SEARCH_KEY);
88	88
89		/* Constructor
90		*
	89	/*
91	90	* Constructs a TaskRequest object for the specified message. This can be either the task request
92	91	* message itself (in the inbox) or the task in the tasks folder, depending on the action to be performed.
93	92	*

+1

-18

php7-ext/include/mapi/mapi.util.php less more

36	36	*/
37	37	function makeGuid($guid)
38	38	{
39		// remove the { and } from the string and explode it into an array
40		$guidArray = explode('-', substr($guid, 1,strlen($guid)-2));
41
42		// convert to hex!
43		$data1[0] = intval(substr($guidArray[0], 0, 4),16); // we need to split the unsigned long
44		$data1[1] = intval(substr($guidArray[0], 4, 4),16);
45		$data2 = intval($guidArray[1], 16);
46		$data3 = intval($guidArray[2], 16);
47
48		$data4[0] = intval(substr($guidArray[3], 0, 2),16);
49		$data4[1] = intval(substr($guidArray[3], 2, 2),16);
50
51		for($i=0; $i < 6; $i++)
52		{
53		$data4[] = intval(substr($guidArray[4], $i*2, 2),16);
54		}
55
56		return pack("vvvvCCCCCCCC", $data1[1], $data1[0], $data2, $data3, $data4[0],$data4[1],$data4[2],$data4[3],$data4[4],$data4[5],$data4[6],$data4[7]);
	39	return pack("vvvv", hexdec(substr($guid, 5, 4)), hexdec(substr($guid, 1, 4)), hexdec(substr($guid, 10, 4)), hexdec(substr($guid, 15, 4))) . hex2bin(substr($guid, 20, 4)) . hex2bin(substr($guid, 25, 12));
57	40	}
58	41
59	42	/**

+15

-54

php7-ext/main.cpp less more

117	117	#include "php_globals.h"
118	118	#include "php_ini.h"
119	119
120		#if PHP_MAJOR_VERSION >= 5
121		#define SUPPORT_EXCEPTIONS 1
122		#else
123		#define SUPPORT_EXCEPTIONS 0
124		#endif
125
126		#if SUPPORT_EXCEPTIONS
127	120	#include "zend_exceptions.h"
128		#endif
129	121	#include "ext/standard/info.h"
130	122	#include "ext/standard/php_string.h"
131	123	}

145	137	ZEND_END_ARG_INFO()
146	138	#endif
147	139
148
149	140	#define LOG_BEGIN() { \
150	141	if (mapi_debug & 1) { \
151	142	php_error_docref(NULL TSRMLS_CC, E_NOTICE, "[IN] %s", __FUNCTION__); \

204	195	#include "util.h"
205	196	#include "rtfutil.h"
206	197	#include <kopano/CommonUtil.h>
207		#include <kopano/ECLogger.h>
208	198
209	199	#include "ECImportContentsChangesProxy.h"
210	200	#include "ECImportHierarchyChangesProxy.h"

459	449	ZEND_FE(mapi_inetmapi_imtoinet, NULL)
460	450	ZEND_FE(mapi_inetmapi_imtomapi, NULL)
461	451
462		#if SUPPORT_EXCEPTIONS
463	452	ZEND_FE(mapi_enable_exceptions, NULL)
464		#endif
465	453
466	454	ZEND_FE(mapi_feature, NULL)
467	455

530	518
531	519	static int LoadSettingsFile(void)
532	520	{
533		#ifdef LINUX
534	521	const char *const cfg_file = ECConfig::GetDefaultPath("php-mapi.cfg");
535		#else
536		const char *const cfg_file = "php-mapi.cfg";
537		#endif
538
539	522	struct stat st;
540	523	if (stat(cfg_file, &st) == 0) {
541	524	static const configsetting_t settings[] = {

575	558	if (lpLogger == NULL)
576	559	return FAILURE;
577	560
578		lpLogger->Log(EC_LOGLEVEL_INFO, "PHP-Mapi instantiated " PROJECT_VERSION_EXT_STR);
	561	lpLogger->Log(EC_LOGLEVEL_INFO, "PHP-MAPI instantiated " PROJECT_VERSION_EXT_STR);
579	562
580	563	ec_log_set(lpLogger);
581	564	if (mapi_debug)

631	614	}
632	615
633	616	// Used at the end of each MAPI call to throw exceptions if mapi_enable_exceptions() has been called
634		#if SUPPORT_EXCEPTIONS
635	617	#define THROW_ON_ERROR() \
636	618	if (FAILED(MAPI_G(hr))) { \
637	619	if (lpLogger) \

640	622	if (MAPI_G(exceptions_enabled)) \
641	623	zend_throw_exception(MAPI_G(exception_ce), "MAPI error ", MAPI_G(hr) TSRMLS_CC); \
642	624	}
643		#else
644		#define THROW_ON_ERROR() \
645		if (FAILED(MAPI_G(hr)) && lpLogger) \
646		lpLogger->Log(EC_LOGLEVEL_ERROR, "MAPI error: %s (%x) (method: %s, line: %d)", GetMAPIErrorMessage(MAPI_G(hr)), MAPI_G(hr), __FUNCTION__, __LINE__);
647		#endif
648	625
649	626	/**
650	627	*

658	635	perf_measure_file = NULL;
659	636
660	637	if (lpLogger)
661		lpLogger->Log(EC_LOGLEVEL_INFO, "php-mapi shutdown");
	638	lpLogger->Log(EC_LOGLEVEL_INFO, "PHP-MAPI shutdown");
662	639
663	640	MAPIUninitialize();
664	641	lpLogger->Release();

725	702	LPUNKNOWN lpObj = (LPUNKNOWN)rsrc->ptr;
726	703	if (lpObj) lpObj->Release();
727	704	}
728
729	705
730	706	static HRESULT GetECObject(LPMAPIPROP lpMapiProp,
731	707	IECUnknown **lppIECUnknown TSRMLS_DC)

1153	1129	LPADRBOOK lpAddrBook;
1154	1130	// local
1155	1131
1156
1157	1132	RETVAL_FALSE;
1158	1133	MAPI_G(hr) = MAPI_E_INVALID_PARAMETER;
1159	1134

1301	1276	THROW_ON_ERROR();
1302	1277	}
1303	1278
1304
1305	1279	/**
1306	1280	* mapi_getstores
1307	1281	* Gets the table with the messagestores available

1754	1728	THROW_ON_ERROR();
1755	1729	}
1756	1730
1757
1758	1731	ZEND_FUNCTION(mapi_folder_emptyfolder)
1759	1732	{
1760	1733	PMEASURE_FUNC;

1828	1801	LOG_END();
1829	1802	THROW_ON_ERROR();
1830	1803	}
1831
1832	1804
1833	1805	/**
1834	1806	* mapi_msgstore_createentryid

1879	1851	LOG_END();
1880	1852	THROW_ON_ERROR();
1881	1853	}
1882
1883	1854
1884	1855	/**
1885	1856	* mapi_msgstore_getearchiveentryid

1931	1902	THROW_ON_ERROR();
1932	1903	}
1933	1904
1934
1935	1905	/**
1936	1906	* mapi_openentry
1937	1907	* Opens the msgstore to get the root folder.

2268	2238	}
2269	2239	}
2270	2240
2271
2272	2241	MAPI_G(hr) = lpTable->QueryRows(lRowCount, 0, &pRowSet);
2273	2242
2274	2243	if (FAILED(MAPI_G(hr)))

2871	2840	THROW_ON_ERROR();
2872	2841	}
2873	2842
2874
2875	2843	ZEND_FUNCTION(mapi_message_createattach)
2876	2844	{
2877	2845	PMEASURE_FUNC;

3103	3071	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &res) == FAILURE) return;
3104	3072
3105	3073	ZEND_FETCH_RESOURCE_C(pStream, LPSTREAM, &res, -1, name_istream, le_istream);
3106
3107	3074
3108	3075	MAPI_G(hr) = pStream->Stat(&stg,STATFLAG_NONAME);
3109	3076	if(MAPI_G(hr) != hrSuccess)

3348	3315
3349	3316	if(guidArray)
3350	3317	guidHash = Z_ARRVAL_P(guidArray);
3351
3352	3318
3353	3319	// get the number of items in the array
3354	3320	hashTotal = zend_hash_num_elements(targetHash);

3565	3531	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown resource type");
3566	3532	goto exit;
3567	3533	}
3568
3569	3534
3570	3535	MAPI_G(hr) = lpSrcObj->CopyTo(cExcludeIIDs, lpExcludeIIDs, lpExcludeProps, 0, NULL, lpInterface, lpDstObj, flags, NULL);
3571	3536

4331	4296	THROW_ON_ERROR();
4332	4297	}
4333	4298
4334
4335	4299	ZEND_FUNCTION(mapi_zarafa_setuser)
4336	4300	{
4337	4301	PMEASURE_FUNC;

4431	4395
4432	4396	ZEND_FETCH_RESOURCE_C(lpMsgStore, LPMDB, &res, -1, name_mapi_msgstore, le_mapi_msgstore);
4433	4397
4434
4435	4398	MAPI_G(hr) = GetECObject(lpMsgStore, &lpUnknown TSRMLS_CC);
4436	4399	if(MAPI_G(hr) != hrSuccess) {
4437	4400	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Specified object is not an zarafa store");

4708	4671	if (MAPI_G(hr) != hrSuccess)
4709	4672	goto exit;
4710	4673
	4674	ZVAL_DEREF(array);
4711	4675	data = HASH_OF(array);
4712	4676	zend_hash_internal_pointer_reset(data);
4713	4677

4754	4718	LOG_END();
4755	4719	THROW_ON_ERROR();
4756	4720	}
4757
4758	4721
4759	4722	/**
4760	4723	* Retrieve user information from zarafa

5292	5255	if(MAPI_G(hr) != hrSuccess)
5293	5256	goto exit;
5294	5257
5295
5296	5258	array_init(return_value);
5297	5259	for (i = 0; i < ulGroups; ++i) {
5298	5260	array_init(&zval_data_value);

5385	5347	IECUnknown *lpUnknown = NULL;
5386	5348	IECServiceAdmin *lpServiceAdmin = NULL;
5387	5349	ULONG ulUsers;
5388		ECUSER *lpsUsers;
	5350	ECUSER *lpsUsers = NULL;
5389	5351	unsigned int i;
5390	5352
5391	5353	RETVAL_FALSE;

6380	6342	goto exit;
6381	6343	}
6382	6344
	6345	ZVAL_DEREF(perms);
6383	6346	target_hash = HASH_OF(perms);
6384	6347	if (!target_hash) {
6385	6348	MAPI_G(hr) = MAPI_E_INVALID_PARAMETER;

6398	6361	j = 0;
6399	6362	ZEND_HASH_FOREACH_VAL(target_hash, entry) {
6400	6363	// null pointer returned if perms was not array(array()).
	6364	ZVAL_DEREF(entry);
6401	6365	data = HASH_OF(entry);
6402	6366	zend_hash_internal_pointer_reset(data);
6403	6367

6552	6516
6553	6517	ZEND_FETCH_RESOURCE_C(lpFBSupport, IFreeBusySupport*, &resFBSupport, -1, name_fb_support, le_freebusy_support);
6554	6518
	6519	ZVAL_DEREF(resUsers);
6555	6520	target_hash = HASH_OF(resUsers);
6556	6521	if (!target_hash) {
6557	6522	MAPI_G(hr) = MAPI_E_INVALID_PARAMETER;

6632	6597
6633	6598	ZEND_FETCH_RESOURCE_C(lpFBSupport, IFreeBusySupport*, &resFBSupport, -1, name_fb_support, le_freebusy_support);
6634	6599
	6600	ZVAL_DEREF(resUsers);
6635	6601	target_hash = HASH_OF(resUsers);
6636	6602	if (!target_hash) {
6637	6603	MAPI_G(hr) = MAPI_E_INVALID_PARAMETER;

6865	6831	THROW_ON_ERROR();
6866	6832	}
6867	6833
6868
6869	6834	ZEND_FUNCTION(mapi_freebusyenumblock_skip)
6870	6835	{
6871	6836	PMEASURE_FUNC;

6952	6917
6953	6918	ZEND_FETCH_RESOURCE_C(lpFBUpdate, IFreeBusyUpdate*, &resFBUpdate, -1, name_fb_update, le_freebusy_update);
6954	6919
	6920	ZVAL_DEREF(aBlocks);
6955	6921	target_hash = HASH_OF(aBlocks);
6956	6922	if (!target_hash) {
6957	6923	MAPI_G(hr) = MAPI_E_INVALID_PARAMETER;
6958	6924	goto exit;
6959	6925	}
6960	6926
	6927	cBlocks = zend_hash_num_elements(target_hash);
6961	6928	MAPI_G(hr) = MAPIAllocateBuffer(sizeof(FBBlock_1)cBlocks, (void*)&lpBlocks);
6962	6929	if(MAPI_G(hr) != hrSuccess)
6963	6930	goto exit;
6964	6931
6965		i = 0;
6966		ZEND_HASH_FOREACH_VAL(target_hash, entry) {
	6932	i = 0;
	6933	ZEND_HASH_FOREACH_VAL(target_hash, entry) {
	6934	ZVAL_DEREF(entry);
6967	6935	data = HASH_OF(entry);
6968	6936	zend_hash_internal_pointer_reset(data);
6969	6937

6989	6957	}
6990	6958	++i;
6991	6959
6992		} ZEND_HASH_FOREACH_END();
6993
6994		cBlocks = zend_hash_num_elements(target_hash);
	6960	} ZEND_HASH_FOREACH_END();
6995	6961	MAPI_G(hr) = lpFBUpdate->PublishFreeBusy(lpBlocks, cBlocks);
6996	6962	if(MAPI_G(hr) != hrSuccess)
6997	6963	goto exit;

7604	7570	THROW_ON_ERROR();
7605	7571	}
7606	7572
7607
7608	7573	ZEND_FUNCTION(mapi_importhierarchychanges_importfolderdeletion)
7609	7574	{
7610	7575	PMEASURE_FUNC;

7640	7605	LOG_END();
7641	7606	THROW_ON_ERROR();
7642	7607	}
7643
7644
7645	7608
7646	7609	/*
7647	7610	* This function needs some explanation as it is not just a one-to-one MAPI function. This function

7810	7773	return;
7811	7774	}
7812	7775
7813		#if SUPPORT_EXCEPTIONS
7814	7776	ZEND_FUNCTION(mapi_enable_exceptions)
7815	7777	{
7816	7778	PMEASURE_FUNC;

7831	7793	LOG_END();
7832	7794	return;
7833	7795	}
7834		#endif
7835	7796
7836	7797	// Can be queried by client applications to check whether certain API features are supported or not.
7837	7798	ZEND_FUNCTION(mapi_feature)

7848	7809	if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &szFeature, &cbFeature) == FAILURE) return;
7849	7810
7850	7811	for (unsigned int i = 0; i < arraySize(features); ++i)
7851		if(stricmp(features[i], szFeature) == 0) {
	7812	if(strcasecmp(features[i], szFeature) == 0) {
7852	7813	RETVAL_TRUE;
7853	7814	break;
7854	7815	}

+0

-2

php7-ext/main.h less more

296	296	ZEND_FUNCTION(mapi_inetmapi_imtoinet);
297	297	ZEND_FUNCTION(mapi_inetmapi_imtomapi);
298	298
299		#if SUPPORT_EXCEPTIONS
300	299	ZEND_FUNCTION(mapi_enable_exceptions);
301		#endif
302	300
303	301	ZEND_FUNCTION(mapi_feature);
304	302

+0

-7

php7-ext/typeconversion.cpp less more

69	69	PHPTag = (LONG)ulPropTag;
70	70	return PHPTag;
71	71	}
72
73	72
74	73	/*
75	74	* Converts a PHP Array into a SBinaryArray. This is the same as an ENTRYLIST which

287	286	exit:
288	287	return MAPI_G(hr);
289	288	}
290
291	289
292	290	/*
293	291	* Converts an PHP property value array to a MAPI property value structure

467	465	lpPropValue[cvalues].Value.mapimvmember.mapilpmember[j] = dataEntry->value.phpmember; \
468	466	zend_hash_move_forward(dataHash); \
469	467	}
470
471	468
472	469	case PT_MV_I2:
473	470	COPY_MV_PROPS(long, MVi, lpi, lval);

1548	1545	add_assoc_zval(ret, "1", &array);
1549	1546	break;
1550	1547
1551
1552	1548	case RES_CONTENT:
1553	1549	MAPI_G(hr) = PropValueArraytoPHPArray(1, lpRes->res.resContent.lpProp, &props TSRMLS_CC);
1554	1550	if (MAPI_G(hr) != hrSuccess)

1716	1712	char pulproptag[16];
1717	1713
1718	1714	pPropValue = &pPropValueArray[col];
1719
1720	1715
1721	1716	/*
1722	1717	* PHP wants a string as array key. PHP will transform this to zval integer when possible.

1986	1981	return MAPI_G(hr);
1987	1982	}
1988	1983
1989
1990	1984	/*
1991	1985	* Convert from READSTATE array to PHP. Returns a list of arrays, each containing "sourcekey" and "flags" per entry
1992	1986	*/

2093	2087	int n = 0;
2094	2088	int i = 0;
2095	2089	zval *pentry = NULL;
2096
2097	2090
2098	2091	MAPI_G(hr) = hrSuccess;
2099	2092

+5

-0

po/Makefile.am less more

10	10	mkdir -p $$sub; \
11	11	msgfmt -f -v -o $$sub/kopano.mo ${top_srcdir}/po/$$po; \
12	12	done
	13
	14	uninstall-local:
	15	for po in ${EXTRA_DIST}; do \
	16	rm -f "${DESTDIR}${datadir}/$${po%.po}/LC_MESSAGES/kopano.mo"; \
	17	done

+314

-1

provider/Makefile.am less more

0		SUBDIRS = include soap common libserver server client plugins contacts
	0	# -- Makefile --
	1
	2	SUBDIRS = include
	3
	4	AM_CPPFLAGS = ${ZCPPFLAGS} ${DEBUGFLAGS} \
	5	-DLDAP_THREAD_SAFE -DWITH_MULTISERVER -DPKGLIBDIR='"${pkglibdir}"' \
	6	-Isoap \
	7	-I${top_srcdir}/common \
	8	-I${top_srcdir}/libfreebusy \
	9	-I${top_srcdir}/libsync \
	10	-I${top_srcdir}/m4lcommon \
	11	-I${top_srcdir}/mapi4linux/include \
	12	-I${top_srcdir}/provider/client \
	13	-I${top_srcdir}/provider/common \
	14	-I${top_srcdir}/provider/include \
	15	-I${top_srcdir}/provider/libserver \
	16	-I${top_srcdir}/provider/plugins \
	17	${BOOST_CPPFLAGS} ${GSOAP_CFLAGS} ${KRB5_CFLAGS} ${LDAP_FLAGS} \
	18	${MYSQL_INCLUDES} ${SSL_CFLAGS} ${s3_CFLAGS} ${TCMALLOC_CFLAGS}
	19	AM_CXXFLAGS = ${ZCXXFLAGS} -Wno-sign-compare
	20
	21	sbin_PROGRAMS = kopano-server
	22	noinst_LTLIBRARIES = libkccommon.la
	23	lib_LTLIBRARIES = libkcsoapclient.la libkcsoapserver.la libkcserver.la
	24	pkglib_LTLIBRARIES = libkcclient.la libkccontacts.la
	25	pkginclude_HEADERS = \
	26	common/include/kopano/pcuser.hpp \
	27	libserver/include/kopano/ECPluginSharedData.h
	28	noinst_DATA = kopano-server.ldx libkcclient.ldd libkccontacts.ldd
	29	CLEANFILES = ${noinst_DATA}
	30	#noinst_DATA += libkccommon.ldd libkcserver.ldd \
	31	# libkcsoapclient.ldd libkcsoapserver.ldd
	32	sysconf_configdir = ${MAPICONFIGDIR}
	33	dist_sysconf_config_DATA = client/kopano.inf contacts/zcontacts.inf
	34
	35	sampleconfdir = ${docdir}/example-config
	36	sampleconf_DATA = client/kopano.inf contacts/zcontacts.inf
	37
	38	# -E (-rdynamic) still needed because libkcserver.so references
	39	# "searchfolder_restart_required", "_Z23kopano_get_server_statsPjPdS_S_"
	40	# and "_Z18kopano_notify_doneP4soap"
	41	#
	42	kopano_server_LDFLAGS = ${AM_LDFLAGS} -Wl,-E ${BOOST_FILESYSTEM_LDFLAGS}
	43	kopano_server_LDADD = \
	44	libkcserver.la ${GSOAP_LIBS} libkcsoapserver.la libkccommon.la \
	45	${top_builddir}/common/libkcutil.la \
	46	${top_builddir}/common/libkcmapi.la \
	47	${top_builddir}/common/libkcssl.la \
	48	${PROG_LIBS} ${BOOST_FILESYSTEM_LIBS} ${BOOST_SYSTEM_LIBS} \
	49	${icu_uc_LIBS} ${icu_i18n_LIBS} ${DL_LIBS} \
	50	${MYSQL_LIBS} ${SSL_LIBS} ${PAM_LIBS} ${KRB5_LIBS} -lrt
	51	kopano_server_SOURCES = \
	52	server/ECServer.cpp \
	53	server/ECSoapServerConnection.cpp server/ECSoapServerConnection.h \
	54	server/ECClientUpdate.cpp server/ECClientUpdate.h \
	55	server/ECThreadManager.cpp server/ECThreadManager.h
	56
	57	libkcclient_la_SOURCES = \
	58	client/ClientUtil.cpp client/ClientUtil.h \
	59	client/DLLGlobal.h \
	60	client/ECABContainer.cpp client/ECABContainer.h \
	61	client/ECABLogon.cpp client/ECABLogon.h \
	62	client/ECABProp.cpp client/ECABProp.h \
	63	client/ECABProvider.cpp client/ECABProvider.h \
	64	client/ECABProviderOffline.cpp client/ECABProviderOffline.h \
	65	client/ECABProviderSwitch.cpp client/ECABProviderSwitch.h \
	66	client/ECArchiveAwareAttach.cpp client/ECArchiveAwareAttach.h \
	67	client/ECArchiveAwareMessage.cpp client/ECArchiveAwareMessage.h \
	68	client/ECArchiveAwareMsgStore.cpp client/ECArchiveAwareMsgStore.h \
	69	client/ECAttach.cpp client/ECAttach.h \
	70	client/ECChangeAdvisor.cpp client/ECChangeAdvisor.h \
	71	client/ECDisplayTable.cpp client/ECDisplayTable.h \
	72	client/ECDistList.cpp client/ECDistList.h \
	73	client/ECExchangeExportChanges.cpp client/ECExchangeExportChanges.h \
	74	client/ECExchangeImportContentsChanges.cpp \
	75	client/ECExchangeImportContentsChanges.h \
	76	client/ECExchangeImportHierarchyChanges.cpp \
	77	client/ECExchangeImportHierarchyChanges.h \
	78	client/ECExchangeModifyTable.cpp client/ECExchangeModifyTable.h \
	79	client/ECExportAddressbookChanges.cpp \
	80	client/ECExportAddressbookChanges.h \
	81	client/ECGenericProp.cpp client/ECGenericProp.h \
	82	client/ECICS.h \
	83	client/ECMAPIContainer.cpp client/ECMAPIContainer.h \
	84	client/ECMAPIFolder.cpp client/ECMAPIFolder.h \
	85	client/ECMAPIFolderPublic.cpp client/ECMAPIFolderPublic.h \
	86	client/ECMAPIProp.cpp client/ECMAPIProp.h \
	87	client/ECMAPITable.cpp client/ECMAPITable.h \
	88	client/ECMSProvider.cpp client/ECMSProvider.h \
	89	client/ECMSProviderOffline.cpp client/ECMSProviderOffline.h \
	90	client/ECMSProviderSwitch.cpp client/ECMSProviderSwitch.h \
	91	client/ECMailUser.cpp client/ECMailUser.h \
	92	client/ECMemTablePublic.cpp client/ECMemTablePublic.h \
	93	client/ECMessage.cpp client/ECMessage.h \
	94	client/ECMessageStreamImporterIStreamAdapter.cpp \
	95	client/ECMessageStreamImporterIStreamAdapter.h \
	96	client/ECMsgStore.cpp client/ECMsgStore.h \
	97	client/ECMsgStorePublic.cpp client/ECMsgStorePublic.h \
	98	client/ECNamedProp.cpp client/ECNamedProp.h \
	99	client/ECNotifyClient.cpp client/ECNotifyClient.h \
	100	client/ECNotifyMaster.cpp client/ECNotifyMaster.h \
	101	client/ECParentStorage.cpp client/ECParentStorage.h \
	102	client/ECPropertyEntry.cpp client/ECPropertyEntry.h \
	103	client/ECSessionGroupManager.cpp client/ECSessionGroupManager.h \
	104	client/ECXPLogon.cpp client/ECXPLogon.h \
	105	client/ECXPProvider.cpp client/ECXPProvider.h \
	106	client/EntryPoint.h \
	107	client/IECPropStorage.h \
	108	client/Mem.cpp client/Mem.h \
	109	client/ProviderUtil.cpp client/ProviderUtil.h \
	110	client/SessionGroupData.cpp client/SessionGroupData.h \
	111	client/WSABPropStorage.cpp client/WSABPropStorage.h \
	112	client/WSABTableView.cpp client/WSABTableView.h \
	113	client/WSMAPIFolderOps.cpp client/WSMAPIFolderOps.h \
	114	client/WSMAPIPropStorage.cpp client/WSMAPIPropStorage.h \
	115	client/WSMessageStreamExporter.cpp client/WSMessageStreamExporter.h \
	116	client/WSMessageStreamImporter.cpp client/WSMessageStreamImporter.h \
	117	client/WSSerializedMessage.cpp client/WSSerializedMessage.h \
	118	client/WSStoreTableView.cpp client/WSStoreTableView.h \
	119	client/WSTableView.cpp client/WSTableView.h \
	120	client/WSTransport.cpp client/WSTransport.h \
	121	client/WSUtil.cpp client/WSUtil.h \
	122	client/epclient.cpp \
	123	client/resource.h
	124	libkcclient_la_LDFLAGS = ${AM_LDFLAGS} -avoid-version -module
	125	libkcclient_la_LIBADD = \
	126	${top_builddir}/common/libkcmapi.la \
	127	${top_builddir}/common/libkcssl.la \
	128	${top_builddir}/common/libkcutil.la \
	129	${top_builddir}/libfreebusy/libkcfreebusy.la \
	130	${top_builddir}/libsync/libkcsync.la \
	131	${top_builddir}/mapi4linux/src/libmapi.la \
	132	libkccommon.la libkcsoapclient.la -lstdc++ \
	133	${GSOAP_LIBS} ${ICU_LIBS} ${SSL_LIBS} ${UUID_LIBS}
	134
	135	libkccommon_la_SOURCES = \
	136	common/ECLicenseClient.h common/ECLicenseClient.cpp \
	137	common/ECSearchClient.h common/ECSearchClient.cpp \
	138	common/SOAPAlloc.h common/SOAPDebug.cpp common/SOAPDebug.h \
	139	common/SOAPHelpers.cpp common/SOAPHelpers.h \
	140	common/SOAPSock.cpp common/SOAPSock.h \
	141	common/SOAPUtils.cpp common/SOAPUtils.h \
	142	common/pcuser.cpp common/pcutil.cpp common/pcutil.hpp \
	143	common/soapctor.cpp common/versions.h
	144	libkccommon_la_LIBADD = \
	145	../common/libkcutil.la ../common/libkcmapi.la libkcsoapclient.la \
	146	../common/libkcssl.la ${GSOAP_LIBS} ${SSL_LIBS}
	147	libkccommon_la_LDFLAGS = ${AM_LDFLAGS} \
	148	-Wl,--version-script=${top_builddir}/default.sym
	149	EXTRA_libkccommon_la_DEPENDENCIES = ${top_builddir}/default.sym
	150
	151	libkccontacts_la_SOURCES = \
	152	contacts/epcontact.cpp contacts/ZCABData.h \
	153	contacts/ZCABContainer.h contacts/ZCABContainer.cpp \
	154	contacts/ZCABLogon.h contacts/ZCABLogon.cpp \
	155	contacts/ZCABProvider.h contacts/ZCABProvider.cpp \
	156	contacts/ZCMAPIProp.h contacts/ZCMAPIProp.cpp
	157	libkccontacts_la_LDFLAGS = ${AM_LDFLAGS} -avoid-version -module
	158	libkccontacts_la_LIBADD = \
	159	${top_builddir}/common/libkcutil.la \
	160	${top_builddir}/common/libkcmapi.la \
	161	${top_builddir}/mapi4linux/src/libmapi.la \
	162	-lstdc++ $(UUID_LIBS) $(ICU_LIBS)
	163
	164	libkcserver_la_SOURCES = \
	165	libserver/ECABObjectTable.cpp libserver/ECABObjectTable.h \
	166	libserver/ECAttachmentStorage.cpp libserver/ECAttachmentStorage.h \
	167	libserver/ECCacheManager.cpp libserver/ECCacheManager.h \
	168	libserver/ECConvenientDepthABObjectTable.cpp \
	169	libserver/ECConvenientDepthABObjectTable.h \
	170	libserver/ECConvenientDepthObjectTable.cpp \
	171	libserver/ECConvenientDepthObjectTable.h \
	172	libserver/ECConversion.cpp libserver/ECConversion.h \
	173	libserver/ECDBDef.h \
	174	libserver/ECDatabase.h \
	175	libserver/ECDatabaseFactory.cpp libserver/ECDatabaseFactory.h \
	176	libserver/ECDatabaseMySQL.cpp libserver/ECDatabaseMySQL.h \
	177	libserver/ECDatabaseUpdate.cpp libserver/ECDatabaseUpdate.h \
	178	libserver/ECDatabaseUtils.cpp libserver/ECDatabaseUtils.h \
	179	libserver/ECGenProps.cpp libserver/ECGenProps.h \
	180	libserver/ECGenericObjectTable.cpp \
	181	libserver/ECGenericObjectTable.h \
	182	libserver/ECICS.cpp libserver/ECICS.h \
	183	libserver/ECICSHelpers.cpp libserver/ECICSHelpers.h \
	184	libserver/ECIndexer.cpp libserver/ECIndexer.h \
	185	libserver/ECKrbAuth.cpp libserver/ECKrbAuth.h \
	186	libserver/ECLockManager.cpp libserver/ECLockManager.h \
	187	libserver/ECMAPI.h \
	188	libserver/ECMailBoxTable.cpp libserver/ECMailBoxTable.h \
	189	libserver/ECMultiStoreTable.cpp libserver/ECMultiStoreTable.h \
	190	libserver/ECNotification.cpp libserver/ECNotification.h \
	191	libserver/ECNotificationManager.cpp libserver/ECNotificationManager.h \
	192	libserver/ECPamAuth.cpp libserver/ECPamAuth.h \
	193	libserver/ECPluginFactory.cpp libserver/ECPluginFactory.h \
	194	libserver/ECPluginSharedData.cpp \
	195	libserver/ECS3Attachment.cpp libserver/ECS3Attachment.h \
	196	libserver/ECSearchFolders.cpp libserver/ECSearchFolders.h \
	197	libserver/ECSearchObjectTable.cpp libserver/ECSearchObjectTable.h \
	198	libserver/ECSecurity.cpp libserver/ECSecurity.h \
	199	libserver/ECSecurityOffline.cpp libserver/ECSecurityOffline.h \
	200	libserver/ECServerEntrypoint.cpp libserver/ECServerEntrypoint.h \
	201	libserver/ECSession.cpp libserver/ECSession.h \
	202	libserver/ECSessionGroup.cpp libserver/ECSessionGroup.h \
	203	libserver/ECSessionManager.cpp libserver/ECSessionManager.h \
	204	libserver/ECSessionManagerOffline.cpp \
	205	libserver/ECSessionManagerOffline.h \
	206	libserver/ECStatsCollector.cpp libserver/ECStatsCollector.h \
	207	libserver/ECStatsTables.cpp libserver/ECStatsTables.h \
	208	libserver/ECStoreObjectTable.cpp libserver/ECStoreObjectTable.h \
	209	libserver/ECStringCompat.cpp libserver/ECStringCompat.h \
	210	libserver/ECSubRestriction.cpp libserver/ECSubRestriction.h \
	211	libserver/ECTPropsPurge.cpp libserver/ECTPropsPurge.h \
	212	libserver/ECTableManager.cpp libserver/ECTableManager.h \
	213	libserver/ECTestProtocol.cpp libserver/ECTestProtocol.h \
	214	libserver/ECUserManagement.cpp libserver/ECUserManagement.h \
	215	libserver/ECUserManagementOffline.cpp \
	216	libserver/ECUserManagementOffline.h \
	217	libserver/ECUserStoreTable.cpp libserver/ECUserStoreTable.h \
	218	libserver/StorageUtil.cpp libserver/StorageUtil.h \
	219	libserver/StreamUtil.cpp libserver/StreamUtil.h \
	220	libserver/cmd.cpp libserver/cmd.hpp \
	221	libserver/cmdutil.cpp libserver/cmdutil.hpp \
	222	libserver/logontime.cpp libserver/logontime.hpp
	223	libkcserver_la_LIBADD = \
	224	../common/libkcutil.la libkccommon.la \
	225	-lpthread ${icu_i18n_LIBS} ${icu_uc_LIBS} \
	226	${KRB5_LIBS} ${MYSQL_LIBS} ${PAM_LIBS} ${SSL_LIBS}
	227	libkcserver_la_LDFLAGS = ${AM_LDFLAGS} \
	228	-Wl,--version-script=${top_builddir}/default.sym
	229	EXTRA_libkcserver_la_DEPENDENCIES = ${top_builddir}/default.sym
	230
	231	nodist_libkcsoapclient_la_SOURCES = soap/soapC.cpp soap/soapClient.cpp
	232	libkcsoapclient_la_LIBADD = ${GSOAP_LIBS}
	233	libkcsoapclient_la_LDFLAGS = ${AM_LDFLAGS} \
	234	-Wl,--version-script=${top_builddir}/default.sym
	235	EXTRA_libkcsoapclient_la_DEPENDENCIES = ${top_builddir}/default.sym
	236
	237	nodist_libkcsoapserver_la_SOURCES = soap/soapC.cpp soap/soapServer.cpp
	238	libkcsoapserver_la_LIBADD = ${GSOAP_LIBS}
	239	libkcsoapserver_la_LDFLAGS = ${AM_LDFLAGS} \
	240	-Wl,--version-script=${top_builddir}/default.sym
	241	EXTRA_libkcsoapserver_la_DEPENDENCIES = ${top_builddir}/default.sym
	242
	243	SOAPHEADER = include/proto.h
	244	SOAP_NS = soap/KCmd.nsmap soap/KCmd.wsdl
	245	SOAP_H_FILES = soap/soapH.h soap/soapStub.h
	246	SOAP_CPP_CLIENT = soap/soapClient.cpp soap/soapC.cpp
	247	SOAP_LIB_FILES = soap/soapClientLib.cpp soap/soapServerLib.cpp \
	248	soap/soapKCmdObject.h
	249	SOAP_CPP_SRC = ${SOAP_CPP_CLIENT} soap/soapServer.cpp ${SOAP_H_FILES} \
	250	${SOAP_NS} ${SOAP_LIB_FILES}
	251
	252	${SOAP_CPP_SRC}: soap/ns.xsd
	253	soap/ns.xsd: ${SOAPHEADER}
	254	${MKDIR_P} soap
	255	soapcpp2 -z1 -x -Iinclude/ -d soap/ $<
	256
	257	BUILT_SOURCES = soap/ns.xsd ${SOAP_CPP_SRC}
	258	CLEANFILES += ${SOAP_CPP_SRC} soap/.req.xml soap/.res.xml soap/*.wsdl \
	259	soap/.nsmap soap/.xsd soap/Proxy\.h soap/~
	260
	261	COMMON_PLUGIN_FILES = plugins/plugin.h
	262	COMMON_DBPLUGIN_FILES = plugins/DBBase.h plugins/DBBase.cpp
	263
	264	# default plugin
	265	pkglib_LTLIBRARIES += dbplugin.la
	266	#noinst_DATA += dbplugin.ldd
	267	dbplugin_la_SOURCES = \
	268	plugins/DBUserPlugin.cpp plugins/DBUserPlugin.h \
	269	${COMMON_PLUGIN_FILES} ${COMMON_DBPLUGIN_FILES}
	270	dbplugin_la_LDFLAGS = -module -avoid-version
	271	dbplugin_la_LIBADD = \
	272	${top_builddir}/common/libkcutil.la \
	273	libkcserver.la ${MYSQL_LIBS}
	274
	275	if WITH_UNIX
	276	pkglib_LTLIBRARIES += unixplugin.la
	277	#noinst_DATA += unixplugin.ldd
	278	unixplugin_la_SOURCES = \
	279	plugins/UnixUserPlugin.cpp plugins/UnixUserPlugin.h \
	280	${COMMON_PLUGIN_FILES} ${COMMON_DBPLUGIN_FILES}
	281	unixplugin_la_LDFLAGS = ${AM_LDFLAGS} -module -avoid-version
	282	unixplugin_la_LIBADD = \
	283	${top_builddir}/common/libkcutil.la \
	284	libkcserver.la ${MYSQL_LIBS} ${CRYPT_LIBS}
	285	endif
	286
	287	if WITH_LDAP
	288	pkglib_LTLIBRARIES += ldapplugin.la
	289	#noinst_DATA += ldapplugin.ldd
	290	noinst_DATA += .libs/ldapmsplugin.so
	291	ldapplugin_la_SOURCES = \
	292	plugins/LDAPUserPlugin.cpp plugins/LDAPUserPlugin.h \
	293	plugins/LDAPCache.cpp plugins/LDAPCache.h \
	294	plugins/ldappasswords.cpp plugins/ldappasswords.h \
	295	${COMMON_PLUGIN_FILES}
	296	ldapplugin_la_LDFLAGS = ${AM_LDFLAGS} -module -avoid-version
	297	ldapplugin_la_LIBADD = \
	298	${top_builddir}/common/libkcutil.la \
	299	libkcserver.la ${CRYPTO_LIBS} ${LDAP_LIBS}
	300
	301	.libs/ldapmsplugin.so: ldapplugin.la
	302	${AM_V_GEN}ln -fs ldapplugin.so .libs/ldapmsplugin.so
	303
	304	install-exec-local:
	305	${MKDIR_P} ${DESTDIR}${pkglibdir}
	306	ln -fs ldapplugin.so ${DESTDIR}${pkglibdir}/ldapmsplugin.so
	307	endif
	308
	309	check-syntax:
	310	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \
	311	-fsyntax-only -fmessage-length=0 ${CHK_SOURCES} -Wall -Wformat=2
	312
	313	include ../global.am

+4

-16

provider/client/ClientUtil.cpp less more

42	42	#include <boost/algorithm/string/case_conv.hpp>
43	43
44	44	using namespace std;
45
46		#ifdef _DEBUG
47		#define new DEBUG_NEW
48		#endif
49	45
50	46	HRESULT ClientUtil::HrInitializeStatusRow (const char * lpszProviderDisplay, ULONG ulResourceType, LPMAPISUP lpMAPISup, LPSPropValue lpspvIdentity, ULONG ulFlags)
51	47	{

287	283	PR_INTERNET_MESSAGE_ID, PR_DELIVER_TIME, PR_SENT_REPRESENTING_ADDRTYPE, PR_SENT_REPRESENTING_EMAIL_ADDRESS,
288	284	PR_MDN_DISPOSITION_TYPE, PR_MDN_DISPOSITION_SENDINGMODE } };
289	285
290
291	286	// Check incoming parameters
292	287	if(lpReadMessage == NULL \|\| lppEmptyMessage == NULL \|\| *lppEmptyMessage == NULL) {
293	288	hr = MAPI_E_INVALID_OBJECT;

322	317	goto exit;
323	318	}
324	319
325
326	320	strBodyText = _("Your message");
327	321	strBodyText+= _T("\r\n\r\n");
328	322

365	359	strBodyText+= _T("\r\n");
366	360	}
367	361
368
369	362	strBodyText+= _T("\r\n");
370	363	strBodyText+= lpReportText;
371	364	strBodyText+= _T(" ");

379	372
380	373	strBodyText+= convert_to<tstring>(szTime, strlen(szTime), CHARSET_CHAR);
381	374	strBodyText+= _T("\r\n");
382
383	375
384	376	ulMaxDestValues = cSrcValues + 4;//+ default properties
385	377	hr = MAPIAllocateBuffer(sizeof(SPropValue)ulMaxDestValues, (void*)&lpDestPropValue);

705	697	goto exit;
706	698	}
707	699
708
709	700	if((lpProp = PpropFindProp(lpsPropArray, cValues, PR_EC_PATH)) != NULL)
710	701	lpsProfileProps->strServerPath = lpProp->Value.lpszA;
711	702

826	817	* Read registry key to discover the installation directory for the exchange redirector
827	818	*
828	819	* @param[out] lpConfigPath String containing full config path
829		* @return HRESULT Result
830	820	*/
831	821	HRESULT ClientUtil::GetConfigPath(std::string *lpConfigPath)
832	822	{

843	833	* @param pValues[in] Incoming exchange properties (must contain PR_PROFILE_UNRESOLVED_{USER,SERVER})
844	834	* @param lpcValues[out] Number of properties in lppProps
845	835	* @param lppProps[out] New ZARAFA properties
846		* @return HRESULT Success result
847	836	*/
848	837	HRESULT ClientUtil::ConvertMSEMSProps(ULONG cValues, LPSPropValue pValues, ULONG lpcValues, LPSPropValue lppProps)
849	838	{

1053	1042
1054	1043	if (ulSize >= ulMaxSize)
1055	1044	return MAPI_E_NOT_FOUND;
1056		if (strnicmp(lpTmpServerName, "pseudo://", 9) == 0)
	1045	if (strncasecmp(lpTmpServerName, "pseudo://", 9) == 0)
1057	1046	bIsPseudoUrl = true;
1058		else if (strnicmp(lpTmpServerName, "http://", 7) &&
1059		strnicmp(lpTmpServerName, "https://", 8) &&
1060		strnicmp(lpTmpServerName, "file://", 7))
	1047	else if (strncasecmp(lpTmpServerName, "http://", 7) &&
	1048	strncasecmp(lpTmpServerName, "https://", 8) &&
	1049	strncasecmp(lpTmpServerName, "file://", 7))
1061	1050	return MAPI_E_NOT_FOUND;
1062	1051
1063	1052	rServerPath = lpTmpServerName;

1144	1133	return MAPI_E_INVALID_PARAMETER;
1145	1134	}
1146	1135
1147
1148	1136	if (lpcbEntryID == NULL \|\| lppEntryID == NULL)
1149	1137	return MAPI_E_INVALID_PARAMETER;
1150	1138

+0

-7

provider/client/ECABContainer.cpp less more

23	23	#include <kopano/ECGuid.h>
24	24	#include <kopano/ECDebug.h>
25	25
26
27		#include "ECMAPITable.h"
28
29	26	#include "ECDisplayTable.h"
30	27
31	28	#include <kopano/CommonUtil.h>

39	36
40	37	#include <kopano/charset/convstring.h>
41	38	#include <kopano/ECGetText.h>
42
43		#ifdef _DEBUG
44		#define new DEBUG_NEW
45		#endif
46	39
47	40	ECABContainer::ECABContainer(void *lpProvider, ULONG ulObjType, BOOL fModify,
48	41	const char *szClassName) :

+0

-6

provider/client/ECABLogon.cpp less more

32	32	#include <kopano/stringutil.h>
33	33	#include "pcutil.hpp"
34	34
35		#ifdef _DEBUG
36		#define new DEBUG_NEW
37		#endif
38
39	35	ECABLogon::ECABLogon(LPMAPISUP lpMAPISup, WSTransport* lpTransport, ULONG ulProfileFlags, GUID *lpGUID) : ECUnknown("IABLogon")
40	36	{
41	37	// The 'legacy' guid used normally (all AB entryIDs have this GUID)

414	410	if(lpPropVal == NULL)
415	411	lpPropVal = &lpPropArray[j];
416	412
417
418	413	hr = Util::HrCopyProperty(lpNewPropArray + j, lpPropVal, lpNewPropArray);
419	414	if(hr != hrSuccess)
420	415	goto exit;

462	457	return hr;
463	458	}
464	459
465
466	460	HRESULT ECABLogon::xABLogon::QueryInterface(REFIID refiid, void ** lppInterface)
467	461	{
468	462	TRACE_MAPI(TRACE_ENTRY, "IABLogon::QueryInterface", "%s", DBGGUIDToString(refiid).c_str());

+0

-5

provider/client/ECABProp.cpp less more

23	23	#include <kopano/ECDefs.h>
24	24	#include <kopano/CommonUtil.h>
25	25	#include <kopano/ECDebug.h>
26
27
28		#ifdef _DEBUG
29		#define new DEBUG_NEW
30		#endif
31	26
32	27	ECABProp::ECABProp(void *lpProvider, ULONG ulObjType, BOOL fModify,
33	28	const char *szClassName) :

+0

-7

provider/client/ECABProvider.cpp less more

25	25
26	26	#include <kopano/ECDebug.h>
27	27
28
29	28	#include <kopano/Util.h>
30	29
31	30	#include "WSTransport.h"

39	38	#include <kopano/ECGetText.h>
40	39
41	40	using namespace std;
42
43		#ifdef _DEBUG
44		#define new DEBUG_NEW
45		#endif
46	41
47	42	ECABProvider::ECABProvider(ULONG ulFlags, const char *szClassName) :
48	43	ECUnknown(szClassName)

125	120	if(hr != hrSuccess)
126	121	goto exit;
127	122
128
129	123	if (lpulcbSecurity)
130	124	*lpulcbSecurity = 0;
131	125

153	147
154	148	return hr;
155	149	}
156
157	150
158	151	HRESULT __stdcall ECABProvider::xABProvider::QueryInterface(REFIID refiid, void ** lppInterface)
159	152	{

+0

-6

provider/client/ECABProviderOffline.cpp less more

20	20	#include <mapiutil.h>
21	21	#include <mapispi.h>
22	22
23
24	23	#include <kopano/ECGuid.h>
25	24	#include <edkguid.h>
26	25

30	29	#include <kopano/ECTags.h>
31	30
32	31	#include "ECABProviderOffline.h"
33
34		#ifdef _DEBUG
35		#define new DEBUG_NEW
36		#endif
37
38	32
39	33	ECABProviderOffline::ECABProviderOffline(void) : ECABProvider(EC_PROVIDER_OFFLINE, "ECABProviderOffline")
40	34	{

+0

-4

provider/client/ECABProviderSwitch.cpp less more

37	37	#include "ProviderUtil.h"
38	38
39	39	#include <kopano/charset/convstring.h>
40
41		#ifdef _DEBUG
42		#define new DEBUG_NEW
43		#endif
44	40
45	41	ECABProviderSwitch::ECABProviderSwitch(void) : ECUnknown("ECABProviderSwitch")
46	42	{

+0

-3

provider/client/ECArchiveAwareAttach.cpp less more

18	18	#include "ECArchiveAwareAttach.h"
19	19	#include "ECArchiveAwareMessage.h"
20	20
21
22	21	HRESULT ECArchiveAwareAttachFactory::Create(ECMsgStore lpMsgStore, ULONG ulObjType, BOOL fModify, ULONG ulAttachNum, ECMAPIProp lpRoot, ECAttach **lppAttach) const
23	22	{
24	23	return ECArchiveAwareAttach::Create(lpMsgStore, ulObjType, fModify, ulAttachNum, lpRoot, lppAttach);
25	24	}
26
27
28	25
29	26	ECArchiveAwareAttach::ECArchiveAwareAttach(ECMsgStore lpMsgStore, ULONG ulObjType, BOOL fModify, ULONG ulAttachNum, ECMAPIProp lpRoot)
30	27	: ECAttach(lpMsgStore, ulObjType, fModify, ulAttachNum, lpRoot)

+0

-5

provider/client/ECArchiveAwareMessage.cpp less more

32	32	#include <sstream>
33	33	#include <kopano/ECDebug.h>
34	34	#include <kopano/charset/convert.h>
35		#ifdef _DEBUG
36		#define new DEBUG_NEW
37		#endif
38	35
39	36	#define dispidStoreEntryIds "store-entryids"
40	37	#define dispidItemEntryIds "item-entryids"

50	47	ULONG m_ulPropTag;
51	48	};
52	49
53
54	50	HRESULT ECArchiveAwareMessageFactory::Create(ECMsgStore lpMsgStore, BOOL fNew, BOOL fModify, ULONG ulFlags, BOOL bEmbedded, ECMAPIProp lpRoot, ECMessage **lppMessage) const
55	51	{
56	52	ECArchiveAwareMsgStore lpArchiveAwareStore = dynamic_cast<ECArchiveAwareMsgStore>(lpMsgStore);

62	58
63	59	return ECArchiveAwareMessage::Create(lpArchiveAwareStore, FALSE, fModify, ulFlags, lppMessage);
64	60	}
65
66	61
67	62	ECArchiveAwareMessage::ECArchiveAwareMessage(ECArchiveAwareMsgStore *lpMsgStore, BOOL fNew, BOOL fModify, ULONG ulFlags)
68	63	: ECMessage(lpMsgStore, fNew, fModify, ulFlags, FALSE, NULL)

+0

-2

provider/client/ECArchiveAwareMessage.h less more

31	31	class ECArchiveAwareMessage _kc_final : public ECMessage {
32	32	protected:
33	33	/**
34		* \brief Constructor
35		*
36	34	* \param lpMsgStore The store owning this message.
37	35	* \param fNew Specifies whether the message is a new message.
38	36	* \param fModify Specifies whether the message is writable.

+0

-7

provider/client/ECAttach.cpp less more

26	26	#include <kopano/ECDebug.h>
27	27	#include <kopano/ECInterfaceDefs.h>
28	28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32
33
34	29	HRESULT ECAttachFactory::Create(ECMsgStore lpMsgStore, ULONG ulObjType, BOOL fModify, ULONG ulAttachNum, ECMAPIProp lpRoot, ECAttach **lppAttach) const
35	30	{
36	31	return ECAttach::Create(lpMsgStore, ulObjType, fModify, ulAttachNum, lpRoot, lppAttach);
37	32	}
38
39
40	33
41	34	ECAttach::ECAttach(ECMsgStore lpMsgStore, ULONG ulObjType, BOOL fModify, ULONG ulAttachNum, ECMAPIProp lpRoot) : ECMAPIProp(lpMsgStore, ulObjType, fModify, lpRoot, "IAttach")
42	35	{

+0

-9

provider/client/ECChangeAdvisor.cpp less more

23	23
24	24	#include "ECChangeAdvisor.h"
25	25	#include "ECMsgStore.h"
26
27
28		#ifdef _DEBUG
29		#define new DEBUG_NEW
30		#endif
31	26
32	27	ULONG ECChangeAdvisor::GetSyncId(const ConnectionMap::value_type &sConnection)
33	28	{

157	152
158	153	return hr;
159	154	}
160
161
162	155
163	156	HRESULT ECChangeAdvisor::GetLastError(HRESULT hResult, ULONG ulFlags, LPMAPIERROR *lppMAPIError)
164	157	{

340	333	lpStream->Write(&m_mapSyncStates[iterConnection->first], sizeof(SyncStateMap::key_type), NULL);
341	334	}
342	335
343
344	336	exit:
345	337	pthread_mutex_unlock(&m_hConnectionLock);
346	338	return hr;

351	343	HRESULT hr = hrSuccess;
352	344	SSyncState *lpsSyncState = NULL;
353	345	ECLISTCONNECTION listConnections;
354		ECLISTCONNECTION::const_iterator iterConnection;
355	346	ECLISTSYNCSTATE listSyncStates;
356	347
357	348	if (m_lpChangeAdviseSink == NULL && !(m_ulFlags & SYNC_CATCHUP))

+0

-4

provider/client/ECChangeAdvisor.h less more

63	63	* change notifications.
64	64	* @param[out] lppChangeAdvisor
65	65	* The new change advisor.
66		* @return HRESULT
67	66	*/
68	67	static HRESULT Create(ECMsgStore lpMsgStore, ECChangeAdvisor *lppChangeAdvisor);
69	68

131	130	* The parameter passed to AddSessionReloadCallback.
132	131	* @param[in] newSessionId
133	132	* The sessionid of the new session.
134		*
135		* @return HRESULT.
136	133	*/
137	134	static HRESULT Reload(void *lpParam, ECSESSIONID newSessionId);
138	135
139	136	/**
140	137	* Purge all unused connections from advisor.
141		* @return HRESULT
142	138	*/
143	139	HRESULT PurgeStates();
144	140

+0

-3

provider/client/ECDisplayTable.cpp less more

23	23
24	24	#include "Mem.h"
25	25	#include <kopano/ECMemTable.h>
26		#ifdef _DEBUG
27		#define new DEBUG_NEW
28		#endif
29	26
30	27	// This function is NOT used, but is used as dummy for the xgettext parser so it
31	28	// can find the translation strings. DO NOT REMOVE THIS FUNCTION

+0

-5

provider/client/ECDistList.cpp less more

25	25	#include <kopano/CommonUtil.h>
26	26	#include <kopano/ECDebug.h>
27	27
28
29	28	#include "ECMAPITable.h"
30	29
31	30	#include "ECDisplayTable.h"
32
33		#ifdef _DEBUG
34		#define new DEBUG_NEW
35		#endif
36	31
37	32	ECDistList::ECDistList(void* lpProvider, BOOL fModify) : ECABContainer(lpProvider, MAPI_DISTLIST, fModify, "IDistList")
38	33	{

+5

-15

provider/client/ECExchangeExportChanges.cpp less more

40	40	#include "ECSyncSettings.h"
41	41	#include "EntryPoint.h"
42	42	#include <kopano/CommonUtil.h>
43
44		#ifdef LINUX
45	43	// We use ntohl/htonl for network-order conversion
46	44	#include <arpa/inet.h>
47		#endif
48
49	45	#include <kopano/charset/convert.h>
50
51		#ifdef _DEBUG
52		#define new DEBUG_NEW
53		#endif
54	46
55	47	ECExchangeExportChanges::ECExchangeExportChanges(ECMsgStore lpStore, const std::string &sk, const wchar_t szDisplay, unsigned int ulSyncType)
56	48	: m_iidMessage(IID_IMessage)

492	484	}
493	485
494	486	if (*lpulProgress == 0 && m_lpLogger->Log(EC_LOGLEVEL_DEBUG))
495		m_clkStart = z_times(&m_tmsStart);
	487	m_clkStart = times(&m_tmsStart);
496	488
497	489	if(m_ulSyncType == ICS_SYNC_CONTENTS){
498	490	hr = ExportMessageChanges();

555	547
556	548	if(m_ulChanges) {
557	549	if (m_lpLogger->Log(EC_LOGLEVEL_DEBUG)) {
558		struct z_tms tmsEnd = {0};
559		clock_t clkEnd = z_times(&tmsEnd);
	550	struct tms tmsEnd = {0};
	551	clock_t clkEnd = times(&tmsEnd);
560	552	double dblDuration = 0;
561	553	char szDuration[64] = {0};
562	554
563	555	// Calculate diff
564	556	dblDuration = (double)(clkEnd - m_clkStart) / TICKS_PER_SEC;
565	557	if (dblDuration >= 60)
566		_snprintf(szDuration, sizeof(szDuration), "%u:%02u.%03u min.", (unsigned)(dblDuration / 60), (unsigned)dblDuration % 60, (unsigned)(dblDuration * 1000 + .5) % 1000);
	558	snprintf(szDuration, sizeof(szDuration), "%u:%02u.%03u min.", (unsigned)(dblDuration / 60), (unsigned)dblDuration % 60, (unsigned)(dblDuration * 1000 + .5) % 1000);
567	559	else
568		_snprintf(szDuration, sizeof(szDuration), "%u.%03u s.", (unsigned)dblDuration % 60, (unsigned)(dblDuration * 1000 + .5) % 1000);
	560	snprintf(szDuration, sizeof(szDuration), "%u.%03u s.", (unsigned)dblDuration % 60, (unsigned)(dblDuration * 1000 + .5) % 1000);
569	561
570	562	m_lpLogger->Log(EC_LOGLEVEL_DEBUG, "folder changes synchronized in %s", szDuration);
571	563	} else

804	796	return pThis->SetLogger(lpLogger);
805	797	}
806	798
807
808	799	HRESULT ECExchangeExportChanges::ExportMessageChanges() {
809	800	ASSERT(m_lpImportContents != NULL);
810	801	if (m_lpImportStreamedContents != NULL)

1101	1092	ZLOG_DEBUG(m_lpLogger, "SaveChanges failed for destination message");
1102	1093	goto exit;
1103	1094	}
1104
1105	1095
1106	1096	next:
1107	1097	// Mark this change as processed, even if we skipped it due to SYNC_E_IGNORE or because the item was deleted on the source server

+1

-1

provider/client/ECExchangeExportChanges.h less more

126	126
127	127	ECLogger *m_lpLogger;
128	128	clock_t m_clkStart;
129		struct z_tms m_tmsStart;
	129	struct tms m_tmsStart;
130	130
131	131	HRESULT AddProcessedChanges(ChangeList &lstChanges);
132	132

+0

-60

provider/client/ECExchangeImportContentsChanges.cpp less more

42	42	#include "EntryPoint.h"
43	43
44	44	#include <list>
45
46		#ifdef _DEBUG
47		#define new DEBUG_NEW
48		#endif
49
50		#ifdef _DEBUG
51		class NullStream _kc_final : public IStream
52		{
53		public:
54		NullStream() : m_cRef(1) {}
55
56		// IUnknown
57		ULONG __stdcall AddRef() { return ++m_cRef; }
58		ULONG __stdcall Release() {
59		ULONG cRef = --m_cRef;
60		if (!m_cRef)
61		delete this;
62		return cRef;
63		}
64		HRESULT __stdcall QueryInterface(REFIID refiid, void **lpvoid) {
65		if (refiid == IID_IUnknown \|\| refiid == IID_IStream) {
66		AddRef();
67		*lpvoid = this;
68		return hrSuccess;
69		}
70		return MAPI_E_INTERFACE_NOT_SUPPORTED;
71		}
72
73		// ISequentialStream
74		HRESULT __stdcall Read(void pv, ULONG cb, ULONG pcbRead) {
75		if (pcbRead)
76		*pcbRead = cb;
77		return hrSuccess;
78		}
79		HRESULT __stdcall Write(const void pv, ULONG cb, ULONG pcbWritten) {
80		if (pcbWritten)
81		*pcbWritten = cb;
82		return hrSuccess;
83		}
84
85		// IStream
86		HRESULT __stdcall Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition) { return MAPI_E_NO_SUPPORT; }
87		HRESULT __stdcall SetSize(ULARGE_INTEGER libNewSize) { return MAPI_E_NO_SUPPORT; }
88		HRESULT __stdcall CopyTo(IStream pstm, ULARGE_INTEGER cb, ULARGE_INTEGER pcbRead, ULARGE_INTEGER *pcbWritten) { return MAPI_E_NO_SUPPORT; }
89		HRESULT __stdcall Commit(DWORD grfCommitFlags) { return MAPI_E_NO_SUPPORT; }
90		HRESULT __stdcall Revert(void) { return MAPI_E_NO_SUPPORT; }
91		HRESULT __stdcall LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) { return MAPI_E_NO_SUPPORT; }
92		HRESULT __stdcall UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType) { return MAPI_E_NO_SUPPORT; }
93		HRESULT __stdcall Stat(STATSTG *pstatstg, DWORD grfStatFlag) { return MAPI_E_NO_SUPPORT; }
94		HRESULT __stdcall Clone(IStream **ppstm) { return MAPI_E_NO_SUPPORT; }
95
96		private:
97		ULONG m_cRef;
98		};
99		#endif
100	45
101	46	ECExchangeImportContentsChanges::ECExchangeImportContentsChanges(ECMAPIFolder *lpFolder)
102	47	: m_iidMessage(IID_IMessage)

279	224	return hrSuccess;
280	225	}
281	226
282
283	227	HRESULT ECExchangeImportContentsChanges::ImportMessageChange(ULONG cValue, LPSPropValue lpPropArray, ULONG ulFlags, LPMESSAGE * lppMessage){
284	228	HRESULT hr = hrSuccess;
285	229

566	510	return bConflict;
567	511	}
568	512
569
570	513	HRESULT ECExchangeImportContentsChanges::CreateConflictMessage(LPMESSAGE lpMessage)
571	514	{
572	515	HRESULT hr = hrSuccess;

583	526	hr = lpMessage->SaveChanges(KEEP_OPEN_READWRITE);
584	527	if(hr != hrSuccess)
585	528	goto exit;
586
587	529
588	530	exit:
589	531	MAPIFreeBuffer(lpConflictItems);

704	646	MAPIFreeBuffer(lpEntryIdProp);
705	647	return hr;
706	648	}
707
708	649
709	650	HRESULT ECExchangeImportContentsChanges::CreateConflictFolders(){
710	651	HRESULT hr = hrSuccess;

1059	1000	m_iidMessage = refiid;
1060	1001	return hrSuccess;
1061	1002	}
1062
1063	1003
1064	1004	/**
1065	1005	* Check if the passed entryids can be found in the RES_PROPERTY restrictions with the proptag

+0

-6

provider/client/ECExchangeImportHierarchyChanges.cpp less more

37	37	#include <kopano/charset/utf8string.h>
38	38	#include <kopano/charset/convstring.h>
39	39
40		#ifdef _DEBUG
41		#define new DEBUG_NEW
42		#endif
43
44	40	ECExchangeImportHierarchyChanges::ECExchangeImportHierarchyChanges(ECMAPIFolder *lpFolder){
45	41	m_lpFolder = lpFolder;
46	42	m_lpStream = NULL;

209	205
210	206	return lpStream->Write(&m_ulChangeId, 4, &ulLen);
211	207	}
212
213	208
214	209	HRESULT ECExchangeImportHierarchyChanges::ImportFolderChange(ULONG cValue, LPSPropValue lpPropArray){
215	210	HRESULT hr = hrSuccess;

466	461	hrTmp = ECExchangeImportContentsChanges::HrUpdateSearchReminders(ptrRoot, lpPropAdditionalREN);
467	462	}
468	463
469
470	464	exit:
471	465	MAPIFreeBuffer(lpPropVal);
472	466	MAPIFreeBuffer(lpEntryId);

+0

-9

provider/client/ECExchangeModifyTable.cpp less more

41	41
42	42	#include <kopano/ECInterfaceDefs.h>
43	43
44		#ifdef _DEBUG
45		#define new DEBUG_NEW
46		#endif
47
48	44	static LPWSTR WTF1252_to_WCHAR(LPCSTR szWTF1252, LPVOID lpBase, convert_context *lpConverter)
49	45	{
50	46	HRESULT hr = hrSuccess;

80	76
81	77	return lpszResult;
82	78	}
83
84	79
85	80	ECExchangeModifyTable::ECExchangeModifyTable(ULONG ulUniqueTag, ECMemTable table, ECMAPIProp lpParent, ULONG ulStartUniqueId, ULONG ulFlags) {
86	81	m_ecTable = table;

102	97	if(m_lpParent)
103	98	m_lpParent->Release();
104	99	}
105
106	100
107	101	HRESULT __stdcall ECExchangeModifyTable::CreateACLTable(ECMAPIProp lpParent, ULONG ulFlags, LPEXCHANGEMODIFYTABLE lppObj) {
108	102	HRESULT hr = hrSuccess;

333	327	return hr;
334	328	}
335	329
336
337	330	HRESULT ECExchangeModifyTable::OpenACLS(ECMAPIProp lpecMapiProp, ULONG ulFlags, ECMemTable lpTable, ULONG *lpulUniqueID)
338	331	{
339	332	HRESULT hr = hrSuccess;

550	543	hr = ConvertString8ToUnicode(lpRowSet);
551	544	if(hr != hrSuccess)
552	545	goto exit;
553
554	546
555	547	// Convert to SOAP rows
556	548	hr = CopyMAPIRowSetToSOAPRowSet(lpRowSet, &lpSOAPRowSet);

688	680	return MAPI_E_NO_SUPPORT;
689	681	}
690	682
691
692	683	// wrappers for ExchageRuleAction class
693	684
694	685	DEF_HRMETHOD(TRACE_MAPI, ECExchangeRuleAction, ExchangeRuleAction, QueryInterface, (REFIID, refiid), (void **, lppInterface))

+0

-6

provider/client/ECExportAddressbookChanges.cpp less more

32	32	#include <kopano/Util.h>
33	33
34	34	#include <edkmdb.h>
35
36		#ifdef _DEBUG
37		#define new DEBUG_NEW
38		#endif
39	35
40	36	ECExportAddressbookChanges::ECExportAddressbookChanges(ECMsgStore *lpStore) {
41	37	ECSyncLog::GetLogger(&m_lpLogger);

344	340	return hrSuccess;
345	341	}
346	342
347
348	343	/**
349	344	* Compares two ICSCHANGE objects and determines which of the two should precede the other.
350	345	* This function is supposed to be used as the predicate in std::stable_sort.

398	393	return false;
399	394	}
400	395
401
402	396	ULONG ECExportAddressbookChanges::xECExportAddressbookChanges::AddRef()
403	397	{
404	398	METHOD_PROLOGUE_(ECExportAddressbookChanges, ECExportAddressbookChanges);

+0

-5

provider/client/ECGenericProp.cpp less more

31	31	#include <kopano/charset/convert.h>
32	32	#include "EntryPoint.h"
33	33
34		#ifdef _DEBUG
35		#define new DEBUG_NEW
36		#endif
37
38	34	ECGenericProp::ECGenericProp(void *lpProvider, ULONG ulObjType, BOOL fModify,
39	35	const char *szClassName) :
40	36	ECUnknown(szClassName)

458	454	}
459	455	return hr;
460	456	}
461
462	457
463	458	HRESULT ECGenericProp::GetLastError(HRESULT hResult, ULONG ulFlags, LPMAPIERROR FAR * lppMAPIError)
464	459	{

+0

-8

provider/client/ECMAPIContainer.cpp less more

21	21	#include <kopano/ECGuid.h>
22	22	#include <kopano/ECDebug.h>
23	23
24
25	24	//#include <edkmdb.h>
26	25	#include <kopano/mapiext.h>
27	26	#include <mapiutil.h>
28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32	27
33	28	ECMAPIContainer::ECMAPIContainer(ECMsgStore *lpMsgStore, ULONG ulObjType,
34	29	BOOL fModify, const char *szClassName) :

93	88	if(hr != hrSuccess)
94	89	goto exit;
95	90
96
97	91	hr = this->GetMsgStore()->lpTransport->HrOpenTableOps(MAPI_MESSAGE, (ulFlags&(MAPI_UNICODE\|SHOW_SOFT_DELETES\|MAPI_ASSOCIATED\|EC_TABLE_NOCAP)), m_cbEntryId, m_lpEntryId, this->GetMsgStore(), &lpTableOps);
98	92
99	93	if(hr != hrSuccess)

117	111
118	112	return hr;
119	113	}
120
121	114
122	115	HRESULT ECMAPIContainer::GetHierarchyTable(ULONG ulFlags, LPMAPITABLE *lppTable)
123	116	{

191	184	return this->GetMsgStore()->OpenEntry(cbEntryID, lpEntryID, lpInterface, ulFlags, lpulObjType, lppUnk);
192	185	}
193	186
194
195	187	// From IMAPIContainer
196	188	HRESULT ECMAPIContainer::xMAPIContainer::GetContentsTable(ULONG ulFlags, LPMAPITABLE *lppTable)
197	189	{

+0

-8

provider/client/ECMAPIFolder.cpp less more

47	47	#include <kopano/stringutil.h>
48	48
49	49	#include <kopano/charset/convstring.h>
50
51		#ifdef _DEBUG
52		#define new DEBUG_NEW
53		#endif
54	50
55	51	static LONG __stdcall AdviseECFolderCallback(void *lpContext, ULONG cNotif,
56	52	LPNOTIFICATION lpNotif)

225	221	return hr;
226	222	}
227	223
228
229	224	HRESULT ECMAPIFolder::QueryInterface(REFIID refiid, void **lppInterface)
230	225	{
231	226	REGISTER_INTERFACE(IID_ECMAPIFolder, this);

447	442	if(hr != hrSuccess)
448	443	goto exit;
449	444
450
451	445	// Load an empty property set
452	446	hr = lpMessage->HrLoadEmptyProps();
453	447	if(hr != hrSuccess)

731	725	hr = this->GetMsgStore()->lpSupport->CopyFolder(&IID_IMAPIFolder, &this->m_xMAPIFolder, cbEntryID, lpEntryID, lpInterface, lpDestFolder, lpszNewFolderName, ulUIParam, lpProgress, ulFlags);
732	726	}
733	727
734
735	728	exit:
736	729	if(lpMapiFolder)
737	730	lpMapiFolder->Release();

1081	1074	return hr;
1082	1075	}
1083	1076
1084
1085	1077	HRESULT ECMAPIFolder::xMAPIFolder::CreateMessage(LPCIID lpInterface, ULONG ulFlags, LPMESSAGE *lppMessage)
1086	1078	{
1087	1079	TRACE_MAPI(TRACE_ENTRY, "IMAPIFolder::CreateMessage", "flags=%d", ulFlags);

+0

-6

provider/client/ECMAPIFolderPublic.cpp less more

42	42
43	43	#include <kopano/ECGetText.h>
44	44
45		#ifdef _DEBUG
46		#define new DEBUG_NEW
47		#endif
48
49
50	45	ECMAPIFolderPublic::ECMAPIFolderPublic(ECMsgStore lpMsgStore, BOOL fModify, WSMAPIFolderOps lpFolderOps, enumPublicEntryID ePublicEntryID) :
51	46	ECMAPIFolder(lpMsgStore, fModify, lpFolderOps, "IMAPIFolderPublic")
52	47	{

545	540	hr = this->GetMsgStore()->lpSupport->CopyFolder(&IID_IMAPIFolder, &this->m_xMAPIFolder, cbEntryID, lpEntryID, lpInterface, lpDestFolder, lpszNewFolderName, ulUIParam, lpProgress, ulFlags);
546	541	}
547	542
548
549	543	exit:
550	544	if(lpMapiFolder)
551	545	lpMapiFolder->Release();

+0

-7

provider/client/ECMAPIProp.cpp less more

43	43
44	44	#include <sstream>
45	45
46		#ifdef _DEBUG
47		#define new DEBUG_NEW
48		#endif
49
50	46	static struct rights ECPermToRightsCheap(const ECPERMISSION &p)
51	47	{
52	48	struct rights r = {0, p.ulType, p.ulRights, p.ulState};

386	382
387	383	return hr;
388	384	}
389
390	385
391	386	// FIXME openproperty on computed value is illegal
392	387	HRESULT ECMAPIProp::OpenProperty(ULONG ulPropTag, LPCIID lpiid, ULONG ulInterfaceOptions, ULONG ulFlags, LPUNKNOWN FAR * lppUnk)

537	532	exit:
538	533	if(lpsPropValue)
539	534	ECFreeBuffer(lpsPropValue);
540
541	535
542	536	return hr;
543	537	}

748	742	return hrSuccess;
749	743	}
750	744
751
752	745	HRESULT ECMAPIProp::CopyTo(ULONG ciidExclude, LPCIID rgiidExclude, LPSPropTagArray lpExcludeProps, ULONG ulUIParam, LPMAPIPROGRESS lpProgress, LPCIID lpInterface, LPVOID lpDestObj, ULONG ulFlags, LPSPropProblemArray FAR * lppProblems)
753	746	{
754	747	return Util::DoCopyTo(&IID_IMAPIProp, &this->m_xMAPIProp, ciidExclude, rgiidExclude, lpExcludeProps, ulUIParam, lpProgress, lpInterface, lpDestObj, ulFlags, lppProblems);

+0

-19

provider/client/ECMAPITable.cpp less more

31	31	#include <kopano/ECDebug.h>
32	32	#include <kopano/ECInterfaceDefs.h>
33	33
34
35		#ifdef _DEBUG
36		#define new DEBUG_NEW
37		#endif
38
39	34	ECMAPITable::ECMAPITable(std::string strName, ECNotifyClient *lpNotifyClient, ULONG ulFlags) : ECUnknown("IMAPITable")
40	35	{
41	36	TRACE_MAPI(TRACE_ENTRY, "ECMAPITable::ECMAPITable","");

238	233	return hr;
239	234	}
240	235
241
242	236	HRESULT ECMAPITable::SetColumns(LPSPropTagArray lpPropTagArray, ULONG ulFlags)
243	237	{
244	238	HRESULT hr = hrSuccess;

314	308	return hr;
315	309	}
316	310
317
318	311	HRESULT ECMAPITable::SeekRow(BOOKMARK bkOrigin, LONG lRowCount, LONG *lplRowsSought)
319	312	{
320	313	HRESULT hr = hrSuccess;

333	326	return hr;
334	327	}
335	328
336
337	329	HRESULT ECMAPITable::SeekRowApprox(ULONG ulNumerator, ULONG ulDenominator)
338	330	{
339	331	HRESULT hr = hrSuccess;

358	350
359	351	return hr;
360	352	}
361
362	353
363	354	HRESULT ECMAPITable::QueryPosition(ULONG lpulRow, ULONG lpulNumerator, ULONG *lpulDenominator)
364	355	{

387	378	return hr;
388	379	}
389	380
390
391	381	HRESULT ECMAPITable::FindRow(LPSRestriction lpRestriction, BOOKMARK bkOrigin, ULONG ulFlags)
392	382	{
393	383	HRESULT hr = hrSuccess;

409	399
410	400	return hr;
411	401	}
412
413	402
414	403	HRESULT ECMAPITable::Restrict(LPSRestriction lpRestriction, ULONG ulFlags)
415	404	{

442	431	return hr;
443	432	}
444	433
445
446	434	HRESULT ECMAPITable::CreateBookmark(BOOKMARK* lpbkPosition)
447	435	{
448	436	HRESULT hr = hrSuccess;

460	448	return hr;
461	449	}
462	450
463
464	451	HRESULT ECMAPITable::FreeBookmark(BOOKMARK bkPosition)
465	452	{
466	453	HRESULT hr = hrSuccess;

477	464
478	465	return hr;
479	466	}
480
481	467
482	468	HRESULT ECMAPITable::SortTable(LPSSortOrderSet lpSortCriteria, ULONG ulFlags)
483	469	{

511	497	return hr;
512	498	}
513	499
514
515	500	HRESULT ECMAPITable::QuerySortOrder(LPSSortOrderSet *lppSortCriteria)
516	501	{
517	502	HRESULT hr = hrSuccess;

561	546	return hr;
562	547	}
563	548
564
565	549	HRESULT ECMAPITable::ExpandRow(ULONG cbInstanceKey, LPBYTE pbInstanceKey, ULONG ulRowCount, ULONG ulFlags, LPSRowSet * lppRows, ULONG *lpulMoreRows)
566	550	{
567	551	HRESULT hr = hrSuccess;

577	561	pthread_mutex_unlock(&m_hLock);
578	562	return hr;
579	563	}
580
581	564
582	565	HRESULT ECMAPITable::CollapseRow(ULONG cbInstanceKey, LPBYTE pbInstanceKey, ULONG ulFlags, ULONG *lpulRowCount)
583	566	{

614	597	return hr;
615	598	}
616	599
617
618	600	HRESULT ECMAPITable::GetCollapseState(ULONG ulFlags, ULONG cbInstanceKey, LPBYTE lpbInstanceKey, ULONG lpcbCollapseState, LPBYTE lppbCollapseState)
619	601	{
620	602	HRESULT hr = hrSuccess;

631	613
632	614	return hr;
633	615	}
634
635	616
636	617	HRESULT ECMAPITable::SetCollapseState(ULONG ulFlags, ULONG cbCollapseState, LPBYTE pbCollapseState, BOOKMARK *lpbkLocation)
637	618	{

+0

-8

provider/client/ECMSProvider.cpp less more

33	33
34	34	#include <kopano/ECDebug.h>
35	35
36
37	36	#include "ClientUtil.h"
38	37	#include "EntryPoint.h"
39	38

52	51
53	52	#include <kopano/mapi_ptr/mapi_memory_ptr.h>
54	53	typedef mapi_memory_ptr<ECUSER> ECUserPtr;
55
56		#ifdef _DEBUG
57		#define new DEBUG_NEW
58		#endif
59	54
60	55	ECMSProvider::ECMSProvider(ULONG ulFlags, const char *szClassName) :
61	56	ECUnknown(szClassName)

256	251	sGlobalProfileProps sProfileProps;
257	252	wchar_t *strSep = NULL;
258	253
259
260	254	if(lpEntryID == NULL) {
261	255	hr = MAPI_E_UNCONFIGURED;
262	256	goto exit;

298	292	}
299	293	}
300	294
301
302	295	if (cbSpoolSecurity % sizeof(wchar_t) != 0) {
303	296	hr = MAPI_E_INVALID_PARAMETER;
304	297	goto exit;

336	329	&lpMsgStore);
337	330	if(hr != hrSuccess)
338	331	goto exit;
339
340	332
341	333	// Register ourselves with mapisupport
342	334	//guidStore = lpMsgStore->GetStoreGuid();

+0

-6

provider/client/ECMSProviderOffline.cpp less more

29	29	#include <kopano/Trace.h>
30	30	#include <kopano/ECDebug.h>
31	31
32
33	32	#include <edkguid.h>
34	33	#include "EntryPoint.h"
35	34	#include "DLLGlobal.h"

40	39	#include <kopano/stringutil.h>
41	40
42	41	#include "ProviderUtil.h"
43
44		#ifdef _DEBUG
45		#define new DEBUG_NEW
46		#endif
47
48	42
49	43	ECMSProviderOffline::ECMSProviderOffline(ULONG ulFlags) :
50	44	ECMSProvider(ulFlags\|EC_PROVIDER_OFFLINE, "ECMSProviderOffline")

+0

-7

provider/client/ECMSProviderSwitch.cpp less more

49	49	#undef swprintf
50	50	#endif
51	51
52		#ifdef _DEBUG
53		#define new DEBUG_NEW
54		#endif
55
56	52	ECMSProviderSwitch::ECMSProviderSwitch(ULONG ulFlags) : ECUnknown("ECMSProviderSwitch")
57	53	{
58	54	m_ulFlags = ulFlags;

277	273	swprintf((wchar_t)lppbSpoolSecurity, cbSpoolSecurity, L"%s%c%s", sProfileProps.strUserName.c_str(), 0, sProfileProps.strPassword.c_str());
278	274	*lpcbSpoolSecurity = cbSpoolSecurity;
279	275	}
280
281	276
282	277	exit:
283	278	if (lppMAPIError)

340	335	if (hr != hrSuccess)
341	336	goto exit;
342	337
343
344	338	if (lppMSLogon) {
345	339	hr = lpMSLogon->QueryInterface(IID_IMSLogon, (void **)lppMSLogon);
346	340	if (hr != hrSuccess)

353	347	goto exit;
354	348	}
355	349
356
357	350	exit:
358	351	if (lppMAPIError)
359	352	*lppMAPIError = NULL;

+0

-4

provider/client/ECMailUser.cpp less more

25	25
26	26	#include "ECDisplayTable.h"
27	27
28		#ifdef _DEBUG
29		#define new DEBUG_NEW
30		#endif
31
32	28	ECMailUser::ECMailUser(void* lpProvider, BOOL fModify) : ECABProp(lpProvider, MAPI_MAILUSER, fModify, "IMailUser")
33	29	{
34	30	// since we have no OpenProperty / abLoadProp, remove the 8k prop limit

+0

-8

provider/client/ECMemTablePublic.cpp less more

30	30	#include <kopano/restrictionutil.h>
31	31	#include "favoritesutil.h"
32	32
33		#ifdef _DEBUG
34		#define new DEBUG_NEW
35		#endif
36
37
38	33	//FIXME: add the classname "ECMemTablePublic"
39	34	ECMemTablePublic::ECMemTablePublic(ECMAPIFolderPublic lpECParentFolder, SPropTagArray lpsPropTags, ULONG ulRowPropTag) : ECMemTable(lpsPropTags, ulRowPropTag)
40	35	{

69	64	m_lpECParentFolder->Release();
70	65
71	66	}
72
73	67
74	68	HRESULT ECMemTablePublic::Create(ECMAPIFolderPublic lpECParentFolder, ECMemTablePublic *lppECMemTable)
75	69	{

235	229	hr = lpShortcutTable->SetColumns(GetShortCutTagArray(), MAPI_DEFERRED_ERRORS);
236	230	if(hr != hrSuccess)
237	231	goto exit;
238
239	232
240	233	// build restriction
241	234	CREATE_RESTRICTION(lpRestriction);

375	368	lpEntryID = lpFolderID;
376	369	}
377	370
378
379	371	cProps = 0;
380	372
381	373	hr = MAPIAllocateBuffer(sizeof(SPropValue) * 20, (void**)&lpProps);

+0

-16

provider/client/ECMessage.cpp less more

36	36	#include <kopano/ECDebug.h>
37	37	#include "WSUtil.h"
38	38
39
40	39	#include "ClientUtil.h"
41	40	#include "ECMemStream.h"
42	41

44	43	#include <kopano/charset/convert.h>
45	44
46	45	using namespace std;
47
48		#ifdef _DEBUG
49		#define new DEBUG_NEW
50		#endif
51	46
52	47	#define MAX_TABLE_PROPSIZE 8192
53	48

96	91
97	92	// Workaround for support html in outlook 2000/xp need SetPropHandler
98	93	this->HrAddPropHandlers(PR_HTML, GetPropHandler ,SetPropHandler, (void*) this, FALSE, FALSE);
99
100	94
101	95	// The property 0x10970003 is set by outlook when browsing in the 'unread mail' searchfolder. It is used to make sure
102	96	// that a message that you just read is not removed directly from view. It is set for each message which should be in the view

548	542	if (hr != hrSuccess)
549	543	goto exit;
550	544
551
552	545	// Determine strategy based on RTF type.
553	546	if (isrtfhtml(strRTF.c_str(), strRTF.size()))
554	547	rtfType = RTFTypeFromHTML;

556	549	rtfType = RTFTypeFromText;
557	550	else
558	551	rtfType = RTFTypeOther;
559
560	552
561	553	if (rtfType == RTFTypeOther) {
562	554	BOOL bUpdated;

962	954	} // !new == empty table
963	955	}
964	956
965
966	957	if(this->lpAttachments == NULL) {
967	958	hr = MAPI_E_CALL_FAILED;
968	959	goto exit;

1267	1258	goto exit;
1268	1259	} // !fNew
1269	1260	}
1270
1271	1261
1272	1262	hr = lpRecips->HrGetView(createLocaleFromName(""), ulFlags & MAPI_UNICODE, &lpView);
1273	1263

2148	2138	goto exit;
2149	2139	}
2150	2140
2151
2152	2141	// Property change of a new item
2153	2142	if (fNew && this->GetMsgStore()->IsSpooler() == TRUE) {
2154	2143

2694	2683
2695	2684	hr = Util::DoCopyTo(&IID_IMessage, &this->m_xMessage, ciidExclude, rgiidExclude, lpExcludeProps, ulUIParam, lpProgress, lpInterface, lpDestObj, ulFlags, lppProblems);
2696	2685
2697
2698	2686	exit:
2699	2687	if(lpECMAPIProp)
2700	2688	lpECMAPIProp->Release();

2755	2743	if (lpsBodyProps[2].ulPropTag == PR_HTML \|\| (lpsBodyProps[2].ulPropTag == PROP_TAG(PT_ERROR, PROP_ID(PR_HTML)) && lpsBodyProps[2].Value.err == MAPI_E_NOT_ENOUGH_MEMORY))
2756	2744	fHTMLOK = TRUE;
2757	2745
2758
2759	2746	if (fRTFOK) {
2760	2747	HRESULT hrTmp = hrSuccess;
2761	2748

2890	2877	goto exit;
2891	2878	}
2892	2879
2893
2894	2880	if (!m_sMapiObject) {
2895	2881	// when does this happen? .. just a simple precaution for now
2896	2882	ASSERT(m_sMapiObject != NULL);

3107	3093	return pThis->Release();
3108	3094	}
3109	3095
3110
3111	3096	HRESULT ECMessage::xMessage::GetLastError(HRESULT hError, ULONG ulFlags, LPMAPIERROR * lppMapiError)
3112	3097	{
3113	3098	TRACE_MAPI(TRACE_ENTRY, "IMessage::GetLastError", "");

3205	3190	return hr;
3206	3191	}
3207	3192
3208
3209	3193	HRESULT ECMessage::xMessage::GetAttachmentTable(ULONG ulFlags, LPMAPITABLE *lppTable)
3210	3194	{
3211	3195	TRACE_MAPI(TRACE_ENTRY, "IMessage::GetAttachmentTable", "");

+0

-2

provider/client/ECMessage.h less more

40	40	class ECMessage : public ECMAPIProp {
41	41	protected:
42	42	/**
43		* \brief Constructor
44		*
45	43	* \param lpMsgStore The store owning this message.
46	44	* \param fNew Specifies whether the message is a new message.
47	45	* \param fModify Specifies whether the message is writable.

+0

-3

provider/client/ECMessageStreamImporterIStreamAdapter.cpp less more

128	128	return MAPI_E_NO_SUPPORT;
129	129	}
130	130
131
132	131	ECMessageStreamImporterIStreamAdapter::ECMessageStreamImporterIStreamAdapter(WSMessageStreamImporter *lpStreamImporter)
133	132	: m_ptrStreamImporter(lpStreamImporter, true)
134	133	{ }

137	136	{
138	137	Commit(0); // This causes us to wait for the async thread.
139	138	}
140
141
142	139
143	140	// ISequentialStream proxies
144	141	ULONG ECMessageStreamImporterIStreamAdapter::xSequentialStream::AddRef()

+3

-24

provider/client/ECMsgStore.cpp less more

63	63
64	64	using namespace std;
65	65
66		#ifdef _DEBUG
67		#define new DEBUG_NEW
68		#endif
69
70	66	// FIXME: from libserver/ECMAPI.h
71	67	#define MSGFLAG_DELETED ((ULONG) 0x00000400)
72
73	68
74	69	const static SizedSPropTagArray(NUM_RFT_PROPS, sPropRFTColumns) =
75	70	{

158	153	if(lpszProfname)
159	154	this->m_strProfname = lpszProfname;
160	155	}
161
162
163	156
164	157	ECMsgStore::~ECMsgStore() {
165	158

754	747	if(hr != hrSuccess)
755	748	goto exit;
756	749
757
758	750	switch( ulObjType ) {
759	751	case MAPI_FOLDER:
760	752	hr = lpTransport->HrOpenFolderOps(cbEntryID, lpEntryID, &lpFolderOps);

1716	1708	// localfreebusy message
1717	1709	IMessage* lpFBMessage = NULL;
1718	1710
1719
1720	1711	// Freebusy mv propery
1721	1712	// This property will be fill in on another place
1722	1713	hr = ECAllocateBuffer(sizeof(SPropValue), (void**)&lpFBPropValue);

1732	1723	goto exit;
1733	1724
1734	1725	memset(lpFBPropValue->Value.MVbin.lpbin, 0, sizeof(SBinary)*lpFBPropValue->Value.MVbin.cValues);
1735
1736	1726
1737	1727	// Create Freebusy Data into the rootfolder
1738	1728	// Folder for "freebusy data" settings

1786	1776	lpPropValue[cCurValues].ulPropTag = PR_PROCESS_MEETING_REQUESTS;
1787	1777	lpPropValue[cCurValues++].Value.b = false;
1788	1778
1789
1790	1779	hr = lpFBMessage->SetProps(cCurValues, lpPropValue, NULL);
1791	1780	if(hr != hrSuccess)
1792	1781	goto exit;

1833	1822	lpPropValue[cCurValues].ulPropTag = PR_FREEBUSY_NUM_MONTHS;
1834	1823	lpPropValue[cCurValues++].Value.ul = ECFREEBUSY_DEFAULT_PUBLISH_MONTHS;
1835	1824
1836
1837	1825	hr = lpFBMessage->SetProps(cCurValues, lpPropValue, NULL);
1838	1826	if(hr != hrSuccess)
1839	1827	goto exit;

1859	1847
1860	1848	ECFreeBuffer(lpPropValue); lpPropValue = NULL;
1861	1849	lpFBMessage->Release(); lpFBMessage = NULL;
1862
1863	1850
1864	1851	// Add freebusy entryid on Inbox folder
1865	1852	hr = lpInboxFolder->SetProps(1, lpFBPropValue, NULL);

2019	2006	return hr;
2020	2007	}
2021	2008
2022
2023	2009	HRESULT ECMsgStore::CreateStore(ULONG ulStoreType, ULONG cbUserId, LPENTRYID lpUserId, ULONG* lpcbStoreId, LPENTRYID* lppStoreId, ULONG* lpcbRootId, LPENTRYID *lppRootId)
2024	2010	{
2025	2011	HRESULT hr = hrSuccess;

2036	2022	LPMAPIFOLDER lpInboxFolder = NULL;
2037	2023	LPMAPIFOLDER lpCalendarFolder = NULL;
2038	2024
2039
2040	2025	LPSPropValue lpPropValue = NULL;
2041	2026	ULONG cValues = 0;
2042	2027	ULONG ulObjType = 0;

2055	2040	LPENTRYID lpStoreId = NULL;
2056	2041	ULONG cbRootId = 0;
2057	2042	LPENTRYID lpRootId = NULL;
2058
2059	2043
2060	2044	hr = CreateEmptyStore(ulStoreType, cbUserId, lpUserId, 0, &cbStoreId, &lpStoreId, &cbRootId, &lpRootId);
2061	2045	if (hr != hrSuccess)

2147	2131	if(hr != hrSuccess)
2148	2132	goto exit;
2149	2133
2150
2151	2134	// Set acl's on the folder
2152	2135	sPermission.ulRights = ecRightsReadAny\|ecRightsFolderVisible;
2153	2136	sPermission.ulState = RIGHT_NEW\|RIGHT_AUTOUPDATE_DENIED;

2192	2175	lpECSecurity->Release();
2193	2176	lpECSecurity = NULL;
2194	2177
2195
2196	2178	// Set acl's on the IPM subtree folder
2197	2179	sPermission.ulRights = ecRightsReadAny\| ecRightsCreate \| ecRightsEditOwned\| ecRightsDeleteOwned \| ecRightsCreateSubfolder \| ecRightsFolderVisible;
2198	2180	sPermission.ulState = RIGHT_NEW\|RIGHT_AUTOUPDATE_DENIED;

2291	2273	if(hr != hrSuccess)
2292	2274	goto exit;
2293	2275
2294
2295	2276	// Create Outbox
2296	2277	hr = CreateSpecialFolder(lpFolderRootST, lpecMsgStore, _("Outbox"), _T(""), PR_IPM_OUTBOX_ENTRYID, 0, NULL, NULL);
2297	2278	if(hr != hrSuccess)

2389	2370
2390	2371	lpCalendarFolder->Release(); lpCalendarFolder = NULL;
2391	2372	lpECMapiFolderInbox->Release(); lpECMapiFolderInbox = NULL;
2392
2393	2373
2394	2374	// Create Outlook 2007/2010 Additional folders
2395	2375	hr = CreateAdditionalFolder(lpFolderRoot, lpInboxFolder, lpFolderRootST, RSF_PID_RSS_SUBSCRIPTION, _("RSS Feeds"), _("RSS Feed comment"), _T("IPF.Note.OutlookHomepage"), false);

2542	2522	goto exit;
2543	2523	}
2544	2524
2545
2546	2525	if (lpcbStoreId == 0 \|\| lpcbRootId == 0) {
2547	2526	if (CoCreateGuid(&guidStore) != S_OK) {
2548	2527	hr = MAPI_E_CALL_FAILED;

3299	3278
3300	3279	// Check if the last part equals 'cn=Microsoft Private MDB'
3301	3280	riPart = parts.rbegin();
3302		if (stricmp(riPart->c_str(), "cn=Microsoft Private MDB") != 0)
	3281	if (strcasecmp(riPart->c_str(), "cn=Microsoft Private MDB") != 0)
3303	3282	return MAPI_E_INVALID_PARAMETER;
3304	3283
3305	3284	// Check if the for last part starts with 'cn='
3306	3285	++riPart;
3307		if (strnicmp(riPart->c_str(), "cn=", 3) != 0)
	3286	if (strncasecmp(riPart->c_str(), "cn=", 3) != 0)
3308	3287	return MAPI_E_INVALID_PARAMETER;
3309	3288
3310	3289	// If the server has no home server information for a user, the servername will be set to 'Unknown'
3311	3290	// Return MAPI_E_NO_SUPPORT in that case.
3312		if (stricmp(riPart->c_str(), "cn=Unknown") == 0)
	3291	if (strcasecmp(riPart->c_str(), "cn=Unknown") == 0)
3313	3292	return MAPI_E_NO_SUPPORT;
3314	3293
3315	3294	*lpstrPseudoUrl = utf8string::from_string("pseudo://" + riPart->substr(3));

+0

-6

provider/client/ECMsgStorePublic.cpp less more

33	33
34	34	using namespace std;
35	35
36		#ifdef _DEBUG
37		#define new DEBUG_NEW
38		#endif
39
40	36	ECMsgStorePublic::ECMsgStorePublic(char lpszProfname, LPMAPISUP lpSupport, WSTransport lpTransport, BOOL fModify, ULONG ulProfileFlags, BOOL fIsSpooler, BOOL bOfflineStore) :
41	37	ECMsgStore(lpszProfname, lpSupport, lpTransport, fModify, ulProfileFlags, fIsSpooler, false, bOfflineStore)
42	38	{

46	42	HrAddPropHandlers(PR_IPM_PUBLIC_FOLDERS_ENTRYID, GetPropHandler, DefaultSetPropComputed, (void*) this, FALSE, FALSE);
47	43	HrAddPropHandlers(PR_IPM_FAVORITES_ENTRYID, GetPropHandler, DefaultSetPropComputed, (void*) this, FALSE, FALSE);
48	44	HrAddPropHandlers(PR_EC_PUBLIC_IPM_SUBTREE_ENTRYID, GetPropHandler, SetPropHandler, (void*) this, FALSE, TRUE);
49
50	45
51	46	m_lpIPMSubTreeID = NULL;
52	47	m_lpIPMFavoritesID = NULL;

239	234	goto exit;
240	235	}
241	236
242
243	237	switch( ulObjType ) {
244	238	case MAPI_FOLDER:
245	239

+0

-7

provider/client/ECNamedProp.cpp less more

25	25	#include "Mem.h"
26	26	#include "ECNamedProp.h"
27	27	#include "WSTransport.h"
28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32	28
33	29	/*
34	30	* How our named properties work

59	55	* Exchange) due to the fact that we know which named properties are likely to be
60	56	* requested. This means that we have
61	57	*/
62
63	58
64	59	/* Our local names
65	60	*

236	231
237	232	lpsPropTagArray->cValues = cPropNames;
238	233
239
240	234	// Pass 1, resolve static (local) names (FAST)
241	235	for (i = 0; i < cPropNames; ++i)
242	236	if(lppPropNames[i] == NULL \|\| ResolveLocal(lppPropNames[i], &lpsPropTagArray->aulPropTag[i]) != hrSuccess)

373	367	exit:
374	368	return hr;
375	369	}
376
377	370
378	371	// Update the cache with the given data
379	372	HRESULT ECNamedProp::UpdateCache(ULONG ulId, MAPINAMEID *lpName)

+5

-11

provider/client/ECNotifyClient.cpp less more

13	13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	14	*/
15	15	#include <kopano/platform.h>
	16	#include <stdexcept>
16	17	#include <mapispi.h>
17	18	#include <mapix.h>
18	19	#include <kopano/ECDebug.h>

28	29
29	30	#define MAX_NOTIFS_PER_CALL 64
30	31
31		#ifdef _DEBUG
32		#define new DEBUG_NEW
33		#endif
34
35	32	static inline std::pair<ULONG,ULONG> SyncAdviseToConnection(const SSyncAdvise &sSyncAdvise) {
36	33	return std::make_pair(sSyncAdvise.sSyncState.ulSyncId,sSyncAdvise.ulConnection);
37	34	}

56	53	else if(m_ulProviderType == MAPI_ADDRBOOK)
57	54	m_lpTransport = ((ECABLogon*)m_lpProvider)->m_lpTransport;
58	55	else
59		ASSERT(FALSE);
	56	throw std::runtime_error("Unknown m_ulProviderType");
60	57
61	58	/* Get the sessiongroup ID of the provider that we will be handling notifications for */
62	59	if (m_lpTransport->HrGetSessionId(&ecSessionId, &m_ecSessionGroupId) != hrSuccess)
63		ASSERT(FALSE);
	60	throw std::runtime_error("ECNotifyClient/HrGetSessionId failed");
64	61
65	62	/* Get the session group that this session belongs to */
66	63	if (g_ecSessionManager.GetSessionGroupData(m_ecSessionGroupId, m_lpTransport->GetProfileProps(), &m_lpSessionGroup) != hrSuccess)
67		ASSERT(FALSE);
	64	throw std::runtime_error("ECNotifyClient/GetSessionGroupData failed");
68	65
69	66	if (m_lpSessionGroup->GetOrCreateNotifyMaster(&m_lpNotifyMaster) != hrSuccess)
70		ASSERT(FALSE);
	67	throw std::runtime_error("ECNotifyClient/GetOrCreateNotifyMaster failed");
71	68
72	69	m_lpNotifyMaster->AddSession(this);
73	70	}

528	525	return hr;
529	526	}
530	527
531
532	528	HRESULT ECNotifyClient::ReleaseAll()
533	529	{
534	530	HRESULT hr = hrSuccess;

566	562
567	563	notifications.push_back(&notif);
568	564
569
570	565	// The transport used for this notifyclient may have a broken session. Inform the
571	566	// transport that the session may be broken and it should verify that all is well.
572	567

582	577
583	578	return hr;
584	579	}
585
586	580
587	581	HRESULT ECNotifyClient::Notify(ULONG ulConnection, const NOTIFYLIST &lNotifications)
588	582	{

+0

-12

provider/client/ECNotifyMaster.cpp less more

26	26	#include <kopano/stringutil.h>
27	27	#include "SOAPUtils.h"
28	28	#include "WSTransport.h"
29
30		#ifdef LINUX
31	29	#include <sys/signal.h>
32	30	#include <sys/types.h>
33		#endif
34
35		#ifdef _DEBUG
36		#define new DEBUG_NEW
37		#endif
38	31
39	32	#define CALL_MEMBER_FN(object,ptrToMember) ((object).*(ptrToMember))
40	33

258	251	/* Make thread joinable which we need during shutdown */
259	252	pthread_attr_setdetachstate(&m_hAttrib, PTHREAD_CREATE_JOINABLE);
260	253
261		#ifdef LINUX
262	254	/* 1Mb of stack space per thread */
263	255	if (pthread_attr_setstacksize(&m_hAttrib, 1024 * 1024)) {
264	256	hr = MAPI_E_CALL_FAILED;
265	257	goto exit;
266	258	}
267		#endif
268
269	259	if (pthread_create(&m_hThread, &m_hAttrib, NotifyWatch, (void *)this)) {
270	260	hr = MAPI_E_CALL_FAILED;
271	261	goto exit;

341	331	notifyResponse notifications;
342	332	bool bReconnect = false;
343	333
344		#ifdef LINUX
345	334	/* Ignore SIGPIPE which may be caused by HrGetNotify writing to the closed socket */
346	335	signal(SIGPIPE, SIG_IGN);
347		#endif
348	336
349	337	while (!pNotifyMaster->m_bThreadExit) {
350	338	memset(&notifications, 0, sizeof(notifications));

+0

-10

provider/client/ECParentStorage.cpp less more

25	25	#include "WSUtil.h"
26	26	#include <kopano/Util.h>
27	27
28		#ifdef _DEBUG
29		#define new DEBUG_NEW
30		#endif
31
32		/*
33		* ECParentStorage implementation
34		*/
35
36	28	ECParentStorage::ECParentStorage(ECGenericProp lpParentObject, ULONG ulUniqueId, ULONG ulObjId, IECPropStorage lpServerStorage)
37	29	{
38	30	m_lpParentObject = lpParentObject;

100	92
101	93	HRESULT ECParentStorage::HrSaveObject(ULONG ulFlags, MAPIOBJECT *lpsMapiObject)
102	94	{
103		ECMapiObjects::const_iterator iterSObj;
104
105	95	if (m_lpParentObject == NULL)
106	96	return MAPI_E_INVALID_OBJECT;
107	97

+0

-4

provider/client/ECPropertyEntry.cpp less more

20	20	#include "Mem.h"
21	21	#include <kopano/charset/convert.h>
22	22
23		#ifdef _DEBUG
24		#define new DEBUG_NEW
25		#endif
26
27	23	//
28	24	// ECPropertyEntry
29	25	//

+0

-5

provider/client/ECSessionGroupManager.cpp less more

23	23	#include "ECSessionGroupManager.h"
24	24	#include "SessionGroupData.h"
25	25	#include "SSLUtil.h"
26
27		#ifdef _DEBUG
28		#define new DEBUG_NEW
29		#endif
30
31	26
32	27	/* std::algorithm helper structures/functions */
33	28	struct findSessionGroupId

+0

-6

provider/client/ECXPLogon.cpp less more

38	38	#include <kopano/ECRestriction.h>
39	39	#include <kopano/mapi_ptr.h>
40	40
41
42		#ifdef _DEBUG
43		#define new DEBUG_NEW
44		#endif
45
46	41	static HRESULT HrGetECMsgStore(IMAPIProp lpProp, ECMsgStore *lppECMsgStore)
47	42	{
48	43	HRESULT hr;

725	720	return hResult;
726	721	}
727	722
728
729	723	HRESULT ECXPLogon::xXPLogon::QueryInterface(REFIID refiid, void ** lppInterface)
730	724	{
731	725	TRACE_MAPI(TRACE_ENTRY, "IXPLogon::QueryInterface", "%s", DBGGUIDToString(refiid).c_str());

+0

-5

provider/client/ECXPProvider.cpp less more

18	18	#include <mapiutil.h>
19	19	#include <kopano/ECGuid.h>
20	20
21
22	21	#include "kcore.hpp"
23	22	#include "ECXPProvider.h"
24	23	#include "ECXPLogon.h"

35	34
36	35	#include <kopano/charset/convstring.h>
37	36	#include <kopano/ECGetText.h>
38
39		#ifdef _DEBUG
40		#define new DEBUG_NEW
41		#endif
42	37
43	38	ECXPProvider::ECXPProvider() : ECUnknown("IXPProvider")
44	39	{

+0

-83

~~provider/client/Makefile.am~~ less more

0		# -- Makefile --
1
2		pkglib_LTLIBRARIES = libkcclient.la
3		noinst_DATA = libkcclient.ldd
4
5		sysconf_configdir = ${MAPICONFIGDIR}
6		dist_sysconf_config_DATA = kopano.inf
7
8		sampleconfdir = ${docdir}/example-config
9		sampleconf_DATA = kopano.inf
10
11		AM_CPPFLAGS = ${ZCPPFLAGS} $(DEBUGFLAGS) $(BOOST_CPPFLAGS) \
12		$(GSOAP_CFLAGS) $(SSL_CFLAGS) \
13		-I${top_srcdir}/provider/include \
14		-I${top_srcdir}/provider/common \
15		-I${top_builddir}/provider/soap \
16		-I${top_srcdir}/provider/soap \
17		-I${top_srcdir}/mapi4linux/include \
18		-I${top_srcdir}/libfreebusy \
19		-I${top_srcdir}/common -I${top_srcdir}/m4lcommon \
20		-I${top_srcdir}/libsync
21
22		libkcclient_la_LDFLAGS = ${AM_LDFLAGS} -avoid-version -module
23		libkcclient_la_LIBADD = $(SSL_LIBS) \
24		${GSOAP_LIBS} \
25		${top_builddir}/provider/soap/libkcsoapclient.la \
26		${top_builddir}/provider/common/libkccommon.la \
27		${top_builddir}/common/libkcutil.la \
28		${top_builddir}/common/libkcmapi.la \
29		${top_builddir}/common/libkcssl.la \
30		${top_builddir}/libfreebusy/libkcfreebusy.la \
31		${top_builddir}/mapi4linux/src/libmapi.la \
32		${top_builddir}/libsync/libkcsync.la \
33		-lstdc++ $(UUID_LIBS) $(ICU_LIBS)
34
35		libkcclient_la_SOURCES = ECABLogon.cpp ECABProvider.cpp \
36		ECAttach.cpp ECMAPIContainer.cpp ECMAPIFolder.cpp ECMAPIProp.cpp \
37		ECMAPITable.cpp ECMessage.cpp ECMsgStore.cpp \
38		ECMSProvider.cpp ECNamedProp.cpp ECNotifyClient.cpp ECNotifyMaster.cpp \
39		SessionGroupData.cpp ECSessionGroupManager.cpp ECXPLogon.cpp ECXPProvider.cpp epclient.cpp \
40		Mem.cpp WSTransport.cpp \
41		ECPropertyEntry.cpp ECGenericProp.cpp ECParentStorage.cpp \
42		ECABProp.cpp ECABContainer.cpp ECDistList.cpp ECMailUser.cpp \
43		WSMAPIPropStorage.cpp WSMAPIFolderOps.cpp WSTableView.cpp \
44		WSABPropStorage.cpp WSUtil.cpp \
45		WSABTableView.cpp WSStoreTableView.cpp \
46		DLLGlobal.h ECABLogon.h ECABProvider.h ECAttach.h ECMAPIContainer.h \
47		ECMAPIFolder.h ECMAPIProp.h ECMAPITable.h ECMessage.h \
48		ECMsgStore.h ECMSProvider.h ECNamedProp.h ECNotifyClient.h SessionGroupData.h ECSessionGroupManager.h \
49		ECXPLogon.h ECXPProvider.h EntryPoint.h Mem.h resource.h WSTransport.h \
50		IECPropStorage.h ECPropertyEntry.h ECGenericProp.h ECParentStorage.h \
51		ECABProp.h ECABContainer.h ECDistList.h ECMailUser.h \
52		WSMAPIPropStorage.h WSMAPIFolderOps.h WSTableView.h \
53		WSABPropStorage.h ECNotifyMaster.h WSUtil.h \
54		WSABTableView.h WSStoreTableView.h \
55		ClientUtil.h ClientUtil.cpp \
56		ECExchangeModifyTable.cpp ECExchangeModifyTable.h \
57		ECExchangeExportChanges.cpp ECExchangeExportChanges.h \
58		ECExchangeImportContentsChanges.cpp ECExchangeImportContentsChanges.h \
59		ECExchangeImportHierarchyChanges.cpp ECExchangeImportHierarchyChanges.h \
60		ECICS.h \
61		ECMSProviderSwitch.cpp ECMSProviderSwitch.h ECMSProviderOffline.h ECMSProviderOffline.cpp \
62		ECABProviderSwitch.cpp ECABProviderSwitch.h ECABProviderOffline.h ECABProviderOffline.cpp \
63		ProviderUtil.h ProviderUtil.cpp \
64		ECExportAddressbookChanges.h ECExportAddressbookChanges.cpp \
65		ECMAPIFolderPublic.h ECMAPIFolderPublic.cpp \
66		ECMemTablePublic.h ECMemTablePublic.cpp \
67		ECMsgStorePublic.h ECMsgStorePublic.cpp \
68		ECChangeAdvisor.h ECChangeAdvisor.cpp \
69		ECDisplayTable.h ECDisplayTable.cpp \
70		ECArchiveAwareMsgStore.h ECArchiveAwareMsgStore.cpp \
71		ECArchiveAwareMessage.h ECArchiveAwareMessage.cpp \
72		ECArchiveAwareAttach.h ECArchiveAwareAttach.cpp \
73		WSMessageStreamExporter.h WSMessageStreamExporter.cpp \
74		WSSerializedMessage.h WSSerializedMessage.cpp \
75		WSMessageStreamImporter.h WSMessageStreamImporter.cpp \
76		ECMessageStreamImporterIStreamAdapter.h ECMessageStreamImporterIStreamAdapter.cpp
77
78		check-syntax:
79		$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \
80		-fsyntax-only -fmessage-length=0 ${CHK_SOURCES} -Wall -Wformat=2
81
82		include ../../global.am

+0

-51

provider/client/Mem.cpp less more

21	21	#include <kopano/Trace.h>
22	22	#include "Mem.h"
23	23
24		#ifdef _DEBUG
25		#define new DEBUG_NEW
26		#endif
27
28	24	// We don't want that here
29	25	#undef ECAllocateBuffer
30	26

33	29	LPALLOCATEMORE _pfnAllocMore;
34	30	LPFREEBUFFER _pfnFreeBuf;
35	31	HINSTANCE _hInstance;
36
37		LPALLOCATEBUFFER GetAllocateBuffer() { return _pfnAllocBuf; }
38		LPALLOCATEMORE GetAllocateMore() { return _pfnAllocMore; }
39		LPFREEBUFFER GetFreeBuffer() { return _pfnFreeBuf; }
40		HINSTANCE GetInstance() { return _hInstance; }
41		LPMALLOC GetMalloc(){ return _pmalloc; }
42	32
43	33	// This is the same as client-side MAPIFreeBuffer, but uses
44	34	// the linked memory routines passed in during MSProviderInit()

75	65	return MAPI_E_CALL_FAILED;
76	66	else return _pfnAllocMore(cbSize, lpBase, lpvoid);
77	67	}
78
79		// Use these functions for internal memory management
80
81		/* Use new() and delete() instead !
82		HRESULT HrAlloc(ULONG cbSize, void **lpvoid) {
83		if(_pmalloc == NULL)
84		return MAPI_E_CALL_FAILED;
85		else {
86		*lpvoid = _pmalloc->Alloc(cbSize);
87		if(*lpvoid == NULL)
88		return MAPI_E_NOT_ENOUGH_MEMORY;
89		else
90		return hrSuccess;
91		}
92		}
93
94		HRESULT HrRealloc(ULONG cbSize, void lpBase, void *lpvoid) {
95		if(_pmalloc == NULL)
96		return MAPI_E_CALL_FAILED;
97		else {
98		*lpvoid = _pmalloc->Realloc(lpBase, cbSize);
99		if(*lpvoid == NULL)
100		return MAPI_E_NOT_ENOUGH_MEMORY;
101		else
102		return hrSuccess;
103		}
104		}
105
106		HRESULT HrFree(void *lpvoid) {
107		if(lpvoid == NULL)
108		return MAPI_E_CALL_FAILED;
109
110		if(_pmalloc == NULL)
111		return MAPI_E_CALL_FAILED;
112		else {
113		_pmalloc->Free(lpvoid);
114		return hrSuccess;
115		}
116		}
117
118		*/
119	68
120	69	HRESULT AllocNewMapiObject(ULONG ulUniqueId, ULONG ulObjId, ULONG ulObjType, MAPIOBJECT **lppMapiObject)
121	70	{

+0

-19

provider/client/Mem.h less more

25	25	HRESULT ECAllocateBufferDbg(ULONG cbSize, void *lpvoid, char szFile, int line);
26	26	HRESULT ECAllocateMore(ULONG cbSize, void lpBase, void *lpvoid);
27	27
28		LPALLOCATEBUFFER GetAllocateBuffer();
29		LPALLOCATEMORE GetAllocateMore();
30		LPFREEBUFFER GetFreeBuffer();
31
32		HINSTANCE GetInstance();
33		LPMALLOC GetMalloc();
34
35		// Standard memory management
36		/* DEPRECATED - do not use
37		HRESULT HrAlloc(ULONG cbSize, void **lpvoid);
38		HRESULT HrRealloc(ULONG cbSize, void lpBase, void *lpvoid);
39		HRESULT HrFree(void lpvoid); /
40
41		// debug tracing
42		#ifdef _DEBUG
43		#define ECAllocateBuffer(cbSize, lpvoid) ECAllocateBufferDbg(cbSize, lpvoid, __FILE__, __LINE__)
44		#endif
45
46
47	28	HRESULT AllocNewMapiObject(ULONG ulUniqueId, ULONG ulObjId, ULONG ulObjType, MAPIOBJECT **lppMapiObject);
48	29	HRESULT FreeMapiObject(MAPIOBJECT *lpsObject);
49	30

+0

-34

provider/client/ProviderUtil.cpp less more

54	54
55	55	using namespace std;
56	56
57		#ifdef _DEBUG
58		#define new DEBUG_NEW
59		#endif
60
61
62	57	HRESULT CompareStoreIDs(ULONG cbEntryID1, LPENTRYID lpEntryID1, ULONG cbEntryID2, LPENTRYID lpEntryID2, ULONG ulFlags, ULONG *lpulResult)
63	58	{
64	59	HRESULT hr = hrSuccess;

110	105	return hr;
111	106	}
112	107
113		// Get MAPI unique guid, guaranteed by MAPI to be unique for all profiles.
114		HRESULT GetMAPIUniqueProfileId(LPMAPISUP lpMAPISup, tstring* lpstrUniqueId)
115		{
116		HRESULT hr = hrSuccess;
117		LPPROFSECT lpProfSect = NULL;
118		LPSPropValue lpsPropValue = NULL;
119
120		hr = lpMAPISup->OpenProfileSection((LPMAPIUID)&MUID_PROFILE_INSTANCE, 0, &lpProfSect);
121		if(hr != hrSuccess)
122		goto exit;
123
124		hr = HrGetOneProp(lpProfSect, PR_SEARCH_KEY, &lpsPropValue);
125		if(hr != hrSuccess)
126		goto exit;
127
128		*lpstrUniqueId = bin2hext(lpsPropValue->Value.bin.cb, lpsPropValue->Value.bin.lpb);
129		exit:
130		MAPIFreeBuffer(lpsPropValue);
131		if(lpProfSect)
132		lpProfSect->Release();
133
134		return hr;
135		}
136
137	108	HRESULT RemoveAllProviders(ECMapProvider* lpmapProvider)
138	109	{
139	110	ECMapProvider::const_iterator iterProvider;

154	125
155	126	HRESULT SetProviderMode(IMAPISupport lpMAPISup, ECMapProvider lpmapProvider, LPCSTR lpszProfileName, ULONG ulConnectType)
156	127	{
157		return hrSuccess;
158		}
159
160		HRESULT GetLastConnectionType(IMAPISupport lpMAPISup, ULONG lpulType) {
161		*lpulType = CT_ONLINE;
162	128	return hrSuccess;
163	129	}
164	130

+0

-2

provider/client/ProviderUtil.h less more

43	43	HRESULT RemoveAllProviders(ECMapProvider *lpmapProvider);
44	44	HRESULT SetProviderMode(IMAPISupport lpMAPISup, ECMapProvider lpmapProvider, LPCSTR lpszProfileName, ULONG ulConnectType);
45	45	HRESULT GetProviders(ECMapProvider lpmapProvider, IMAPISupport lpMAPISup, LPCSTR lpszProfileName, ULONG ulFlags, PROVIDER_INFO *lpsProviderInfo);
46		HRESULT GetLastConnectionType(IMAPISupport lpMAPISup, ULONG lpulType);
47	46
48		HRESULT GetMAPIUniqueProfileId(LPMAPISUP lpMAPISup, tstring *lpstrUniqueId);
49	47	HRESULT GetTransportToNamedServer(WSTransport lpTransport, LPCTSTR lpszServerName, ULONG ulFlags, WSTransport *lppTransport);
50	48
51	49	#endif // #ifndef PROVIDERUTIL_H

+18

-0

provider/client/README.md less more

	0	Kopano basic tech. information
	1	===============================
	2
	3	The Kopano Message store provider works with the following components (layered top-to-bottom):
	4
	5	Client side:
	6	- Full MAPI implementation to the client
	7	- Local client handling of data structures, formats, and anything needing caching or local processing
	8	- Abstract 'storage' classes for doing the actual transport of data to and from the server
	9	- Currently only the WS (WebService) Transport is implemented, using gSOAP for serialization
	10
	11	Network:
	12	- HTTP / SOAP network transport
	13
	14	Server side:
	15	- Server deserialisation and RPC with gSOAP (through either Apache or standalone server)
	16	- Storage layer for database communication
	17	- MySQL database storage

+0

-6

provider/client/SessionGroupData.cpp less more

24	24	#include "ECSessionGroupManager.h"
25	25	#include "SessionGroupData.h"
26	26	#include "WSTransport.h"
27
28		#ifdef _DEBUG
29		#define new DEBUG_NEW
30		#endif
31
32	27
33	28	SessionGroupData::SessionGroupData(ECSESSIONGROUPID ecSessionGroupId, ECSessionGroupInfo *lpInfo, const sGlobalProfileProps &sProfileProps)
34	29	{

71	66
72	67	return hr;
73	68	}
74
75	69
76	70	HRESULT SessionGroupData::GetOrCreateNotifyMaster(ECNotifyMaster **lppMaster)
77	71	{

+0

-4

provider/client/WSABPropStorage.cpp less more

20	20	#include "WSUtil.h"
21	21	#include <kopano/charset/convert.h>
22	22
23		#ifdef _DEBUG
24		#define new DEBUG_NEW
25		#endif
26
27	23	#define START_SOAP_CALL retry:
28	24	#define END_SOAP_CALL \
29	25	if(er == KCERR_END_OF_SESSION) { if(this->m_lpTransport->HrReLogon() == hrSuccess) goto retry; } \

+0

-4

provider/client/WSABTableView.cpp less more

29	29	#include "SOAPUtils.h"
30	30	#include "WSUtil.h"
31	31
32		#ifdef _DEBUG
33		#define new DEBUG_NEW
34		#endif
35
36	32	WSABTableView::WSABTableView(ULONG ulType, ULONG ulFlags, KCmd lpCmd, pthread_mutex_t lpDataLock, ECSESSIONID ecSessionId, ULONG cbEntryId, LPENTRYID lpEntryId, ECABLogon* lpABLogon, WSTransport *lpTransport) : WSTableView(ulType, ulFlags, lpCmd, lpDataLock, ecSessionId, cbEntryId, lpEntryId, lpTransport, "WSABTableView")
37	33	{
38	34	m_lpProvider = lpABLogon;

+0

-6

provider/client/WSMAPIFolderOps.cpp less more

26	26
27	27	#include <kopano/charset/utf8string.h>
28	28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32
33	29	#define START_SOAP_CALL retry:
34	30	#define END_SOAP_CALL \
35	31	if(er == KCERR_END_OF_SESSION) { if(m_lpTransport->HrReLogon() == hrSuccess) goto retry; } \

157	153	return hr;
158	154	}
159	155
160
161	156	HRESULT WSMAPIFolderOps::HrEmptyFolder(ULONG ulFlags, ULONG ulSyncId)
162	157	{
163	158	ECRESULT er = erSuccess;

251	246	exit:
252	247	UnLockSoap();
253	248
254
255	249	if(lpsRestrict)
256	250	FreeRestrictTable(lpsRestrict);
257	251

+0

-6

provider/client/WSMAPIPropStorage.cpp less more

22	22	#include "pcutil.hpp"
23	23	#include <kopano/charset/convert.h>
24	24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28
29	25	/*
30	26	*
31	27	* This is a PropStorage object for use with the WebServices storage platform

467	463	struct loadObjectResponse sResponse;
468	464	convert_context converter;
469	465
470
471	466	HrMapiObjectToSoapObject(lpsMapiObject, &sSaveObj, &converter);
472	467
473	468	LockSoap();

643	638	return &this->m_xECPropStorage; // I am the server storage
644	639	}
645	640
646
647	641	//FIXME: one lock/unlock function
648	642	HRESULT WSMAPIPropStorage::LockSoap()
649	643	{

+0

-4

provider/client/WSMessageStreamExporter.cpp less more

20	20	#include "WSTransport.h"
21	21	#include <kopano/charset/convert.h>
22	22	#include "WSUtil.h"
23
24		#ifdef _DEBUG
25		#define new DEBUG_NEW
26		#endif
27	23
28	24	/**
29	25	* Create a WSMessageStreamExporter instance.

+0

-7

provider/client/WSMessageStreamImporter.cpp less more

18	18	#include "WSMessageStreamImporter.h"
19	19	#include "WSUtil.h"
20	20	#include "ECSyncSettings.h"
21
22		#ifdef _DEBUG
23		#define new DEBUG_NEW
24		#endif
25
26		// WSMessageStreamSink Implementation
27	21
28	22	/**
29	23	* Create a new WSMessageStreamSink instance

79	73	}
80	74
81	75	/**
82		* Constructor
83	76	* @param[in] lpFifoBuffer The fifobuffer to write the data into.
84	77	*/
85	78	WSMessageStreamSink::WSMessageStreamSink(ECFifoBuffer lpFifoBuffer, ULONG ulTimeout, WSMessageStreamImporter lpImporter)

+0

-8

provider/client/WSSerializedMessage.cpp less more

17	17	#include <kopano/platform.h>
18	18	#include "WSSerializedMessage.h"
19	19
20		#ifdef _DEBUG
21		#define new DEBUG_NEW
22		#endif
23
24	20	/**
25		* Constructor
26	21	* @param[in] lpSoap The gSoap object from which the MTOM attachments must be obtained.
27	22	* @param[in] strStreamId The expected stream id. Used to validate the MTOM attachment obtained from gSoap.
28	23	* @param[in] cbProps The amount of properties returned from the original soap call.

103	98	return m_hr;
104	99	}
105	100
106
107
108
109	101	void* WSSerializedMessage::StaticMTOMWriteOpen(struct soap soap, void handle, const char id, const char type, const char *description, enum soap_mime_encoding encoding)
110	102	{
111	103	WSSerializedMessage lpMessage = reinterpret_cast<WSSerializedMessage>(handle);

+0

-6

provider/client/WSStoreTableView.cpp less more

20	20	#include "SOAPUtils.h"
21	21	#include "WSUtil.h"
22	22
23		#ifdef _DEBUG
24		#define new DEBUG_NEW
25		#endif
26
27	23	WSStoreTableView::WSStoreTableView(ULONG ulType, ULONG ulFlags, KCmd lpCmd, pthread_mutex_t lpDataLock, ECSESSIONID ecSessionId, ULONG cbEntryId, LPENTRYID lpEntryId, ECMsgStore lpMsgStore, WSTransport lpTransport) : WSTableView(ulType, ulFlags, lpCmd, lpDataLock, ecSessionId, cbEntryId, lpEntryId, lpTransport, "WSStoreTableView")
28	24	{
29	25

126	122	return hr;
127	123	}
128	124
129
130	125	HRESULT WSTableMultiStore::HrSetEntryIDs(LPENTRYLIST lpMsgList)
131	126	{
132	127	// Not really a transport function, but this is the best place for it for now
133	128
134	129	return CopyMAPIEntryListToSOAPEntryList(lpMsgList, &m_sEntryList);
135	130	}
136
137	131
138	132	/*
139	133	Miscellaneous tables are not really store tables, but the is the same, so it inherits from the store table

+0

-6

provider/client/WSTableView.cpp less more

20	20	#include "WSUtil.h"
21	21	#include <kopano/charset/convert.h>
22	22
23		#ifdef _DEBUG
24		#define new DEBUG_NEW
25		#endif
26
27	23	/*
28	24	* TableView operations for WS transport
29	25	*/

130	126	return hr;
131	127	}
132	128
133
134	129	HRESULT WSTableView::HrSetColumns(LPSPropTagArray lpsPropTagArray)
135	130	{
136	131	ECRESULT er = erSuccess;

307	302
308	303	return hr;
309	304	}
310
311	305
312	306	HRESULT WSTableView::HrGetRowCount(ULONG lpulRowCount, ULONG lpulCurrentRow)
313	307	{

+0

-39

provider/client/WSTransport.cpp less more

58	58	#include "WSMessageStreamImporter.h"
59	59
60	60	using namespace std;
61
62		#ifdef _DEBUG
63		#define new DEBUG_NEW
64		#endif
65
66	61
67	62	/*
68	63	*

334	329	if (sResponse.sServerGuid.__ptr != NULL && sResponse.sServerGuid.__size == sizeof(m_sServerGuid))
335	330	memcpy(&m_sServerGuid, sResponse.sServerGuid.__ptr, sizeof(m_sServerGuid));
336	331
337
338	332	// From here the login is ok
339	333
340	334	auth: // User have a logon

395	389	this->m_lpCmd->soap->recv_timeout = ulSeconds;
396	390	return hrSuccess;
397	391	}
398
399	392
400	393	HRESULT WSTransport::CreateAndLogonAlternate(LPCSTR szServer, WSTransport **lppTransport) const
401	394	{

709	702	}
710	703	END_SOAP_CALL
711	704
712
713	705	exit:
714	706	UnLockSoap();
715	707

775	767	LPENTRYID lpUnWrapEntryID = NULL;
776	768	ULONG cbUnWrapEntryID = 0;
777	769
778
779	770	if (lpParentEntryID) {
780	771	hr = UnWrapServerClientStoreEntry(cbParentEntryID, lpParentEntryID, &cbUnWrapParentID, &lpUnWrapParentID);
781	772	if(hr != hrSuccess)

830	821
831	822	LPENTRYID lpUnWrapStoreID = NULL;
832	823	ULONG cbUnWrapStoreID = 0;
833
834	824
835	825	hr = UnWrapServerClientABEntry(cbEntryID, lpEntryID, &cbUnWrapStoreID, &lpUnWrapStoreID);
836	826	if(hr != hrSuccess)

954	944	if(hr != hrSuccess)
955	945	goto exit;
956	946
957
958	947	START_SOAP_CALL
959	948	{
960	949	if(SOAP_OK != m_lpCmd->ns__deleteObjects(m_ecSessionId, ulFlags, &sEntryList, ulSyncId, &er))
961	950	er = KCERR_NETWORK_ERROR;
962	951	}
963	952	END_SOAP_CALL
964
965	953
966	954	exit:
967	955	UnLockSoap();

1111	1099
1112	1100	}
1113	1101	END_SOAP_CALL
1114
1115	1102
1116	1103	exit:
1117	1104	MAPIFreeBuffer(notSubscribeArray.__ptr);

1415	1402	sEntryId.__ptr = (unsigned char*)lpUnWrapStoreID;
1416	1403	sEntryId.__size = cbUnWrapStoreID;
1417	1404
1418
1419
1420	1405	// Get ReceiveFolder information from the server
1421	1406	START_SOAP_CALL
1422	1407	{

1508	1493	if(lpstrExplicitClass)
1509	1494	lpstrExplicitClass->clear();
1510	1495
1511
1512	1496	// Get ReceiveFolder information from the server
1513	1497	START_SOAP_CALL
1514	1498	{

1575	1559	sStoreId.__ptr = (unsigned char*)lpUnWrapStoreID;
1576	1560	sStoreId.__size = cbUnWrapStoreID;
1577	1561
1578
1579	1562	// Ignore error
1580	1563	CopyMAPIEntryIdToSOAPEntryId(cbEntryID, lpEntryID, &sEntryId, true);
1581
1582	1564
1583	1565	START_SOAP_CALL
1584	1566	{

1785	1767	hr = MAPI_E_INVALID_PARAMETER;
1786	1768	goto exit;
1787	1769	}
1788
1789	1770
1790	1771	START_SOAP_CALL
1791	1772	{

1873	1854
1874	1855	return hr;
1875	1856	}
1876
1877	1857
1878	1858	/**
1879	1859	* Create a new user.

2049	2029
2050	2030	}
2051	2031	END_SOAP_CALL
2052
2053	2032
2054	2033	exit:
2055	2034	UnLockSoap();

2278	2257	goto exit;
2279	2258	}
2280	2259
2281
2282	2260	*lpcUsers = 0;
2283	2261
2284	2262	START_SOAP_CALL

2642	2620	er = KCERR_NETWORK_ERROR;
2643	2621	}
2644	2622	END_SOAP_CALL
2645
2646	2623
2647	2624	hr = CopyUserClientUpdateStatusFromSOAP(sResponse, ulFlags, lppECUCUS);
2648	2625	if (hr != hrSuccess)

4146	4123	}
4147	4124	pthread_mutex_unlock(&m_ResolveResultCacheMutex);
4148	4125
4149
4150	4126	// Cache failed. Try the server
4151	4127	LockSoap();
4152	4128

4203	4179	hr = SvrNameListToSoapMvString8(lpServerNameList, ulFlags & MAPI_UNICODE, &lpsSvrNameList);
4204	4180	if (hr != hrSuccess)
4205	4181	goto exit;
4206
4207	4182
4208	4183	START_SOAP_CALL
4209	4184	{

4435	4410	HRESULT hr = hrSuccess;
4436	4411	WSTableMultiStore *lpMultiStoreTable = NULL;
4437	4412
4438
4439	4413	if (!lpMsgList \|\| lpMsgList->cValues == 0) {
4440	4414	hr = MAPI_E_INVALID_PARAMETER;
4441	4415	goto exit;
4442	4416	}
4443
4444	4417
4445	4418	hr = WSTableMultiStore::Create(ulFlags, m_lpCmd, &m_hDataLock, m_ecSessionId, cbEntryID, lpEntryID, lpMsgStore, this, &lpMultiStoreTable);
4446	4419	if (hr != hrSuccess)

4458	4431
4459	4432	return hr;
4460	4433	}
4461
4462	4434
4463	4435	HRESULT WSTransport::HrOpenMiscTable(ULONG ulTableType, ULONG ulFlags, ULONG cbEntryID, LPENTRYID lpEntryID, ECMsgStore lpMsgStore, WSTableView *lppTableView)
4464	4436	{

4508	4480	/* else: er is already set and good to use */
4509	4481	}
4510	4482	END_SOAP_CALL
4511
4512	4483
4513	4484	exit:
4514	4485	UnLockSoap();

4615	4586	er = sResponse.er;
4616	4587	}
4617	4588	END_SOAP_CALL
4618
4619	4589
4620	4590	*lpulUsers = sResponse.ulUsers;
4621	4591

4861	4831	{
4862	4832	if (!m_strAppName.empty())
4863	4833	return m_strAppName;
4864		#ifdef LINUX
4865	4834	std::string procpath = "/proc/" + stringify(getpid()) + "/cmdline";
4866	4835	std::string s;
4867	4836

4871	4840	m_strAppName = "<unknown>";
4872	4841	else
4873	4842	m_strAppName = basename((char *)s.c_str());
4874		#else
4875		char s[1024];
4876		GetModuleFileNameA(0, s, sizeof(s));
4877
4878		s[sizeof(s)-1] = 0;
4879
4880		m_strAppName = basename(s);
4881		#endif
4882	4843	return m_strAppName;
4883	4844	}
4884	4845

+0

-11

provider/client/WSUtil.cpp less more

15	15	*/
16	16
17	17	#include <kopano/platform.h>
18		#ifdef LINUX
19	18	#include <sys/un.h>
20		#endif
21	19	#include "WSUtil.h"
22	20	#include <kopano/ECIConv.h>
23	21	#include <kopano/ECGuid.h>

48	46	#include "SOAPSock.h"
49	47
50	48	using namespace std;
51
52		#ifdef _DEBUG
53		#define new DEBUG_NEW
54		#endif
55
56	49
57	50	#define CONVERT_TO(_context, _charset, ...) ((_context) ? (_context)->convert_to<_charset>(__VA_ARGS__) : convert_to<_charset>(__VA_ARGS__))
58	51

1541	1534	convert_context converter;
1542	1535	ULONG ulConvFlags;
1543	1536
1544
1545	1537	if (lpPropmap && lpPropmap->cEntries) {
1546	1538	hr = ECAllocateBuffer(sizeof soapPropmap, (void*)&soapPropmap);
1547	1539	if (hr != hrSuccess)

2223	2215	CopySOAPEntryIdToMAPIEntryId(lpSrc->newmail->pParentId, &lpNotification->info.newmail.cbParentID, &lpNotification->info.newmail.lpParentID, (void **)lpNotification);
2224	2216	}
2225	2217
2226
2227	2218	if(lpSrc->newmail->lpszMessageClass != NULL) {
2228	2219	nLen = strlen(lpSrc->newmail->lpszMessageClass)+1;
2229	2220	ECAllocateMore(nLen, lpNotification, (void**)&lpNotification->info.newmail.lpszMessageClass);

2281	2272	if(lpSrc->tab->propPrior.Value.bin){
2282	2273	lpNotification->info.tab.propPrior.Value.bin.cb = lpSrc->tab->propPrior.Value.bin->__size;
2283	2274	ECAllocateMore(lpNotification->info.tab.propPrior.Value.bin.cb, lpNotification, (void**)&lpNotification->info.tab.propPrior.Value.bin.lpb);
2284
2285	2275
2286	2276	memcpy(lpNotification->info.tab.propPrior.Value.bin.lpb, lpSrc->tab->propPrior.Value.bin->__ptr, lpSrc->tab->propPrior.Value.bin->__size);
2287	2277	}

2442	2432
2443	2433	if (hr != hrSuccess)
2444	2434	goto exit;
2445
2446	2435
2447	2436	*lppECUCUS = lpECUCUS;
2448	2437	lpECUCUS = NULL;

+0

-9

provider/client/WSUtil.h less more

68	68
69	69	HRESULT SvrNameListToSoapMvString8(ECSVRNAMELIST lpSvrNameList, ULONG ulFLags, struct mv_string8 *lppsSvrNameList);
70	70	HRESULT SoapServerListToServerList(const struct serverList lpsServerList, ULONG ulFLags, ECSERVERLIST *lppServerList);
71
72		#ifdef LINUX
73	71	int gsoap_connect_unixsocket(struct soap soap, const char endpoint, const char *host, int port);
74		#else
75		int gsoap_win_fsend(struct soap soap, const char s, size_t n);
76		size_t gsoap_win_frecv(struct soap soap, char s, size_t n);
77		int gsoap_win_fclose(struct soap *soap);
78		int gsoap_connect_namedpipe(struct soap soap, const char endpoint, const char *host, int port);
79		#endif
80
81	72	HRESULT CreateSoapTransport(ULONG ulUIFlags, const sGlobalProfileProps &sProfileProps, KCmd **const lppCmd);
82	73
83	74	HRESULT WrapServerClientStoreEntry(const char* lpszServerName, entryId* lpsStoreId, ULONG* lpcbStoreID, LPENTRYID* lppStoreID);

+1

-15

provider/client/epclient.cpp less more

34	34	#include "ECMSProviderSwitch.h"
35	35	#include "ECXPProvider.h"
36	36	#include "ECABProviderSwitch.h"
37		#ifdef LINUX
38	37	#include <iostream>
39		#endif
40
41	38	#include <kopano/ecversion.h>
42	39
43	40	#include <kopano/ECDebug.h>

60	57	#include <kopano/charset/convstring.h>
61	58
62	59	using namespace std;
63
64		#ifdef _DEBUG
65		#define new DEBUG_NEW
66
67		#define DEBUG_WITH_MEMORY_DUMP 0 // Sure to dump memleaks before the dll is exit
68		#endif
69	60
70	61	class EPCDeleter {
71	62	public:

174	165	*
175	166	* @param lpProviderAdmin[in] The ProviderAdmin object passed to MSGServiceEntry
176	167	* @param lpServiceName[out] The name of the message service
177		* @return HRESULT Result status
178	168	*/
179	169	static HRESULT GetServiceName(IProviderAdmin *lpProviderAdmin,
180	170	std::string *lpServiceName)

441	431	d.provadm = lpAdminProvider;
442	432	d.profsect = lpProfSect;
443	433	d.count = d.eid_size = 0;
	434	d.transport = NULL;
444	435
445	436	if (d.provadm != NULL) {
446	437	hr = GetServiceName(d.provadm, &strServiceName);

862	853	}
863	854	break;
864	855	} // switch(ulContext)
865
866	856
867	857	exit:
868	858	if (lppMapiError) {

925	915	return hr;
926	916	}
927	917
928
929	918	extern "C" HRESULT __cdecl XPProviderInit(HINSTANCE hInstance, LPMALLOC lpMalloc, LPALLOCATEBUFFER lpAllocateBuffer, LPALLOCATEMORE lpAllocateMore, LPFREEBUFFER lpFreeBuffer, ULONG ulFlags, ULONG ulMAPIVer, ULONG * lpulProviderVer, LPXPPROVIDER * lppXPProvider)
930	919	{
931	920	TRACE_MAPI(TRACE_ENTRY, "XPProviderInit", "");

958	947	if(pXPProvider)
959	948	pXPProvider->Release();
960	949
961
962	950	return hr;
963	951	}
964
965	952
966	953	extern "C" HRESULT __cdecl ABProviderInit(HINSTANCE hInstance, LPMALLOC lpMalloc, LPALLOCATEBUFFER lpAllocateBuffer, LPALLOCATEMORE lpAllocateMore, LPFREEBUFFER lpFreeBuffer, ULONG ulFlags, ULONG ulMAPIVer, ULONG * lpulProviderVer, LPABPROVIDER * lppABProvider)
967	954	{

994	981	if(lpABProvider)
995	982	lpABProvider->Release();
996	983
997
998	984	return hr;
999	985	}

+3

-11

provider/common/ECLicenseClient.cpp less more

18	18
19	19	#include <string>
20	20	#include <vector>
21
22		#ifdef LINUX
	21	#include <cstdlib>
23	22	#include <sys/un.h>
24	23	#include <sys/socket.h>
25		#endif
26
27	24	#include <kopano/ECDefs.h>
28	25	#include <kopano/ECChannel.h>
29	26	#include <kopano/base64.h>

128	125	} LICENSERESPONSE;
129	126
130	127	ECRESULT ECLicenseClient::Auth(const unsigned char *lpData,
131		unsigned int ulSize, unsigned char **lppResponse,
132		unsigned int *lpulResponseSize)
	128	unsigned int ulSize, void *lppResponse, unsigned int lpulResponseSize)
133	129	{
134		LICENSERESPONSE *lpResponse = new LICENSERESPONSE;
135		memset(lpResponse, 0, sizeof(LICENSERESPONSE));
136
137		lppResponse = (unsigned char )lpResponse;
	130	*lppResponse = calloc(1, sizeof(LICENSERESPONSE));
138	131	*lpulResponseSize = sizeof(LICENSERESPONSE);
139
140	132	return erSuccess;
141	133	}
142	134

+1

-1

provider/common/ECLicenseClient.h less more

32	32	ECRESULT QueryCapability(unsigned int ulServiceType, const std::string &strCapability, bool *lpbResult);
33	33	ECRESULT GetSerial(unsigned int ulServiceType, std::string &lpstrSerial, std::vector<std::string> &lstCALs);
34	34	ECRESULT GetInfo(unsigned int ulServiceType, unsigned int *lpulUserCount);
35		ECRESULT Auth(const unsigned char lpData, unsigned int ulSize, unsigned char lpResponse, unsigned int lpulResponseSize);
	35	ECRESULT Auth(const unsigned char lpData, unsigned int ulSize, void ret, unsigned int retsize);
36	36	ECRESULT SetSerial(unsigned int ulServiceType, const std::string &strSerial, const std::vector<std::string> &lstCALs);
37	37
38	38	private:

+0

-4

provider/common/ECSearchClient.cpp less more

15	15	*/
16	16
17	17	#include <kopano/platform.h>
18
19		#ifdef LINUX
20	18	#include <sys/un.h>
21	19	#include <sys/socket.h>
22		#endif
23
24	20	#include <kopano/base64.h>
25	21	#include <kopano/ECChannel.h>
26	22	#include <kopano/ECDefs.h>

+0

-36

~~provider/common/Makefile.am~~ less more

0		# -- Makefile --
1
2		AM_CPPFLAGS = ${ZCPPFLAGS} ${DEBUGFLAGS} ${GSOAP_CFLAGS} \
3		${BOOST_CPPFLAGS} \
4		-I${top_srcdir}/mapi4linux/include -I${top_srcdir}/provider/include \
5		-I${top_builddir}/provider/soap -I${top_srcdir}/provider/soap \
6		-I${top_srcdir}/common -I${top_srcdir}/m4lcommon
7
8		pkginclude_HEADERS = include/kopano/pcuser.hpp
9
10		noinst_LTLIBRARIES = libkccommon.la
11		#noinst_DATA = libkccommon.ldd
12
13		libkccommon_la_SOURCES = SOAPUtils.cpp SOAPUtils.h \
14		SOAPAlloc.h \
15		SOAPHelpers.cpp SOAPHelpers.h \
16		SOAPDebug.cpp SOAPDebug.h \
17		SOAPSock.cpp SOAPSock.h \
18		pcutil.cpp pcutil.hpp \
19		pcuser.cpp \
20		ECLicenseClient.h ECLicenseClient.cpp \
21		ECSearchClient.h ECSearchClient.cpp \
22		soapctor.cpp
23		libkccommon_la_LIBADD = \
24		../../common/libkcutil.la ../../common/libkcmapi.la \
25		../soap/libkcsoapclient.la ../../common/libkcssl.la \
26		${GSOAP_LIBS} ${SSL_LIBS}
27		libkccommon_la_LDFLAGS = ${AM_LDFLAGS} \
28		-Wl,--version-script=${top_builddir}/default.sym
29		EXTRA_libkccommon_la_DEPENDENCIES = ${top_builddir}/default.sym
30
31		check-syntax:
32		$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \
33		-fsyntax-only -fmessage-length=0 ${CHK_SOURCES} -Wall -Wformat=2
34
35		include ../../global.am

+0

-4

provider/common/SOAPDebug.cpp less more

24	24	#include <kopano/stringutil.h>
25	25
26	26	using namespace std;
27
28		#ifdef _DEBUG
29		#define new DEBUG_NEW
30		#endif
31	27
32	28	std::string RestrictionToString(const restrictTable *lpRestriction,
33	29	unsigned int indent)

+0

-4

provider/common/SOAPHelpers.cpp less more

15	15	*/
16	16
17	17	#include "SOAPHelpers.h"
18
19		#ifdef _DEBUG
20		#define new DEBUG_NEW
21		#endif
22	18
23	19	void mime_file_read_open(struct soap soap, void handle, const char id, const char type, const char description)
24	20	{

+2

-157

provider/common/SOAPSock.cpp less more

16	16
17	17	#include <kopano/platform.h>
18	18	#include "SOAPSock.h"
19
20		#ifdef LINUX
21	19	#include <sys/un.h>
22		#endif
23
24	20	#include "SOAPUtils.h"
	21	#include <kopano/stringutil.h>
25	22	#include <kopano/threadutil.h>
26	23	#include <kopano/CommonUtil.h>
27	24	#include <string>

58	55	return soap->fposthdr(soap, NULL, NULL);
59	56	}
60	57
61		#ifdef LINUX
62
63	58	// This function wraps the GSOAP fopen call to support "file:///var/run/socket" unix-socket URI's
64	59	static int gsoap_connect_pipe(struct soap soap, const char endpoint,
65	60	const char *host, int port)

88	83	// >= because there also needs to be room for the 0x00
89	84	if (strlen(socket_name) >= sizeof(saddr.sun_path))
90	85	return SOAP_EOF;
91
92		strncpy(saddr.sun_path, socket_name, sizeof(saddr.sun_path));
93
	86	kc_strlcpy(saddr.sun_path, socket_name, sizeof(saddr.sun_path));
94	87	connect(fd, (struct sockaddr *)&saddr, sizeof(struct sockaddr_un));
95	88
96	89	soap->sendfd = soap->recvfd = SOAP_INVALID_SOCKET;

106	99
107	100	return SOAP_OK;
108	101	}
109		#else
110		/* In windows, we support file: URI's with named pipes (ie file://\\server\pipe\kopano)
111		* Unfortunately, we can't use the standard fsend/frecv call with this, because gsoap
112		* uses winsock-style SOCKET handles for send and recv, so we also have to supply
113		* fsend,frecv, etc to use HANDLE-type connections
114		*/
115
116		int gsoap_win_fsend(struct soap soap, const char s, size_t n)
117		{
118		int rc = SOAP_ERR;
119		DWORD ulWritten;
120		OVERLAPPED op = {0};
121
122		op.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); // Will this ever fail?
123
124		if (WriteFile((HANDLE)soap->socket, s, n, &ulWritten, &op) == TRUE)
125		rc = SOAP_OK;
126
127		else if (GetLastError() == ERROR_IO_PENDING) {
128		if (WaitForSingleObject(op.hEvent, 70*1000) == WAIT_OBJECT_0) {
129		// We would normaly reset the event here, but we're not reusing it anyway.
130		if (GetOverlappedResult((HANDLE)soap->socket, &op, &ulWritten, TRUE) == TRUE)
131		rc = SOAP_OK;
132		} else
133		CancelIo((HANDLE)soap->socket);
134		}
135
136		CloseHandle(op.hEvent);
137		return rc;
138		}
139
140		size_t gsoap_win_frecv(struct soap soap, char s, size_t n)
141		{
142		size_t rc = 0;
143		DWORD ulRead;
144		OVERLAPPED op = {0};
145
146		op.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); // Will this ever fail?
147
148		if (ReadFile((HANDLE)soap->socket, s, n, &ulRead, &op) == TRUE)
149		rc = ulRead;
150
151		else if (GetLastError() == ERROR_IO_PENDING) {
152		if (WaitForSingleObject(op.hEvent, 70*1000) == WAIT_OBJECT_0) {
153		// We would normaly reset the event here, but we're not reusing it anyway.
154		if (GetOverlappedResult((HANDLE)soap->socket, &op, &ulRead, TRUE) == TRUE)
155		rc = ulRead;
156		} else
157		CancelIo((HANDLE)soap->socket);
158		}
159
160		CloseHandle(op.hEvent);
161		return rc;
162		}
163
164		int gsoap_win_fclose(struct soap *soap)
165		{
166		if((HANDLE)soap->socket == INVALID_HANDLE_VALUE)
167		return SOAP_OK;
168
169		CloseHandle((HANDLE)soap->socket); // Ignore error
170		soap->socket = (int)INVALID_HANDLE_VALUE;
171
172		return SOAP_OK;
173		}
174
175		int gsoap_win_fpoll(struct soap *soap)
176		{
177		// Always a connection
178		return SOAP_OK;
179		}
180
181		// Override the soap function shutdown
182		// disable read/write actions
183		static int gsoap_win_shutdownsocket(struct soap *soap, SOAP_SOCKET fd, int how)
184		{
185		// Normaly gsoap called shutdown, but the function isn't
186		// exist for named pipes, so return;
187		return SOAP_OK;
188		}
189
190		int gsoap_connect_pipe(struct soap soap, const char endpoint, const char *host, int port)
191		{
192		HANDLE hSocket = INVALID_HANDLE_VALUE;
193
194		#ifdef UNDER_CE
195		WCHAR x[1024];
196		#endif
197		// Check whether it is already a validated socket.
198		if ((HANDLE)soap->socket != INVALID_HANDLE_VALUE) // if (soap_valid_socket(soap->socket))
199		return SOAP_OK;
200
201		if (strncmp(endpoint, "file:", 5) \|\| strlen(endpoint) < 7)
202		return SOAP_EOF;
203
204		#ifdef UNDER_CE
205		MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,endpoint+5+2,strlen(endpoint+5+2),x,1024);
206		#endif
207
208		for (int nRetry = 0; nRetry < 10; ++nRetry) {
209		#ifdef UNDER_CE
210		hSocket = CreateFileW(x, GENERIC_READ\|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
211		#else
212		hSocket = CreateFileA(endpoint+5+2, GENERIC_READ\|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
213		#endif
214		if (hSocket == INVALID_HANDLE_VALUE) {
215		if (GetLastError() != ERROR_PIPE_BUSY) {
216		return SOAP_EOF; // Could not open pipe
217		}
218
219		// All pipe instances are busy, so wait for 1 second.
220		if (!WaitNamedPipeA(endpoint+5+2, 1000)) {
221		if (GetLastError() != ERROR_PIPE_BUSY) {
222		return SOAP_EOF; // Could not open pipe
223		}
224		}
225		} else {
226		break;
227		}
228		}// for (...)
229
230		if (hSocket == INVALID_HANDLE_VALUE)
231		return SOAP_EOF;
232
233		#ifdef UNDER_CE
234		soap->sendfd = soap->recvfd = NULL;
235		#else
236		soap->sendfd = soap->recvfd = SOAP_INVALID_SOCKET;
237		#endif
238
239		soap->max_keep_alive = 0;
240		soap->socket = (int)hSocket;
241		soap->status = SOAP_POST;
242
243		//Override soap functions
244		soap->fpoll = gsoap_win_fpoll;
245		soap->fsend = gsoap_win_fsend;
246		soap->frecv = gsoap_win_frecv;
247		soap->fclose = gsoap_win_fclose;
248		soap->fshutdownsocket = gsoap_win_shutdownsocket;
249
250		// Unused
251		soap->faccept = NULL;
252		soap->fopen = NULL;
253
254		return SOAP_OK;
255		}
256		#endif
257	102
258	103	HRESULT CreateSoapTransport(ULONG ulUIFlags,
259	104	const char *strServerPath,

+2

-23

provider/common/SOAPUtils.cpp less more

15	15	*/
16	16
17	17	#include <kopano/platform.h>
18
	18	#include <cstring>
19	19	#include <mapidefs.h>
20	20	#include <mapitags.h>
21	21	#include <edkmdb.h>

29	29	#include <kopano/base64.h>
30	30
31	31	using namespace std;
32
33		#ifdef _DEBUG
34		#define new DEBUG_NEW
35		#endif
36	32
37	33	/* See m4lcommon/Util.cpp for twcmp */
38	34	template<typename T> static int twcmp(T a, T b)

659	655	*lpCompareResult = nCompareResult;
660	656	return er;
661	657	}
662
663	658
664	659	/**
665	660	* ulType is one of the RELOP_xx types. The result returned will indicate that at least one of the values in lpMVProp positively

1233	1228	return erSuccess;
1234	1229	}
1235	1230
1236
1237	1231	ECRESULT CopyRestrictTable(struct soap *soap,
1238	1232	const struct restrictTable lpSrc, struct restrictTable *lppDst)
1239	1233	{

1442	1436	lpDst->__ptr[i].__ptr = s_alloc<unsigned char>(soap, lpSrc->__ptr[i].__size);
1443	1437	memcpy(lpDst->__ptr[i].__ptr, lpSrc->__ptr[i].__ptr, sizeof(unsigned char) * lpSrc->__ptr[i].__size);
1444	1438	}
1445
1446	1439
1447	1440	*lppDst = lpDst;
1448	1441	return erSuccess;

1758	1751	return KCERR_NOT_FOUND;
1759	1752
1760	1753	lpDst = new searchCriteria;
	1754	memset(lpDst, '\0', sizeof(*lpDst));
1761	1755	if(lpSrc->lpRestrict) {
1762	1756	er = CopyRestrictTable(soap, lpSrc->lpRestrict, &lpDst->lpRestrict);
1763	1757	if (er != erSuccess)

1799	1793
1800	1794	return er;
1801	1795	}
1802
1803		ECRESULT CopyUserObjectDetailsToSoap(unsigned int ulId, entryId lpUserEid, const objectdetails_t &details, struct soap soap, struct userobject *lpObject)
1804		{
1805		ECRESULT er = erSuccess;
1806
1807		lpObject->ulId = ulId;
1808		lpObject->lpszName = s_strcpy(soap, details.GetPropString(OB_PROP_S_FULLNAME).c_str());
1809		lpObject->ulType = details.GetClass();
1810		lpObject->sId.__size = lpUserEid->__size;
1811		lpObject->sId.__ptr = s_alloc<unsigned char>(soap, lpUserEid->__size);
1812		memcpy(lpObject->sId.__ptr, lpUserEid->__ptr, lpUserEid->__size);
1813
1814		return er;
1815		}
1816
1817	1796
1818	1797	/**
1819	1798	* Copy extra user details into propmap, (only the string values)

+0

-2

provider/common/SOAPUtils.h less more

84	84	ECRESULT CopyRightsArrayToSoap(struct soap soap, struct rightsArray lpRightsArraySrc, struct rightsArray **lppRightsArrayDst);
85	85
86	86	// userobjects
87		ECRESULT CopyUserObjectDetailsToSoap(unsigned int ulId, entryId *lpUserEid, const objectdetails_t &details,
88		struct soap soap, struct userobject lpObject);
89	87	ECRESULT CopyUserDetailsToSoap(unsigned int ulId, entryId *lpUserEid, const objectdetails_t &details, bool bCopyBinary,
90	88	struct soap soap, struct user lpUser);
91	89	ECRESULT CopyUserDetailsFromSoap(struct user lpUser, std::string lpstrExternId, objectdetails_t details, struct soap soap);

+1

-5

provider/common/pcuser.cpp less more

20	20	#include <kopano/pcuser.hpp>
21	21
22	22	#include <sstream>
23
24		#ifdef _DEBUG
25		#define new DEBUG_NEW
26		#endif
27	23
28	24	template<int(fnCmp)(const char, const char*)>
29	25	class StringComparer {

228	224	{
229	225	const std::list<std::string> list = GetPropListString(propname);
230	226	if (ignoreCase)
231		return std::find_if(list.begin(), list.end(), StringComparer<stricmp>(value)) != list.end();
	227	return std::find_if(list.begin(), list.end(), StringComparer<strcasecmp>(value)) != list.end();
232	228	return std::find_if(list.begin(), list.end(), StringComparer<strcmp>(value)) != list.end();
233	229	}
234	230

+0

-4

provider/common/pcutil.cpp less more

24	24	#include <mapidefs.h>
25	25	#include <kopano/ECGuid.h>
26	26	#include "versions.h"
27
28		#ifdef _DEBUG
29		#define new DEBUG_NEW
30		#endif
31	27
32	28	bool IsKopanoEntryId(ULONG cb, LPBYTE lpEntryId)
33	29	{

+0

-36

~~provider/contacts/Makefile.am~~ less more

0		# -- Makefile --
1
2		pkglib_LTLIBRARIES = libkccontacts.la
3		noinst_DATA = libkccontacts.ldd
4
5		sysconf_configdir = ${MAPICONFIGDIR}
6		dist_sysconf_config_DATA = zcontacts.inf
7
8		sampleconfdir = ${docdir}/example-config
9		sampleconf_DATA = zcontacts.inf
10
11		AM_CPPFLAGS = ${ZCPPFLAGS} $(DEBUGFLAGS) \
12		-I${top_srcdir}/provider/include \
13		-I${top_srcdir}/provider/common \
14		-I${top_srcdir}/provider/client \
15		-I${top_srcdir}/mapi4linux/include \
16		-I${top_srcdir}/common -I${top_srcdir}/m4lcommon
17
18		libkccontacts_la_LDFLAGS = ${AM_LDFLAGS} -avoid-version -module
19		libkccontacts_la_LIBADD = \
20		${top_builddir}/common/libkcutil.la \
21		${top_builddir}/common/libkcmapi.la \
22		${top_builddir}/mapi4linux/src/libmapi.la \
23		-lstdc++ $(UUID_LIBS) $(ICU_LIBS)
24
25		libkccontacts_la_SOURCES = epcontact.cpp ZCABData.h \
26		ZCMAPIProp.h ZCMAPIProp.cpp \
27		ZCABProvider.h ZCABProvider.cpp \
28		ZCABLogon.h ZCABLogon.cpp \
29		ZCABContainer.h ZCABContainer.cpp
30
31		check-syntax:
32		$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \
33		-fsyntax-only -fmessage-length=0 ${CHK_SOURCES} -Wall -Wformat=2
34
35		include ../../global.am

+3

-11

provider/contacts/ZCABContainer.cpp less more

38	38	#include <kopano/stringutil.h>
39	39	using namespace std;
40	40
41		#ifdef _DEBUG
42		#define new DEBUG_NEW
43		#endif
44
45	41	ZCABContainer::ZCABContainer(std::vector<zcabFolderEntry> *lpFolders,
46	42	IMAPIFolder lpContacts, LPMAPISUP lpMAPISup, void lpProvider,
47	43	const char *szClassName) :

269	265	{(LPGUID)&PSETID_Address, MNID_ID, {dispidABPArrayType}},
270	266	};
271	267
272
273	268	ulFlags = ulFlags & MAPI_UNICODE;
274	269
275	270	hr = Util::HrCopyUnicodePropTagArray(ulFlags, (LPSPropTagArray)&inputCols, &ptrInputCols);

381	376
382	377	if (
383	378	((ulFlags & MAPI_UNICODE) && wcscasecmp(ptrRows[i].lpProps[I_MESSAGE_CLASS].Value.lpszW, L"IPM.Contact") == 0) \|\|
384		((ulFlags & MAPI_UNICODE) == 0 && stricmp(ptrRows[i].lpProps[I_MESSAGE_CLASS].Value.lpszA, "IPM.Contact") == 0)
	379	((ulFlags & MAPI_UNICODE) == 0 && strcasecmp(ptrRows[i].lpProps[I_MESSAGE_CLASS].Value.lpszA, "IPM.Contact") == 0)
385	380	)
386	381	{
387	382	lpColData[O_DISPLAY_TYPE].ulPropTag = PR_DISPLAY_TYPE;

394	389	lpColData[O_ADDRTYPE].Value = ptrRows[i].lpProps[I_NAMEDSTART + ulOffset + 1].Value;
395	390	} else if (
396	391	((ulFlags & MAPI_UNICODE) && wcscasecmp(ptrRows[i].lpProps[I_MESSAGE_CLASS].Value.lpszW, L"IPM.DistList") == 0) \|\|
397		((ulFlags & MAPI_UNICODE) == 0 && stricmp(ptrRows[i].lpProps[I_MESSAGE_CLASS].Value.lpszA, "IPM.DistList") == 0)
	392	((ulFlags & MAPI_UNICODE) == 0 && strcasecmp(ptrRows[i].lpProps[I_MESSAGE_CLASS].Value.lpszA, "IPM.DistList") == 0)
398	393	)
399	394	{
400	395	lpColData[O_DISPLAY_TYPE].ulPropTag = PR_DISPLAY_TYPE;

547	542	if (hr != hrSuccess)
548	543	goto exit;
549	544
550
551	545	sKey.ulPropTag = PR_ROWID;
552	546	sKey.Value.ul = 0;
553	547	for (ULONG i = 0; i < ptrEntries->Value.MVbin.cValues; ++i) {

557	551	// Wrapped entryid's:
558	552	// Flags: (ULONG) 0
559	553	// Provider: (GUID) 0xC091ADD3519DCF11A4A900AA0047FAA4
560		// Type: (BYTE) <value>, describes wrapped enrtyid
	554	// Type: (BYTE) <value>, describes wrapped entryid
561	555	// lower 4 bits:
562	556	// 0x00 = OneOff (use addressbook)
563	557	// 0x03 = Contact (use folder / session?)

648	642	return hr;
649	643	}
650	644
651
652	645	/**
653	646	* Returns an addressbook contents table of the IPM.Contacts folder in m_lpContactFolder.
654	647	*

1115	1108	ptrColumns->cValues = stProps.size();
1116	1109	std::copy(stProps.begin(), stProps.end(), ptrColumns->aulPropTag);
1117	1110
1118
1119	1111	hr = this->GetContentsTable(ulFlags & MAPI_UNICODE, &ptrContents);
1120	1112	if (hr != hrSuccess)
1121	1113	goto exit;

+0

-5

provider/contacts/ZCABLogon.cpp less more

25	25	#include "kcore.hpp"
26	26	#include <mapix.h>
27	27	#include <edkmdb.h>
28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32	28
33	29	ZCABLogon::ZCABLogon(LPMAPISUP lpMAPISup, ULONG ulProfileFlags, GUID *lpGUID) : ECUnknown("IABLogon")
34	30	{

333	329	return hr;
334	330	}
335	331
336
337	332	HRESULT ZCABLogon::xABLogon::QueryInterface(REFIID refiid, void ** lppInterface)
338	333	{
339	334	TRACE_MAPI(TRACE_ENTRY, "IABLogon::QueryInterface", "%s", DBGGUIDToString(refiid).c_str());

+0

-5

provider/contacts/ZCMAPIProp.cpp less more

29	29	#include <kopano/namedprops.h>
30	30	#include <kopano/mapiguidext.h>
31	31
32		#ifdef _DEBUG
33		#define new DEBUG_NEW
34		#endif
35
36	32	ZCMAPIProp::ZCMAPIProp(ULONG ulObjType, const char *szClassName) :
37	33	ECUnknown(szClassName), m_ulObject(ulObjType)
38	34	{

391	387	return hr;
392	388	}
393	389
394
395	390	/**
396	391	* return property data of this object
397	392	*

+0

-5

provider/contacts/epcontact.cpp less more

21	21	#include <kopano/Trace.h>
22	22
23	23	#include "ZCABProvider.h"
24
25		#ifdef _DEBUG
26		#define new DEBUG_NEW
27		#endif
28	24
29	25	extern "C" MSGSERVICEENTRY __stdcall MSGServiceEntry;
30	26

64	60	if (lppMapiError)
65	61	*lppMapiError = NULL;
66	62
67
68	63	TRACE_MAPI(TRACE_RETURN, "MSGServiceEntry", "%s", GetMAPIErrorDescription(hr).c_str());
69	64	return hr;
70	65	}

+0

-14

provider/libserver/ECABObjectTable.cpp less more

32	32	#include "ECSession.h"
33	33	#include "ECSessionManager.h"
34	34	#include <kopano/stringutil.h>
35
36		#ifdef _DEBUG
37		#define new DEBUG_NEW
38		#endif
39	35
40	36	ECABObjectTable::ECABObjectTable(ECSession *lpSession, unsigned int ulABId, unsigned int ulABType, unsigned int ulABParentId, unsigned int ulABParentType, unsigned int ulFlags, const ECLocale &locale) : ECGenericObjectTable(lpSession, ulABType, ulFlags, locale)
41	37	{

138	134
139	135	pthread_mutex_unlock(&m_hLock);
140	136
141
142	137	return er;
143	138	}
144	139
145	140	ECRESULT ECABObjectTable::ReloadTableMVData(ECObjectTableList* lplistRows, ECListInt* lplistMVPropTag)
146	141	{
147	142	ECRESULT er = erSuccess;
148		ECListIntIterator iterListMVPropTag;
149
150		ECObjectTableList::const_iterator iterListRows;
151	143
152	144	ASSERT(lplistMVPropTag->size() <2); //FIXME: Limit of one 1 MV column
153	145

158	150	return er;
159	151	}
160	152
161
162	153	ECRESULT ECABObjectTable::GetMVRowCount(unsigned int ulObjId, unsigned int *lpulCount)
163	154	{
164	155	ECRESULT er = erSuccess;
165		ECObjectTableList listRows;
166		ECObjectTableList::const_iterator iterListRows;
167		ECObjectTableMap::const_iterator iterIDs;
168
169		ECListInt::const_iterator iterListMVPropTag;
170	156
171	157	pthread_mutex_lock(&m_hLock);
172	158

+7

-3

provider/libserver/ECAttachmentStorage.cpp less more

122	122	}
123	123	if (ans != NULL && strcmp(ans, "files") == 0) {
124	124	const char *const sync_files_par = lpConfig->GetSetting("attachment_files_fsync");
125		bool sync_files = sync_files_par == NULL \|\| strcmp_ci(sync_files_par, "yes") == 0;
	125	bool sync_files = sync_files_par == NULL \|\| strcasecmp(sync_files_par, "yes") == 0;
126	126	const char *comp = lpConfig->GetSetting("attachment_compression");
127	127	unsigned int complvl = (comp == NULL) ? 0 : strtoul(comp, NULL, 0);
128	128
129	129	lpAttachmentStorage = new ECFileAttachment(lpDatabase, dir, complvl, sync_files);
130	130	#ifdef HAVE_LIBS3_H
131	131	} else if (ans != NULL && strcmp(ans, "s3") == 0) {
132		lpAttachmentStorage = new ECS3Attachment(lpDatabase,
	132	try {
	133	lpAttachmentStorage = new ECS3Attachment(lpDatabase,
133	134	lpConfig->GetSetting("attachment_s3_protocol"),
134	135	lpConfig->GetSetting("attachment_s3_uristyle"),
135	136	lpConfig->GetSetting("attachment_s3_accesskeyid"),

137	138	lpConfig->GetSetting("attachment_s3_bucketname"),
138	139	lpConfig->GetSetting("attachment_path"),
139	140	strtol(lpConfig->GetSetting("attachment_compression"), NULL, 0));
	141	} catch (std::runtime_error &e) {
	142	ec_log_warn("Cannot instantiate ECS3Attachment: %s", e.what());
	143	return KCERR_DATABASE_ERROR;
	144	}
140	145	#endif
141	146	} else {
142	147	lpAttachmentStorage = new ECDatabaseAttachment(lpDatabase);

1189	1194	return erSuccess;
1190	1195	}
1191	1196
1192
1193	1197	// Attachment storage is in separate files
1194	1198	ECFileAttachment::ECFileAttachment(ECDatabase *lpDatabase,
1195	1199	const std::string &basepath, unsigned int ulCompressionLevel,

+0

-15

provider/libserver/ECCacheManager.cpp less more

30	30	#include <kopano/stringutil.h>
31	31	#include "ECGenericObjectTable.h"
32	32	#include <kopano/threadutil.h>
33
34		#ifdef _DEBUG
35		#define new DEBUG_NEW
36		#endif
37	33
38	34	#include <algorithm>
39	35

652	648	memcpy(&guid, lpDBRow[1], sizeof(GUID));
653	649	ulType = atoi(lpDBRow[2]);
654	650
655
656	651	} else {
657	652	// We have a parent, get the store for our parent by recursively calling ourselves
658	653	er = GetStoreAndType(ulSubObjId, &ulStore, &guid, &ulType, maxdepth-1);

980	975	return m_UserObjectCache.AddCacheItem(ulUserId, sData);
981	976	}
982	977
983
984	978	ECRESULT ECCacheManager::_GetUserObject(unsigned int ulUserId, objectclass_t* lpulClass, unsigned int *lpulCompanyId,
985	979	std::string* lpstrExternId, std::string* lpstrSignature)
986	980	{

1333	1327
1334	1328	void ECCacheManager::ForEachCacheItem(void(callback)(const std::string &, const std::string &, const std::string &, void), void obj)
1335	1329	{
1336		string value;
1337
1338	1330	pthread_mutex_lock(&m_hCacheMutex);
1339	1331
1340	1332	m_ObjectsCache.RequestStats(callback, obj);

1349	1341
1350	1342	pthread_mutex_unlock(&m_hCacheMutex);
1351	1343
1352
1353	1344	pthread_mutex_lock(&m_hCacheCellsMutex);
1354	1345
1355	1346	m_CellCache.RequestStats(callback, obj);
1356	1347
1357	1348	pthread_mutex_unlock(&m_hCacheCellsMutex);
1358
1359	1349
1360	1350	pthread_mutex_lock(&m_hCacheIndPropMutex);
1361	1351

1381	1371	m_ServerDetailsCache.DumpStats();
1382	1372	pthread_mutex_unlock(&m_hCacheMutex);
1383	1373
1384
1385	1374	pthread_mutex_lock(&m_hCacheCellsMutex);
1386	1375	m_CellCache.DumpStats();
1387	1376	pthread_mutex_unlock(&m_hCacheCellsMutex);
1388
1389	1377
1390	1378	pthread_mutex_lock(&m_hCacheIndPropMutex);
1391	1379	m_PropToObjectCache.DumpStats();

1607	1595	{
1608	1596	ECRESULT er = erSuccess;
1609	1597	ECsIndexObject sObjectKeyLower, sObjectKeyUpper;
1610		ECMapObjectToProp::const_iterator iter, iDel;
1611	1598	ECMapPropToObject::const_iterator iterPropToObj;
1612	1599
1613	1600	std::list<ECMapObjectToProp::value_type> lstItems;

1629	1616
1630	1617	return er;
1631	1618	}
1632
1633	1619
1634	1620	ECRESULT ECCacheManager::RemoveIndexData(unsigned int ulPropTag, unsigned int cbData, unsigned char *lpData)
1635	1621	{

2029	2015	if(bPartialCompletion)
2030	2016	er = KCWARN_PARTIAL_COMPLETION;
2031	2017
2032
2033	2018	return er;
2034	2019	}
2035	2020

+0

-5

provider/libserver/ECConvenientDepthABObjectTable.cpp less more

26	26	#include "ECSession.h"
27	27	#include "ECMAPI.h"
28	28	#include <kopano/stringutil.h>
29
30		#ifdef _DEBUG
31		#define new DEBUG_NEW
32		#endif
33	29
34	30	ECConvenientDepthABObjectTable::ECConvenientDepthABObjectTable(ECSession *lpSession, unsigned int ulABId, unsigned int ulABType, unsigned int ulABParentId, unsigned int ulABParentType, unsigned int ulFlags, const ECLocale &locale) : ECABObjectTable(lpSession, ulABId, ulABType, ulABParentId, ulABParentType, ulFlags, locale) {
35	31	m_lpfnQueryRowData = ECConvenientDepthABObjectTable::QueryRowData;

83	79	}
84	80	return erSuccess;
85	81	}
86
87	82
88	83	/*
89	84	* Loads an entire multi-depth hierarchy table recursively.

+0

-4

provider/libserver/ECConvenientDepthObjectTable.cpp less more

27	27	#include <kopano/stringutil.h>
28	28
29	29	#include <list>
30
31		#ifdef _DEBUG
32		#define new DEBUG_NEW
33		#endif
34	30
35	31	ECConvenientDepthObjectTable::ECConvenientDepthObjectTable(ECSession *lpSession, unsigned int ulStoreId, LPGUID lpGuid, unsigned int ulFolderId, unsigned int ulObjType, unsigned int ulFlags, const ECLocale &locale) : ECStoreObjectTable(lpSession, ulStoreId, lpGuid, 0, ulObjType, ulFlags, 0, locale) {
36	32	m_ulFolderId = ulFolderId;

+0

-5

provider/libserver/ECConversion.cpp less more

27	27
28	28	using namespace std;
29	29
30		#ifdef _DEBUG
31		#define new DEBUG_NEW
32		#endif
33
34	30	// Convert search criteria from zarafa-5.2x to zarafa-6 format
35	31	ECRESULT ConvertSearchCriteria52XTo6XX(ECDatabase lpDatabase, char lpData, struct searchCriteria **lppNewSearchCriteria)
36	32	{

110	106	er = lpDatabase->DoSelect(strQuery, &lpDBResult);
111	107	if(er != erSuccess)
112	108	goto exit;
113
114	109
115	110	while ((lpDBRow = lpDatabase->FetchRow(lpDBResult)))
116	111	{

+1

-5

provider/libserver/ECDatabaseFactory.cpp less more

21	21
22	22	#include "ECServerEntrypoint.h"
23	23
24		#ifdef _DEBUG
25		#define new DEBUG_NEW
26		#endif
27
28	24	// The ECDatabaseFactory creates database objects connected to the server database. Which
29	25	// database is returned is chosen by the database_engine configuration setting.
30	26

37	33	{
38	34	const char *szEngine = m_lpConfig->GetSetting("database_engine");
39	35
40		if(stricmp(szEngine, "mysql") == 0) {
	36	if(strcasecmp(szEngine, "mysql") == 0) {
41	37	*lppDatabase = new ECDatabaseMySQL(m_lpConfig);
42	38	} else {
43	39	ec_log_crit("ECDatabaseFactory::GetDatabaseFactory(): database not mysql");

+5

-10

provider/libserver/ECDatabaseMySQL.cpp less more

43	43
44	44	using namespace std;
45	45
46		#ifdef _DEBUG
47		#define new DEBUG_NEW
48		#endif
49	46	#ifdef DEBUG
50	47	#define DEBUG_SQL 0
51	48	#define DEBUG_TRANSACTION 0

252	249	" FROM mvproperties JOIN hierarchy ON mvproperties.hierarchyid=hierarchy.id LEFT JOIN names ON (mvproperties.tag-0x8501)=names.id WHERE hierarchy.parent=hid AND (tag <= 0x8500 OR names.id IS NOT NULL) GROUP BY tag, mvproperties.type; \n"
253	250	"END;\n";
254	251
255
256	252	static const char szGetBestBody[] =
257	253	"CREATE PROCEDURE GetBestBody(hid integer, OUT bestbody integer)\n"
258	254	"DETERMINISTIC\n"

1156	1152	cbFields = mysql_field_count(&m_lpMySQL);
1157	1153
1158	1154	for (unsigned int i = 0; i < cbFields && ulIndex == (unsigned int)-1; ++i)
1159		if (stricmp(lpFields[i].name, strFieldname.c_str()) == 0)
	1155	if (strcasecmp(lpFields[i].name, strFieldname.c_str()) == 0)
1160	1156	ulIndex = i;
1161	1157
1162	1158	return ulIndex;

1374	1370	}
1375	1371
1376	1372	while ((lpDBRow = FetchRow(lpResult)) != NULL) {
1377		if (stricmp(lpDBRow[0], "InnoDB") != 0)
	1373	if (strcasecmp(lpDBRow[0], "InnoDB") != 0)
1378	1374	continue;
1379	1375
1380		if (stricmp(lpDBRow[1], "DISABLED") == 0) {
	1376	if (strcasecmp(lpDBRow[1], "DISABLED") == 0) {
1381	1377	// mysql has run with innodb enabled once, but disabled this.. so check your log.
1382	1378	ec_log_crit("INNODB engine is disabled. Please re-enable the INNODB engine. Check your MySQL log for more information or comment out skip-innodb in the mysql configuration file.");
1383	1379	er = KCERR_DATABASE_ERROR;
1384	1380	goto exit;
1385		} else if (stricmp(lpDBRow[1], "YES") != 0 && stricmp(lpDBRow[1], "DEFAULT") != 0) {
	1381	} else if (strcasecmp(lpDBRow[1], "YES") != 0 && strcasecmp(lpDBRow[1], "DEFAULT") != 0) {
1386	1382	// mysql is incorrectly configured or compiled.
1387	1383	ec_log_crit("INNODB engine is not supported. Please enable the INNODB engine in the mysql configuration file.");
1388	1384	er = KCERR_DATABASE_ERROR;

1585	1581	er = KCERR_UNKNOWN_DATABASE;
1586	1582
1587	1583	while (lpDBRow != NULL) {
1588		if (lpDBRow[0] != NULL && stricmp(lpDBRow[0], "storeid") == 0) {
	1584	if (lpDBRow[0] != NULL && strcasecmp(lpDBRow[0], "storeid") == 0) {
1589	1585	dbv->v_major = 5;
1590	1586	dbv->v_minor = 0;
1591	1587	dbv->v_rev = 0;

1662	1658	*lpulDatabaseRevision = 0;
1663	1659	}else
1664	1660	*lpulDatabaseRevision = atoui(lpDBRow[0]);
1665
1666	1661
1667	1662	exit:
1668	1663	if (lpResult != NULL)

+1

-12

provider/libserver/ECDatabaseUpdate.cpp less more

273	273	DB_RESULT lpResult = NULL;
274	274	DB_ROW lpDBRow = NULL;
275	275	DB_LENGTHS lpDBLenths = NULL;
276
277	276
278	277	strQuery = "SELECT `value` FROM `settings` WHERE `name` = 'server_guid'";
279	278	er = lpDatabase->DoSelect(strQuery, &lpResult);

875	874	lpResult = NULL;
876	875	}
877	876
878
879	877	exit:
880	878	if(lpResult)
881	879	lpDatabase->FreeResult(lpResult);

920	918	if (er != erSuccess)
921	919	goto exit;
922	920
923
924	921	// Create the new objectproperty table.
925	922	strQuery = Z_TABLEDEF_OBJECT_PROPERTY;
926	923	strQuery.replace(strQuery.find("objectproperty"), 14, "objectproperty_temp");

928	925	if (er != erSuccess)
929	926	goto exit;
930	927
931
932	928	// Create the new objectrelation table.
933	929	strQuery = Z_TABLEDEF_OBJECT_RELATION;
934	930	strQuery.replace(strQuery.find("objectrelation"), 14, "objectrelation_temp");

936	932	if (er != erSuccess)
937	933	goto exit;
938	934
939
940	935	// Create a list of all current objects from the object table.
941	936	strQuery = "SELECT id, objecttype FROM object ORDER BY objecttype";
942	937	er = lpDatabase->DoSelect(strQuery, &lpResult);

955	950
956	951	lpDatabase->FreeResult(lpResult);
957	952	lpResult = NULL;
958
959	953
960	954	// Recreate the objects in the object_temp table and on the fly create the queries to regenerate
961	955	// their properties in the objectpropert_temp table.

1021	1015	if (er != erSuccess)
1022	1016	goto exit;
1023	1017	}
1024
1025	1018
1026	1019	// Now repopulate the objectrelation table.
1027	1020	strQuery = "SELECT objectid, parentobjectid, relationtype FROM objectrelation";

1107	1100	goto exit;
1108	1101	}
1109	1102
1110
1111
1112	1103	// Now delete the old tables and rename the new ones
1113	1104	er = lpDatabase->DoDelete("DROP TABLE object, objectproperty, objectrelation");
1114	1105	if (er != erSuccess)

1223	1214	if (er != erSuccess)
1224	1215	goto exit;
1225	1216	}
1226
1227	1217
1228	1218	// Remove the extracted changes from the changes table
1229	1219	strQuery = "DELETE FROM changes WHERE id IN (";

1523	1513	if (lpDBRow[0] == NULL \|\| lpDBRow[1] == NULL \|\| lpDBRow[2] == NULL)
1524	1514	continue;
1525	1515
1526		if(stricmp(lpDBRow[2], "hi") == 0) {
	1516	if(strcasecmp(lpDBRow[2], "hi") == 0) {
1527	1517	bUpdate = true;
1528	1518	break;
1529	1519	}

2054	2044	ECRESULT UpdateDatabaseCreateDeferred(ECDatabase *lpDatabase)
2055	2045	{
2056	2046	ECRESULT er = erSuccess;
2057		std::string strQuery;
2058	2047	// Create the deferred table
2059	2048	er = lpDatabase->DoInsert(Z_TABLEDEF_DELAYEDUPDATE);
2060	2049	return er;

+2

-29

provider/libserver/ECDatabaseUtils.cpp less more

31	31	#include <pthread.h>
32	32	#include <string>
33	33
34		#ifdef _DEBUG
35		#define new DEBUG_NEW
36		#endif
37
38	34	ECRESULT GetPropSize(DB_ROW lpRow, DB_LENGTHS lpLen, unsigned int *lpulSize)
39	35	{
40	36	ECRESULT er = erSuccess;

73	69	return er;
74	70	}
75	71
76
77	72	// Case insensitive find
78	73	static size_t
79	74	ci_find_substr(const std::string &first, const std::string &second)

364	359	default:
365	360	return KCERR_INVALID_TYPE;
366	361	}
367		return erSuccess;
368		}
369		// by table
370
371		ECRESULT ParseMVPropCount(const char *lpRowData, ULONG ulSize,
372		unsigned int lpulLastPos, int lpnItemCount)
373		{
374		ULONG ulPos = *lpulLastPos;
375		ULONG ulIter = ulPos;
376		std::string strSize;
377
378		ASSERT(ulPos < ulSize);
379
380		while(ulIter < ulSize && lpRowData[ulIter] != ':')
381		++ulIter;
382
383		strSize.insert(0, lpRowData+ulPos, ulIter - ulPos);
384
385		*lpnItemCount = atoi(strSize.c_str());
386		*lpulLastPos = (ulIter+1);
387
388	362	return erSuccess;
389	363	}
390	364

569	543	goto exit;
570	544	}
571	545	lpPropVal->__union = SOAP_UNION_propValData_li;
572		lpPropVal->Value.li = _atoi64(lpRow[FIELD_NR_LONGINT]);
	546	lpPropVal->Value.li = atoll(lpRow[FIELD_NR_LONGINT]);
573	547	break;
574	548	case PT_STRING8:
575	549	case PT_UNICODE:

734	708	ulLastPos = 0;
735	709	for (gsoap_size_t i = 0; i < lpPropVal->Value.mvli.__size; ++i) {
736	710	ParseMVProp(lpRow[FIELD_NR_LONGINT], lpLen[FIELD_NR_LONGINT], &ulLastPos, &strData);
737		lpPropVal->Value.mvli.__ptr[i] = _atoi64(strData.c_str());
	711	lpPropVal->Value.mvli.__ptr[i] = atoll(strData.c_str());
738	712	}
739	713	break;
740	714	default:

748	722	freelocale(loc);
749	723	return er;
750	724	}
751
752	725
753	726	unsigned int NormalizeDBPropTag(unsigned int ulPropTag)
754	727	{

+0

-1

provider/libserver/ECDatabaseUtils.h less more

79	79	ECRESULT CopySOAPPropValToDatabaseMVPropVal(struct propVal lpPropVal, int nItem, std::string &strColName, std::string &strColData, ECDatabase lpDatabase);
80	80
81	81	ECRESULT ParseMVProp(const char lpRowData, ULONG ulSize, unsigned int lpulLastPos, std::string *lpstrData);
82		ECRESULT ParseMVPropCount(const char lpRowData, ULONG ulSize, unsigned int lpulLastPos, int *lpnItemCount);
83	82
84	83	unsigned int NormalizeDBPropTag(unsigned int ulPropTag);
85	84	bool CompareDBPropTag(unsigned int ulPropTag1, unsigned int ulPropTag2);

+1

-7

provider/libserver/ECGenProps.cpp less more

37	37
38	38	#include <edkmdb.h>
39	39	#include <kopano/mapiext.h>
40
41		#ifdef _DEBUG
42		#define new DEBUG_NEW
43		#endif
44	40
45	41	#define _(string) dcgettext("kopano", string, LC_MESSAGES)
46	42

294	290	ECRESULT ECGenProps::GetPropComputed(struct soap soap, unsigned int ulObjType, unsigned int ulPropTagRequested, unsigned int ulObjId, struct propVal lpPropVal)
295	291	{
296	292	ECRESULT er = erSuccess;
297		char* lpszColon = NULL;
298	293
299	294	switch(PROP_ID(ulPropTagRequested)) {
300	295	case PROP_ID(PR_MSG_STATUS):

334	329	} else {
335	330	lpPropVal->ulPropTag = ulPropTagRequested;
336	331	// Check for RE, FWD and similar muck at the start of the subject line
337		lpszColon = strchr(lpPropVal->Value.lpszA, ':');
	332	const char *lpszColon = strchr(lpPropVal->Value.lpszA, ':');
338	333	if (lpszColon != NULL && (lpszColon - lpPropVal->Value.lpszA) > 1 && (lpszColon - lpPropVal->Value.lpszA) < 4)
339	334	{
340	335	char* c = lpPropVal->Value.lpszA;

859	854	if (lpDatabase->GetNumRows(lpDBResult) == 0)
860	855	bIsOrphan = true;
861	856
862
863	857	*lpbIsOrphan = bIsOrphan;
864	858
865	859	exit:

+12

-20

provider/libserver/ECGenericObjectTable.cpp less more

46	46	#include <kopano/mapiext.h>
47	47
48	48	#include <sys/types.h>
49		#ifdef LINUX
	49	#if 1 /* change to HAVE_REGEX_H */
50	50	#include <regex.h>
51	51	#endif
52	52

67	67
68	68	#include "ECSession.h"
69	69
70		struct sortOrderArray sDefaultSortOrder{__gszeroinit};
71
72		#ifdef _DEBUG
73		#define new DEBUG_NEW
74		#endif
75
76		ULONG sANRProps[] = { PR_DISPLAY_NAME, PR_SMTP_ADDRESS, PR_ACCOUNT, PR_DEPARTMENT_NAME, PR_OFFICE_TELEPHONE_NUMBER, PR_OFFICE_LOCATION, PR_PRIMARY_FAX_NUMBER, PR_SURNAME};
	70	static struct sortOrderArray sDefaultSortOrder{__gszeroinit};
	71	static const ULONG sANRProps[] = {
	72	PR_DISPLAY_NAME, PR_SMTP_ADDRESS, PR_ACCOUNT, PR_DEPARTMENT_NAME,
	73	PR_OFFICE_TELEPHONE_NUMBER, PR_OFFICE_LOCATION, PR_PRIMARY_FAX_NUMBER,
	74	PR_SURNAME
	75	};
77	76
78	77	#define ISMINMAX(x) ((x) == EC_TABLE_SORT_CATEG_MIN \|\| (x) == EC_TABLE_SORT_CATEG_MAX)
79	78

117	116
118	117	return fMatch;
119	118	}
120
121
122	119
123	120	/**
124	121	* Constructor of the Generic Object Table

631	628	ECObjectTableMap::const_iterator iterObjects;
632	629
633	630	pthread_mutex_lock(&m_hLock);
634
635	631
636	632	if(ulFlags & TBL_ALL_COLUMNS) {
637	633	// All columns were requested. Simply get a unique list of all the proptags used in all the objects in this table

1981	1977	unsigned int ulSearchStringSize;
1982	1978	ULONG ulPropType;
1983	1979	ULONG ulFuzzyLevel;
1984		unsigned int ulScan, ulPos;
1985	1980	unsigned int ulSubRestrict = 0;
1986	1981	SUBRESTRICTIONRESULT::const_iterator iterSubResult;
1987	1982	entryId sEntryId;

2076	2071	fMatch = false;
2077	2072	break;
2078	2073	} else {
2079		ulScan = 1;
	2074	unsigned int ulScan = 1;
2080	2075	if(ulPropTagRestrict & MV_FLAG)
2081	2076	{
2082	2077	if(PROP_TYPE(ulPropTagRestrict) == PT_MV_TSTRING)

2099	2094	// Default match is false
2100	2095	fMatch = false;
2101	2096
2102		for (ulPos = 0; ulPos < ulScan; ++ulPos) {
	2097	for (unsigned int ulPos = 0; ulPos < ulScan; ++ulPos) {
2103	2098	if(ulPropTagRestrict & MV_FLAG)
2104	2099	{
2105	2100	if(PROP_TYPE(ulPropTagRestrict) == PT_MV_TSTRING) {

2157	2152
2158	2153	if(fMatch)
2159	2154	break;
2160		} // for (ulPos = 0; ulPos < ulScan; ++ulPos)
	2155	}
2161	2156	}
2162	2157	break;
2163	2158

2181	2176	if((PROP_TYPE(ulPropTagRestrict) & ~MV_FLAG) != PROP_TYPE(ulPropTagValue))
2182	2177	// cannot compare two different types, except mvprop -> prop
2183	2178	return KCERR_INVALID_TYPE;
2184		#ifdef LINUX
	2179	#if 1 /* HAVE_REGEX_H */
2185	2180	if(lpsRestrict->lpProp->ulType == RELOP_RE) {
2186	2181	regex_t reg;
2187	2182

3412	3407	return erSuccess;
3413	3408	}
3414	3409
3415
3416	3410	void ECCategory::DecUnread() {
3417	3411	--m_ulUnread;
3418	3412	}

3429	3423	size_t ECCategory::GetObjectSize(void) const
3430	3424	{
3431	3425	size_t ulSize = 0;
3432		unsigned int i;
3433	3426
3434	3427	if (m_cProps > 0) {
3435	3428	ulSize += sizeof(struct propVal) * m_cProps;
3436
3437		for (i = 0; i < m_cProps; ++i)
	3429	for (unsigned int i = 0; i < m_cProps; ++i)
3438	3430	ulSize += PropSize(&m_lpProps[i]);
3439	3431	}
3440	3432

+0

-7

provider/libserver/ECICS.cpp less more

35	35	#include "soapH.h"
36	36	#include "SOAPUtils.h"
37	37
38		#ifdef _DEBUG
39		#define new DEBUG_NEW
40		#endif
41
42	38	extern ECSessionManager* g_lpSessionManager;
43	39
44	40	struct ABChangeRecord {

57	53	, change_type(_change_type)
58	54	{ }
59	55
60
61	56	typedef std::list<ABChangeRecord> ABChangeRecordList;
62
63	57
64	58	static bool isICSChange(unsigned int ulChange)
65	59	{

618	612	// CHeck if the client understands the new ABEID.
619	613	if ((lpSession->GetCapabilities() & KOPANO_CAP_MULTI_SERVER) == KOPANO_CAP_MULTI_SERVER)
620	614	bAcceptABEID = true;
621
622	615
623	616	if(ulChangeType != ICS_SYNC_AB) {
624	617	// You must first register your sync via setSyncStatus()

+0

-2

provider/libserver/ECICS.h less more

127	127	* The source key of the message.
128	128	* @param[in] sParentSourceKey
129	129	* THe source key of the folder containing the message.
130		*
131		* @return HRESULT
132	130	*/
133	131	ECRESULT AddToLastSyncedMessagesSet(ECDatabase *lpDatabase, unsigned int ulSyncId, const SOURCEKEY &sSourceKey, const SOURCEKEY &sParentSourceKey);
134	132

+0

-12

provider/libserver/ECICSHelpers.cpp less more

34	34	#include <kopano/ECLogger.h>
35	35	extern ECLogger* g_lpLogger;
36	36
37		#ifdef _DEBUG
38		#define new DEBUG_NEW
39		#endif
40
41	37	extern ECSessionManager* g_lpSessionManager;
42
43
44	38
45	39	/**
46	40	* IDbQueryCreator: Interface to the database query creators

51	45	virtual ~IDbQueryCreator() {};
52	46	virtual std::string CreateQuery() = 0;
53	47	};
54
55	48
56	49	/**
57	50	* CommonQueryCreator: Abstract implementation of IDBQueryCreator that handles the

94	87
95	88	return strQuery;
96	89	}
97
98	90
99	91	/**
100	92	* IncrementalQueryCreator: Creates an incremental query. In other words only messages

161	153	return " ORDER BY changes.id";
162	154	}
163	155
164
165	156	/**
166	157	* FullQueryCreator: Create a query that will return all messages for a sync id. The
167	158	* messages need to be processed afterwards to see what needs to be

214	205	return " ORDER BY hierarchy.id DESC";
215	206	}
216	207
217
218	208	/**
219	209	* NullQueryCreator: Returns no query at all. This is only used for SYNC_CATCHUP syncs that
220	210	* do not have a restriction set. (When a restriction is set, we still need to generate the message set

254	244	virtual ECRESULT GetResidualMessages(LPMESSAGESET lpsetResiduals) = 0;
255	245	virtual unsigned int GetMaxChangeId() const = 0;
256	246	};
257
258	247
259	248	/**
260	249	* NonLegacyIncrementalProcessor: Processes accepted and rejected messages without the burden of tracking

912	901	if (m_lpsRestrict && m_setNewMessages.empty())
913	902	m_setNewMessages.insert(MESSAGESET::value_type(SOURCEKEY(1, "\x00"), SAuxMessageData(m_sFolderSourceKey, 0, 0)));
914	903
915
916	904	if (!m_setNewMessages.empty()) {
917	905	std::set<unsigned int> setChangeIds;
918	906

+0

-4

provider/libserver/ECLockManager.cpp less more

20	20	#include <kopano/threadutil.h>
21	21
22	22	#include <boost/utility.hpp>
23
24		#ifdef _DEBUG
25		#define new DEBUG_NEW
26		#endif
27	23
28	24	using namespace std;
29	25

+0

-4

provider/libserver/ECMailBoxTable.cpp less more

27	27	#include <kopano/stringutil.h>
28	28
29	29	#include "ECMailBoxTable.h"
30
31		#ifdef _DEBUG
32		#define new DEBUG_NEW
33		#endif
34	30
35	31	ECMailBoxTable::ECMailBoxTable(ECSession *lpSession, unsigned int ulFlags, const ECLocale &locale) :
36	32	ECStoreObjectTable(lpSession, 0, NULL, 0, MAPI_STORE, ulFlags, TABLE_FLAG_OVERRIDE_HOME_MDB, locale)

+0

-4

provider/libserver/ECMultiStoreTable.cpp less more

25	25	#include "ECSession.h"
26	26	#include "ECMAPI.h"
27	27	#include <kopano/stringutil.h>
28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32	28
33	29	ECMultiStoreTable::ECMultiStoreTable(ECSession *lpSession, unsigned int ulObjType, unsigned int ulFlags, const ECLocale &locale) : ECStoreObjectTable(lpSession, 0, NULL, 0, ulObjType, ulFlags, 0, locale) {
34	30	}

+0

-4

provider/libserver/ECNotification.cpp less more

17	17	#include "ECNotification.h"
18	18	#include "ECMAPI.h"
19	19	#include "SOAPUtils.h"
20
21		#ifdef _DEBUG
22		#define new DEBUG_NEW
23		#endif
24	20
25	21	ECNotification::ECNotification()
26	22	{

+0

-1

provider/libserver/ECNotificationManager.cpp less more

162	162
163	163	return hrSuccess;
164	164	}
165
166	165
167	166	void * ECNotificationManager::Thread(void *lpParam)
168	167	{

+0

-12

provider/libserver/ECPluginFactory.cpp less more

26	26	#include <kopano/ECLogger.h>
27	27	#include <kopano/ecversion.h>
28	28
29		#ifdef EMBEDDED_USERPLUGIN
30		#include "DBUserPlugin.h"
31		#endif
32
33		#ifdef _DEBUG
34		#define new DEBUG_NEW
35		#endif
36
37	29	ECPluginFactory::ECPluginFactory(ECConfig config, ECStatsCollector lpStatsCollector,
38	30	bool bHosted, bool bDistributed)
39	31	{

59	51	ECRESULT ECPluginFactory::CreateUserPlugin(UserPlugin **lppPlugin) {
60	52	UserPlugin *lpPlugin = NULL;
61	53
62		#ifdef EMBEDDED_USERPLUGIN
63		m_getUserPluginInstance = (UserPlugin* ()(pthread_mutex_t, ECPluginSharedData *)) getUserPluginInstance;
64		#else
65	54	if(m_dl == NULL) {
66	55	const char *pluginpath = m_config->GetSetting("plugin_path");
67	56	const char *pluginname = m_config->GetSetting("user_plugin");

110	99	goto out;
111	100	}
112	101	}
113		#endif
114	102	try {
115	103	lpPlugin = m_getUserPluginInstance(&m_plugin_lock, m_shareddata);
116	104	lpPlugin->InitPlugin();

+0

-2

provider/libserver/ECPluginSharedData.cpp less more

137	137
138	138	void ECPluginSharedData::Signal(int signal)
139	139	{
140		#ifdef LINUX
141	140	if (!m_lpConfig)
142	141	return;
143	142

154	153	default:
155	154	break;
156	155	}
157		#endif
158	156	}
159	157

+103

-48

provider/libserver/ECS3Attachment.cpp less more

1	1	#ifdef HAVE_LIBS3_H
2	2	#include <kopano/platform.h>
3	3	#include <algorithm>
	4	#include <mutex>
	5	#include <stdexcept>
4	6	#include <cerrno>
5	7	#include <pthread.h>
6	8	#include <unistd.h>

38	40	void *cbdata;
39	41	};
40	42
	43	static void *ec_libs3_handle;
	44	#define W(n) static decltype(S3_ ## n) *DY_ ## n;
	45	W(put_object)
	46	W(initialize)
	47	W(status_is_retryable)
	48	W(deinitialize)
	49	W(get_status_name)
	50	W(head_object)
	51	W(delete_object)
	52	W(get_object)
	53	#undef W
	54
41	55	/**
42	56	* Static function used to forward the response properties callback to the
43	57	* right object.

100	114	ECRESULT ECS3Attachment::StaticInit(ECConfig *cf)
101	115	{
102	116	ec_log_info("Initializing S3 Attachment Storage");
103		S3Status status = S3_initialize("Kopano Mail", S3_INIT_ALL, cf->GetSetting("attachment_s3_hostname"));
	117
	118	/*
	119	* Do a dlopen of libs3.so.2 so that the implicit pull-in of
	120	* libldap-2.4.so.2 symbols does not pollute our namespace of
	121	* libldap_r-2.4.so.2 symbols.
	122	*/
	123	void *h = ec_libs3_handle = dlopen("libs3.so.2", RTLD_LAZY \| RTLD_LOCAL);
	124	const char *err;
	125	if (ec_libs3_handle == NULL) {
	126	ec_log_warn("dlopen libs3.so.2: %s", (err = dlerror()) ? err : "<none>");
	127	return KCERR_DATABASE_ERROR;
	128	}
	129	#define W(n) do { \
	130	DY_ ## n = reinterpret_cast<decltype(DY_ ## n)>(dlsym(h, "S3_" #n)); \
	131	if (DY_ ## n == NULL) { \
	132	ec_log_warn("dlsym S3_" #n ": %s", (err = dlerror()) ? err : "<none>"); \
	133	dlclose(h); \
	134	ec_libs3_handle = NULL; \
	135	return KCERR_DATABASE_ERROR; \
	136	} \
	137	} while (false)
	138
	139	W(put_object);
	140	W(initialize);
	141	W(status_is_retryable);
	142	W(deinitialize);
	143	W(get_status_name);
	144	W(head_object);
	145	W(delete_object);
	146	W(get_object);
	147	#undef W
	148
	149	S3Status status = DY_initialize("Kopano Mail", S3_INIT_ALL, cf->GetSetting("attachment_s3_hostname"));
104	150	if (status != S3StatusOK) {
105		ec_log_err("Error while initializing S3 Attachment Storage, error type: %s", S3_get_status_name(status));
	151	ec_log_err("Error while initializing S3 Attachment Storage, error type: %s",
	152	DY_get_status_name(status));
106	153	return KCERR_NETWORK_ERROR;
107	154	}
108	155	return erSuccess;

112	159	{
113	160	ec_log_info("Deinitializing S3 Attachment Storage");
114	161	/* Deinitialize the S3 storage environment */
115		S3_deinitialize();
	162	if (ec_libs3_handle != NULL) {
	163	DY_deinitialize();
	164	dlclose(ec_libs3_handle);
	165	}
116	166	return erSuccess;
117	167	}
118	168

136	186	* simply request the dagent to resend the attachment and to obtain a new
137	187	* attachment id.
138	188	*/
139
140	189
141	190	/**
142	191	* The ECS3Attachment Storage engine is used to store attachments as separate

239	288	struct s3_cd data = reinterpret_cast<struct s3_cd >(cbdata);
240	289	data->status = status;
241	290
242		ec_log_debug("Response completed: %s.", S3_get_status_name(status));
	291	ec_log_debug("Response completed: %s.", DY_get_status_name(status));
243	292	if (status == S3StatusOK)
244	293	return;
245	294	if (error == 0) {
246		ec_log_err("Amazon S3 return status %s", S3_get_status_name(status));
	295	ec_log_err("Amazon S3 return status %s", DY_get_status_name(status));
247	296	return;
248	297	}
249	298	ec_log_err("Amazon S3 return status %s, error: %s, resource: \"%s\"",
250		S3_get_status_name(status),
	299	DY_get_status_name(status),
251	300	error->message ? error->message : "<unknown>",
252	301	error->resource ? error->resource : "<none>");
253	302	if (error->furtherDetails != NULL)

374	423	*/
375	424	cdp->retries = S3_RETRIES;
376	425	do {
377		S3_head_object(&m_bucket_ctx, filename.c_str(), 0,
	426	DY_head_object(&m_bucket_ctx, filename.c_str(), 0,
378	427	&m_response_handler, &cwdata);
379		if (S3_status_is_retryable(cdp->status))
380		ec_log_debug("Existence check result in while: %s", S3_get_status_name(cdp->status));
381		} while (S3_status_is_retryable(cdp->status) && should_retry(cdp));
382
383		ec_log_debug("Result of the existence check: %s", S3_get_status_name(cdp->status));
	428	if (DY_status_is_retryable(cdp->status))
	429	ec_log_debug("Existence check result in while: %s",
	430	DY_get_status_name(cdp->status));
	431	} while (DY_status_is_retryable(cdp->status) && should_retry(cdp));
	432
	433	ec_log_debug("Result of the existence check: %s",
	434	DY_get_status_name(cdp->status));
384	435	return cdp->status == S3StatusOK;
385	436	}
386	437

422	473	*/
423	474	cdp->retries = S3_RETRIES;
424	475	do {
425		S3_get_object(&m_bucket_ctx, filename.c_str(),
	476	DY_get_object(&m_bucket_ctx, filename.c_str(),
426	477	&m_get_conditions, /startByte/ 0, /byteCount/ 0, 0,
427	478	&m_get_obj_handler, &cwdata);
428		if (S3_status_is_retryable(cdp->status))
	479	if (DY_status_is_retryable(cdp->status))
429	480	ec_log_debug("Load instance result in while: %s",
430		S3_get_status_name(cdp->status));
431		} while (S3_status_is_retryable(cdp->status) && should_retry(cdp));
	481	DY_get_status_name(cdp->status));
	482	} while (DY_status_is_retryable(cdp->status) && should_retry(cdp));
432	483
433	484	ec_log_debug("Result of the load instance: %s",
434		S3_get_status_name(cdp->status));
	485	DY_get_status_name(cdp->status));
435	486
436	487	if (cdp->size != cdp->processed) {
437	488	ec_log_err("Short read while reading attachment data, key: %s", filename.c_str());

495	546	*/
496	547	cdp->retries = S3_RETRIES;
497	548	do {
498		S3_get_object(&m_bucket_ctx, filename.c_str(),
	549	DY_get_object(&m_bucket_ctx, filename.c_str(),
499	550	&m_get_conditions, /startByte/ 0, /byteCount/ 0, 0,
500	551	&m_get_obj_handler, &cwdata);
501		if (S3_status_is_retryable(cdp->status))
502		ec_log_debug("Load instance result in while: %s", S3_get_status_name(cdp->status));
503		} while (S3_status_is_retryable(cdp->status) && should_retry(cdp));
504
505		ec_log_debug("Result of the load instance: %s", S3_get_status_name(cdp->status));
	552	if (DY_status_is_retryable(cdp->status))
	553	ec_log_debug("Load instance result in while: %s",
	554	DY_get_status_name(cdp->status));
	555	} while (DY_status_is_retryable(cdp->status) && should_retry(cdp));
	556
	557	ec_log_debug("Result of the load instance: %s",
	558	DY_get_status_name(cdp->status));
506	559	if (cdp->size != cdp->processed) {
507	560	ec_log_err("Short read while reading attachment data from S3, key: %s", filename.c_str());
508	561	ret = KCERR_DATABASE_ERROR;

557	610	*/
558	611	cdp->retries = S3_RETRIES;
559	612	do {
560		S3_put_object(&m_bucket_ctx, filename.c_str(), size, NULL,
	613	DY_put_object(&m_bucket_ctx, filename.c_str(), size, NULL,
561	614	NULL, &m_put_obj_handler, &cwdata);
562		if (S3_status_is_retryable(cdp->status))
	615	if (DY_status_is_retryable(cdp->status))
563	616	ec_log_debug("Save attachment result in while: %s",
564		S3_get_status_name(cdp->status));
565		} while (S3_status_is_retryable(cdp->status) && should_retry(cdp));
566
567		ec_log_debug("Result of the save attachment: %s", S3_get_status_name(cdp->status));
	617	DY_get_status_name(cdp->status));
	618	} while (DY_status_is_retryable(cdp->status) && should_retry(cdp));
	619
	620	ec_log_debug("Result of the save attachment: %s",
	621	DY_get_status_name(cdp->status));
568	622	/* set in transaction before disk full check to remove empty file */
569	623	if (m_transact)
570	624	m_new_att.insert(ins_id);

615	669	*/
616	670	cdp->retries = S3_RETRIES;
617	671	do {
618		S3_put_object(&m_bucket_ctx, filename.c_str(), size, NULL,
	672	DY_put_object(&m_bucket_ctx, filename.c_str(), size, NULL,
619	673	NULL, &m_put_obj_handler, &cwdata);
620		if (S3_status_is_retryable(cdp->status))
	674	if (DY_status_is_retryable(cdp->status))
621	675	ec_log_debug("Save attachment result in while: %s",
622		S3_get_status_name(cdp->status));
623		}
624		while (S3_status_is_retryable(cdp->status) && should_retry(cdp));
	676	DY_get_status_name(cdp->status));
	677	}
	678	while (DY_status_is_retryable(cdp->status) && should_retry(cdp));
625	679
626	680	ec_log_debug("Result of the save attachment: %s",
627		S3_get_status_name(cdp->status));
	681	DY_get_status_name(cdp->status));
628	682	/* set in transaction before disk full check to remove empty file */
629	683	if (m_transact)
630	684	m_new_att.insert(ins_id);

715	769	*/
716	770	cdp->retries = S3_RETRIES;
717	771	do {
718		S3_delete_object(&m_bucket_ctx, filename.c_str(), 0,
	772	DY_delete_object(&m_bucket_ctx, filename.c_str(), 0,
719	773	&m_response_handler, &cwdata);
720
721		if (S3_status_is_retryable(cdp->status))
722		ec_log_debug("Delete marked attachment result in while: %s", S3_get_status_name(cdp->status));
723		} while (S3_status_is_retryable(cdp->status) && should_retry(cdp));
724
725		ec_log_debug("Result of the delete marked attachment: %s", S3_get_status_name(cdp->status));
	774	if (DY_status_is_retryable(cdp->status))
	775	ec_log_debug("Delete marked attachment result in while: %s",
	776	DY_get_status_name(cdp->status));
	777	} while (DY_status_is_retryable(cdp->status) && should_retry(cdp));
	778
	779	ec_log_debug("Result of the delete marked attachment: %s",
	780	DY_get_status_name(cdp->status));
726	781	if (cdp->status == S3StatusOK)
727	782	return erSuccess;
728	783	return KCERR_NOT_FOUND;

831	886	*/
832	887	cdp->retries = S3_RETRIES;
833	888	do {
834		S3_head_object(&m_bucket_ctx, filename.c_str(), 0,
	889	DY_head_object(&m_bucket_ctx, filename.c_str(), 0,
835	890	&m_response_handler, &cwdata);
836		if (S3_status_is_retryable(cdp->status))
	891	if (DY_status_is_retryable(cdp->status))
837	892	ec_log_debug("Get size attachment result in while: %s",
838		S3_get_status_name(cdp->status));
839		} while (S3_status_is_retryable(cdp->status) && should_retry(cdp));
	893	DY_get_status_name(cdp->status));
	894	} while (DY_status_is_retryable(cdp->status) && should_retry(cdp));
840	895
841	896	ec_log_debug("Get size of attachment: %s -> %d",
842		S3_get_status_name(cdp->status), cdp->size);
	897	DY_get_status_name(cdp->status), cdp->size);
843	898
844	899	if (cdp->status == S3StatusOK) {
845	900	*size_p = cdp->size;

+11

-16

provider/libserver/ECSearchFolders.cpp less more

34	34	#include <kopano/stringutil.h>
35	35
36	36	#include "ECSearchClient.h"
37
38		#ifdef _DEBUG
39		#define new DEBUG_NEW
40		#endif
41	37
42	38	typedef struct {
43	39	SEARCHFOLDER *lpFolder;

311	307	pthread_attr_t attr;
312	308	pthread_attr_init(&attr);
313	309	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
314		#ifdef LINUX
315	310	pthread_attr_setstacksize(&attr, 512*1024); // 512KB stack space for search threads
316		#endif
317	311	int err = 0;
318	312
319	313	if((err = pthread_create(&lpSearchFolder->sThreadId, &attr, ECSearchFolders::SearchThread, (void *)ti)) != 0) {

1060	1054	return er;
1061	1055	}
1062	1056
1063
1064	1057	// Does an actual search of a specific search Criteria in store ulStoreId, search folder ulFolderId. Will cancel if *lpbCancel
1065	1058	// is TRUE. We check after each message row set to see if the cancel has been requested.
1066	1059	ECRESULT ECSearchFolders::Search(unsigned int ulStoreId, unsigned int ulFolderId, struct searchCriteria lpSearchCrit, bool lpbCancel, bool bNotify)

1159	1152	strQuery = "SELECT hierarchy.id from hierarchy WHERE hierarchy.parent = " + stringify(*iterFolders) + " AND hierarchy.type=3 AND hierarchy.flags & " + stringify(MSGFLAG_DELETED\|MSGFLAG_ASSOCIATED) + " = 0 ORDER by hierarchy.id DESC";
1160	1153
1161	1154	er = lpDatabase->DoSelect(strQuery, &lpDBResult);
1162		if(er != erSuccess)
1163		continue; // Try to continue if the query failed ..
1164
1165		while((lpDBRow = lpDatabase->FetchRow(lpDBResult)) != NULL) {
1166		if(lpDBRow && lpDBRow[0])
1167		lstFolders.push_back(atoi(lpDBRow[0]));
	1155	if(er == erSuccess) {
	1156	while((lpDBRow = lpDatabase->FetchRow(lpDBResult)) != NULL) {
	1157	if(lpDBRow && lpDBRow[0])
	1158	lstFolders.push_back(atoi(lpDBRow[0]));
	1159	}
	1160	} else
	1161	ec_log_crit("ECSearchFolders::Search() could not expand target folders: 0x%x", er);
	1162
	1163	if(lpDBResult) {
	1164	lpDatabase->FreeResult(lpDBResult);
	1165	lpDBResult = NULL;
1168	1166	}
1169	1167
1170		if(lpDBResult){ lpDatabase->FreeResult(lpDBResult); lpDBResult = NULL; }
1171	1168	++iterFolders;
1172	1169	}
1173	1170	}

1583	1580	return erSuccess;
1584	1581	}
1585	1582
1586
1587	1583	// Remove a single search result (so one message in a search folder). Returns NOT_FOUND if the item wasn't in the database in the first place
1588	1584	ECRESULT ECSearchFolders::DeleteResults(unsigned int ulStoreId, unsigned int ulFolderId, unsigned int ulObjId, unsigned int *lpulOldFlags)
1589	1585	{

1834	1830	struct soap xmlsoap;
1835	1831	struct searchCriteria sSearchCriteria;
1836	1832	std::ostringstream xml;
1837
1838	1833
1839	1834	// We use the soap serializer / deserializer to store the data
1840	1835	soap_set_mode(&xmlsoap, SOAP_XML_TREE \| SOAP_C_UTFSTRING);

+0

-4

provider/libserver/ECSearchObjectTable.cpp less more

22	22	#include "ECSessionManager.h"
23	23	#include "ECSearchObjectTable.h"
24	24	#include "ECSession.h"
25
26		#ifdef _DEBUG
27		#define new DEBUG_NEW
28		#endif
29	25
30	26	ECSearchObjectTable::ECSearchObjectTable(ECSession *lpSession, unsigned int ulStoreId, LPGUID lpGuid, unsigned int ulFolderId, unsigned int ulObjType, unsigned int ulFlags, const ECLocale &locale) : ECStoreObjectTable(lpSession, ulStoreId, lpGuid, 0, ulObjType, ulFlags, 0, locale) {
31	27	// We don't pass ulFolderId to ECStoreObjectTable (see constructor above passing '0'), because

+6

-19

provider/libserver/ECSecurity.cpp less more

13	13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	14	*/
15	15	#include <kopano/platform.h>
16		#ifdef LINUX
17	16	#include <sys/types.h>
18	17	#include <sys/stat.h>
19	18	#include <pwd.h>
20	19	#include <dirent.h>
21		#endif
22
23	20	#include "ECDatabaseUtils.h"
24	21	#include "ECDatabase.h"
25	22	#include "ECSessionManager.h"

33	30	#include "kcore.hpp"
34	31	#include <kopano/md5.h>
35	32
36		#include <kopano/ECDefs.h>
37	33	#include <mapidefs.h>
38	34	#include <mapicode.h>
39	35	#include <mapitags.h>

56	52	#include "ECDBDef.h"
57	53	#include "cmdutil.hpp"
58	54
59		#ifdef _DEBUG
60		#define new DEBUG_NEW
61		#endif
62
63	55	#define MAX_PARENT_LIMIT 64
64	56
65	57	/**
66		* ECSecurity constructor
67		*
68	58	* @param[in] lpSession user session
69	59	* @param[in] lpConfig config object
70	60	* @param[in] lpLogger log object for normal logging

197	187	cSeenGroups.m_seen.insert(*iterGroups);
198	188
199	189	std::list<localobjectdetails_t> *lpGroupInGroups = NULL;
200		std::list<localobjectdetails_t>::const_iterator li;
201	190
202	191	er = m_lpSession->GetUserManagement()->GetParentObjectsOfObjectAndSync(OBJECTRELATION_GROUP_MEMBER,
203	192	iterGroups->ulId, &lpGroupInGroups, USERMANAGEMENT_IDS_ONLY);

687	676	ECRESULT ECSecurity::SetRights(unsigned int objid, struct rightsArray *lpsRightsArray)
688	677	{
689	678	ECRESULT er;
690		std::string strQueryNew, strQueryDeniedNew;
691		std::string strQueryModify, strQueryDeniedModify;
692		std::string strQueryDelete, strQueryDeniedDelete;
	679	std::string strQueryNew, strQueryDelete;
693	680	unsigned int ulDeniedRights=0;
694	681	ECDatabase *lpDatabase = NULL;
695	682	unsigned int ulUserId = 0;

1259	1246	goto exit;
1260	1247	}
1261	1248
1262		*lpllStoreSize = _atoi64(lpDBRow[0]);
	1249	*lpllStoreSize = atoll(lpDBRow[0]);
1263	1250
1264	1251	exit:
1265	1252	if(lpDBResult)

1318	1305	if (lpDBRow[0] == NULL)
1319	1306	llUserSize = 0;
1320	1307	else
1321		llUserSize = _atoi64(lpDBRow[0]);
	1308	llUserSize = atoll(lpDBRow[0]);
1322	1309
1323	1310	*lpllUserSize = llUserSize;
1324	1311

1467	1454	quotadetails.bUseDefaultQuota = true;
1468	1455	quotadetails.bIsUserDefaultQuota = false;
1469	1456	if (lpszWarnQuota)
1470		quotadetails.llWarnSize = _atoi64(lpszWarnQuota) * 1024 * 1024;
	1457	quotadetails.llWarnSize = atoll(lpszWarnQuota) * 1024 * 1024;
1471	1458	if (lpszSoftQuota)
1472		quotadetails.llSoftSize = _atoi64(lpszSoftQuota) * 1024 * 1024;
	1459	quotadetails.llSoftSize = atoll(lpszSoftQuota) * 1024 * 1024;
1473	1460	if (lpszHardQuota)
1474		quotadetails.llHardSize = _atoi64(lpszHardQuota) * 1024 * 1024;
	1461	quotadetails.llHardSize = atoll(lpszHardQuota) * 1024 * 1024;
1475	1462
1476	1463	exit:
1477	1464	if (er == erSuccess)

+0

-4

provider/libserver/ECSecurityOffline.cpp less more

18	18
19	19	#include <kopano/ECDefs.h>
20	20	#include "ECSecurityOffline.h"
21
22		#ifdef _DEBUG
23		#define new DEBUG_NEW
24		#endif
25	21
26	22	ECSecurityOffline::ECSecurityOffline(ECSession lpSession, ECConfig lpConfig) :
27	23	ECSecurity(lpSession, lpConfig, NULL)

+4

-17

provider/libserver/ECServerEntrypoint.cpp less more

27	27	#include "ECSessionManagerOffline.h"
28	28	#include "ECS3Attachment.h"
29	29
30		#ifdef _DEBUG
31		#define new DEBUG_NEW
32		#endif
33
34	30	pthread_key_t database_key;
35	31	pthread_key_t plugin_key;
36	32
37		ULONG g_ulServerInitFlags = 0; // Libary init flags
38	33	ECSessionManager* g_lpSessionManager = NULL;
39	34	ECStatsCollector* g_lpStatsCollector = NULL;
40		std::set<ECDatabase*> g_lpDBObjectList;
41		pthread_mutex_t g_hMutexDBObjectList;
42		bool g_bInitLib = false;
	35	static std::set<ECDatabase *> g_lpDBObjectList;
	36	static pthread_mutex_t g_hMutexDBObjectList;
	37	static bool g_bInitLib = false;
43	38
44	39	void AddDatabaseObject(ECDatabase* lpDatabase)
45	40	{

191	186	return erSuccess;
192	187	}
193	188
194		#if 0
195		static void kopano_resetstats(void)
196		{
197		if (g_lpStatsCollector)
198		g_lpStatsCollector->Reset();
199		}
200		#endif
201
202	189	/**
203	190	* Called for each HTTP header in a request, handles the proxy header
204	191	* and marks the connection as using the proxy if it is found. The value

218	205	const char *val)
219	206	{
220	207	const char *szProxy = g_lpSessionManager->GetConfig()->GetSetting("proxy_header");
221		if(strlen(szProxy) > 0 && stricmp(key, szProxy) == 0) {
	208	if(strlen(szProxy) > 0 && strcasecmp(key, szProxy) == 0) {
222	209	((SOAPINFO *)soap->user)->bProxy = true;
223	210	}
224	211

+4

-68

provider/libserver/ECSession.cpp less more

16	16
17	17	#include <kopano/platform.h>
18	18	#include <new>
19		#ifdef LINUX
20	19	#include <sys/types.h>
21	20	#include <sys/stat.h>
22	21	#include <pwd.h>
23	22	#include <dirent.h>
24		#endif
25
26	23	#include <mapidefs.h>
27	24	#include <mapitags.h>
28	25

51	48
52	49	#include <boost/filesystem.hpp>
53	50	namespace bfs = boost::filesystem;
54
55		#ifdef _DEBUG
56		#define new DEBUG_NEW
57		#endif
58	51
59	52	#if defined LINUX \|\| !defined UNICODE
60	53	#define WHITESPACE " \t\n\r"

183	176	return this->m_lpDatabaseFactory->CreateDatabaseObject(lppDatabase, str);
184	177	}
185	178
186
187	179	ECRESULT BTSession::GetServerGUID(GUID* lpServerGuid){
188	180	return m_lpSessionManager->GetServerGUID(lpServerGuid);
189	181	}

305	297	pthread_mutex_init(&m_hStateLock, NULL);
306	298	pthread_mutex_init(&m_hLocksLock, NULL);
307	299	}
308
309	300
310	301	ECSession::~ECSession()
311	302	{

674	665	if (m_lpEcSecurity)
675	666	ulSize += m_lpEcSecurity->GetObjectSize();
676	667
677
678	668	// The Table manager size is not callculated here
679	669	// ulSize += GetTableManager()->GetObjectSize();
680	670	return ulSize;

694	684
695	685	m_ulConnectingPid = 0;
696	686
697		#ifdef LINUX
698	687	m_NTLM_pid = -1;
699	688	#ifdef HAVE_GSSAPI
700	689	m_gssServerCreds = GSS_C_NO_CREDENTIAL;
701	690	m_gssContext = GSS_C_NO_CONTEXT;
702	691	#endif
703		#else
704		SecInvalidateHandle(&m_hCredentials);
705		SecInvalidateHandle(&m_hContext);
706		m_cPackages = 0;
707		m_ulPid = 0;
708		m_lpPackageInfo = NULL;
709		#endif
710	692	}
711	693
712	694	ECAuthSession::~ECAuthSession()

727	709	pthread_cond_wait(&m_hThreadReleased, &m_hThreadReleasedMutex);
728	710	pthread_mutex_unlock(&m_hThreadReleasedMutex);
729	711
730		#ifdef LINUX
731	712	if (m_NTLM_pid != -1) {
732	713	int status;
733	714

758	739	#endif
759	740	}
760	741	}
761		#else // LINUX
762		if (m_lpPackageInfo)
763		FreeContextBuffer(m_lpPackageInfo);
764
765		if (SecIsValidHandle(&m_hCredentials))
766		FreeCredentialHandle(&m_hCredentials);
767
768		if (SecIsValidHandle(&m_hContext))
769		DeleteSecurityContext(&m_hContext);
770		#endif
771
772	742	delete m_lpUserManagement;
773	743	}
774
775	744
776	745	ECRESULT ECAuthSession::CreateECSession(ECSESSIONGROUPID ecSessionGroupId,
777	746	const std::string &cl_ver, const std::string &cl_app,

831	800	}
832	801
833	802	// SYSTEM can't login with user/pass
834		if (stricmp(lpszName, KOPANO_ACCOUNT_SYSTEM) == 0)
	803	if (strcasecmp(lpszName, KOPANO_ACCOUNT_SYSTEM) == 0)
835	804	return KCERR_NO_ACCESS;
836	805	er = m_lpUserManagement->AuthUserAndSync(lpszName, lpszPassword, &m_ulUserID);
837	806	if(er != erSuccess)

870	839	goto exit;
871	840	}
872	841	p = m_lpSessionManager->GetConfig()->GetSetting("allow_local_users");
873		if (p && !stricmp(p, "yes")) {
	842	if (p && !strcasecmp(p, "yes")) {
874	843	allowLocalUsers = true;
875	844	}
876	845
877	846	// Authentication stage
878		#ifdef LINUX
879	847	localAdminUsers = strdup(m_lpSessionManager->GetConfig()->GetSetting("local_admin_users"));
880	848
881	849	struct passwd pwbuf;

943	911	}
944	912	p = strtok_r(NULL, WHITESPACE, &ptr);
945	913	}
946
947		#else // LINUX
948
949		localAdminUsers = _tcsdup(GetConfigSetting(m_lpSessionManager->GetConfig(), "local_admin_users"));
950
951		dwSize = arraySize(szUsernameServer);
952
953		if (!GetNamedPipeHandleState((HANDLE)socket, NULL, NULL, NULL, NULL, szUsernameClient, arraySize(szUsernameClient)) \|\|
954		!GetUserName(szUsernameServer, &dwSize))
955		{
956		//GetLastError();
957		er = KCERR_LOGON_FAILED;
958		goto exit;
959		}
960
961		if (_tcscmp(szUsernameServer, szUsernameClient) == 0)
962		goto userok;
963
964		pt = _tcstok(localAdminUsers, WHITESPACE);
965
966		while (pt) {
967		if (_tcscmp(szUsernameClient, pt) == 0)
968		goto userok;
969
970		pt = _tcstok(NULL, WHITESPACE);
971		}
972
973		#endif // LINUX
974
975	914	er = KCERR_LOGON_FAILED;
976	915	goto exit;
977	916

1114	1053	return er;
1115	1054	}
1116	1055
1117		#ifdef LINUX
1118	1056	#define NTLMBUFFER 8192
1119	1057	ECRESULT ECAuthSession::ValidateSSOData(struct soap* soap, const char* lpszName, const char* lpszImpersonateUser, const char* szClientVersion, const char szClientApp, const char szClientAppVersion, const char szClientAppMisc, const struct xsd__base64Binary lpInput, struct xsd__base64Binary **lppOutput)
1120	1058	{

1325	1263	if (pos != string::npos)
1326	1264	strUsername.erase(pos);
1327	1265
1328		if (stricmp(strUsername.c_str(), lpszName) == 0) {
	1266	if (strcasecmp(strUsername.c_str(), lpszName) == 0) {
1329	1267	er = m_lpUserManagement->ResolveObjectAndSync(ACTIVE_USER, lpszName, &m_ulUserID);
1330	1268	// don't check NONACTIVE, since those shouldn't be able to login
1331	1269	if(er != erSuccess)

1581	1519	if(er != erSuccess)
1582	1520	return er;
1583	1521
1584		if (stricmp(lpszName, strAnswer.c_str()) != 0) {
	1522	if (strcasecmp(lpszName, strAnswer.c_str()) != 0) {
1585	1523	// cannot open another user without password
1586	1524	// or should we check permissions ?
1587	1525	ec_log_warn("Single Sign-On: User \"%s\" authenticated, but user \"%s\" requested.", strAnswer.c_str(), lpszName);

1613	1551	return er;
1614	1552	}
1615	1553	#undef NTLMBUFFER
1616		#endif
1617	1554
1618	1555	ECRESULT ECAuthSession::ProcessImpersonation(const char* lpszImpersonateUser)
1619	1556	{

1633	1570
1634	1571	return ulSize;
1635	1572	}
1636
1637	1573
1638	1574	ECAuthSessionOffline::ECAuthSessionOffline(const char *src_addr,
1639	1575	ECSESSIONID sessionID, ECDatabaseFactory *lpDatabaseFactory,

+0

-2

provider/libserver/ECSession.h less more

240	240
241	241	ECRESULT ProcessImpersonation(const char* lpszImpersonateUser);
242	242
243		#ifdef LINUX
244	243	/* NTLM */
245	244	pid_t m_NTLM_pid;
246	245	int m_NTLM_stdin[2], m_NTLM_stdout[2], m_NTLM_stderr[2];

251	250	gss_cred_id_t m_gssServerCreds;
252	251	gss_ctx_id_t m_gssContext;
253	252	#endif
254		#endif
255	253	};
256	254
257	255	/*

+0

-6

provider/libserver/ECSessionGroup.cpp less more

25	25	#include "ECSessionGroup.h"
26	26	#include "ECSessionManager.h"
27	27	#include "SOAPUtils.h"
28
29		#ifdef _DEBUG
30		#define new DEBUG_NEW
31		#endif
32	28
33	29	class FindChangeAdvise
34	30	{

309	305	lpNotify->ulEventType = fnevTableModified;
310	306	lpNotify->tab->ulTableEvent = ulType;
311	307
312
313	308	if(lpsChildRow && (lpsChildRow->ulObjId > 0 \|\| lpsChildRow->ulOrderId > 0)) {
314	309	lpNotify->tab->propIndex.ulPropTag = PR_INSTANCE_KEY;
315	310	lpNotify->tab->propIndex.__union = SOAP_UNION_propValData_bin;

374	369	SESSIONINFOMAP::const_iterator iterSessions;
375	370
376	371	std::map<ECSESSIONID,unsigned int> mapInserted;
377		std::map<ECSESSIONID,unsigned int>::const_iterator iterInserted;
378	372	std::set<unsigned int>::const_iterator iterSyncId;
379	373	CHANGESUBSCRIBEMAP::const_iterator iterItem;
380	374	std::pair<CHANGESUBSCRIBEMAP::const_iterator, CHANGESUBSCRIBEMAP::const_iterator> iterRange;

+0

-13

provider/libserver/ECSessionManager.cpp less more

34	34	#include <edkmdb.h>
35	35	#include "logontime.hpp"
36	36
37		#ifdef _DEBUG
38		#define new DEBUG_NEW
39		#endif
40
41	37	ECSessionManager::ECSessionManager(ECConfig lpConfig, ECLogger lpAudit,
42	38	bool bHostedKopano, bool bDistributedKopano)
43	39	{

612	608	g_lpStatsCollector->Increment(SCN_LOGIN_DENIED);
613	609	goto exit;
614	610
615
616	611	authenticated:
617	612	ec_log_debug("User \"%s\" from \"%s\" authenticated through \"%s\" using program %s", szName, from.c_str(), method, szClientApp ? szClientApp : "<unknown>");
618	613	if (strcmp(KOPANO_SYSTEM_USER, szName) != 0) {

840	835	struct timeval now;
841	836	struct timespec timeout;
842	837	list<BTSession*> lstSessions;
843
844	838
845	839	if(lpSessionManager == NULL) {
846	840	return 0;

1042	1036	return er;
1043	1037	}
1044	1038
1045
1046	1039	ECRESULT ECSessionManager::NotificationModified(unsigned int ulObjType, unsigned int ulObjId, unsigned int ulParentId)
1047	1040	{
1048	1041	ECRESULT er = erSuccess;

1377	1370	{
1378	1371	ECRESULT er = erSuccess;
1379	1372	unsigned int ulLicensedUsers = 0;
1380
1381		#ifdef LINUX
1382	1373	ECLicenseClient *lpLicenseClient = NULL;
1383	1374	lpLicenseClient = new ECLicenseClient();
1384	1375

1390	1381	}
1391	1382
1392	1383	delete lpLicenseClient;
1393		#else
1394		ulLicensedUsers = 0;
1395		#endif
1396
1397	1384	*lpulLicensedUsers = ulLicensedUsers;
1398	1385
1399	1386	return er;

+0

-4

provider/libserver/ECSessionManagerOffline.cpp less more

19	19
20	20	#include "ECSecurity.h"
21	21	#include "ECSessionManagerOffline.h"
22
23		#ifdef _DEBUG
24		#define new DEBUG_NEW
25		#endif
26	22
27	23	ECSessionManagerOffline::ECSessionManagerOffline(ECConfig *lpConfig,
28	24	bool bHostedKopano, bool bDistributedKopano) :

+0

-4

provider/libserver/ECStatsCollector.cpp less more

225	225	pthread_mutex_unlock(&iSD->second.lock);
226	226	}
227	227
228
229	228	void ECStatsCollector::Max(SCName name, float max)
230	229	{
231	230	SCMap::iterator iSD = m_StatData.find(name);

267	266	iSD->second.data.ts = max;
268	267	pthread_mutex_unlock(&iSD->second.lock);
269	268	}
270
271	269
272	270	void ECStatsCollector::Avg(SCName name, float add)
273	271	{

316	314	iSD->second.avginc = 1;
317	315	pthread_mutex_unlock(&iSD->second.lock);
318	316	}
319
320
321	317
322	318	void ECStatsCollector::Set(const std::string &name, const std::string &description, const std::string &value)
323	319	{

+41

-34

provider/libserver/ECStatsTables.cpp less more

34	34	#include "ECStatsCollector.h"
35	35
36	36	#if defined(HAVE_GPERFTOOLS_MALLOC_EXTENSION_H)
37		# include <gperftools/malloc_extension.h>
	37	# include <gperftools/malloc_extension_c.h>
38	38	#elif defined(HAVE_GOOGLE_MALLOC_EXTENSION_H)
39		# include <google/malloc_extension.h>
	39	# include <google/malloc_extension_c.h>
	40	#endif
	41	#ifdef HAVE_MALLOC_H
	42	# include <malloc.h>
40	43	#endif
41	44
42	45	/*

104	107
105	108	#ifdef HAVE_TCMALLOC
106	109	size_t value = 0;
107		MallocExtension::instance()->GetNumericProperty("generic.current_allocated_bytes", &value);
108		GetStatsCollectorData("tc_allocated", "Current allocated memory by TCMalloc", stringify_int64(value), this); // Bytes in use by application
109
110		value = 0;
111		MallocExtension::instance()->GetNumericProperty("generic.heap_size", &value);
112		GetStatsCollectorData("tc_reserved", "Bytes of system memory reserved by TCMalloc", stringify_int64(value), this);
113
114		value = 0;
115		MallocExtension::instance()->GetNumericProperty("tcmalloc.pageheap_free_bytes", &value);
116		GetStatsCollectorData("tc_page_map_free", "Number of bytes in free, mapped pages in page heap", stringify_int64(value), this);
117
118		value = 0;
119		MallocExtension::instance()->GetNumericProperty("tcmalloc.pageheap_unmapped_bytes", &value);
120		GetStatsCollectorData("tc_page_unmap_free", "Number of bytes in free, unmapped pages in page heap (released to OS)", stringify_int64(value), this);
121
122		value = 0;
123		MallocExtension::instance()->GetNumericProperty("tcmalloc.max_total_thread_cache_bytes", &value);
124		GetStatsCollectorData("tc_threadcache_max", "A limit to how much memory TCMalloc dedicates for small objects", stringify_int64(value), this);
125
126		value = 0;
127		MallocExtension::instance()->GetNumericProperty("tcmalloc.current_total_thread_cache_bytes", &value);
128		GetStatsCollectorData("tc_threadcache_cur", "Current allocated memory in bytes for thread cache", stringify_int64(value), this);
	110	auto gnp = reinterpret_cast<decltype(MallocExtension_GetNumericProperty) *>(dlsym(NULL, "MallocExtension_GetNumericProperty"));
	111	if (gnp != NULL) {
	112	gnp("generic.current_allocated_bytes", &value);
	113	GetStatsCollectorData("tc_allocated", "Current allocated memory by TCMalloc", stringify_int64(value), this); // Bytes in use by application
	114
	115	value = 0;
	116	gnp("generic.heap_size", &value);
	117	GetStatsCollectorData("tc_reserved", "Bytes of system memory reserved by TCMalloc", stringify_int64(value), this);
	118
	119	value = 0;
	120	gnp("tcmalloc.pageheap_free_bytes", &value);
	121	GetStatsCollectorData("tc_page_map_free", "Number of bytes in free, mapped pages in page heap", stringify_int64(value), this);
	122
	123	value = 0;
	124	gnp("tcmalloc.pageheap_unmapped_bytes", &value);
	125	GetStatsCollectorData("tc_page_unmap_free", "Number of bytes in free, unmapped pages in page heap (released to OS)", stringify_int64(value), this);
	126
	127	value = 0;
	128	gnp("tcmalloc.max_total_thread_cache_bytes", &value);
	129	GetStatsCollectorData("tc_threadcache_max", "A limit to how much memory TCMalloc dedicates for small objects", stringify_int64(value), this);
	130
	131	value = 0;
	132	gnp("tcmalloc.current_total_thread_cache_bytes", &value);
	133	GetStatsCollectorData("tc_threadcache_cur", "Current allocated memory in bytes for thread cache", stringify_int64(value), this);
	134	}
	135	#ifdef HAVE_MALLINFO
	136	/* parallel threaded allocator */
	137	struct mallinfo malloc_info = mallinfo();
	138	GetStatsCollectorData("pt_allocated", "Current allocated memory by libc ptmalloc, in bytes", stringify_int64(malloc_info.uordblks), this);
	139	#endif
129	140
130	141	#ifdef DEBUG
131	142	char test[2048] = {0};
132		MallocExtension::instance()->GetStats(test, sizeof(test));
133		GetStatsCollectorData("tc_stats_string", "TCMalloc memory debug data", test, this);
	143	auto getstat = reinterpret_cast<decltype(MallocExtension_GetStats) *>(dlsym(NULL, "MallocExtension_GetStats"));
	144	if (getstat != NULL) {
	145	getstat(test, sizeof(test));
	146	GetStatsCollectorData("tc_stats_string", "TCMalloc memory debug data", test, this);
	147	}
134	148	#endif
135	149
136	150	#endif

234	248	*lppRowSet = lpsRowSet;
235	249	return erSuccess;
236	250	}
237
238	251
239	252	/*
240	253	Session stats

489	502
490	503	for (j = 0, iterBS = iterSD->second.busystates.begin();
491	504	iterBS != iterSD->second.busystates.end(); ++j, ++iterBS) {
492		const char *szState;
	505	const char *szState = "";
493	506	if(iterBS->state == SESSION_STATE_PROCESSING)
494	507	szState = "P";
495	508	else if(iterBS->state == SESSION_STATE_SENDING)

521	534	*lppRowSet = lpsRowSet;
522	535	return erSuccess;
523	536	}
524
525	537
526	538	/*
527	539	User stats

603	615	delete lpObjects;
604	616	return er;
605	617	}
606
607	618
608	619	ECRESULT ECUserStatsTable::QueryRowData(ECGenericObjectTable lpThis, struct soap soap, ECSession lpSession, ECObjectTableList lpRowList, struct propTagArray lpsPropTagArray, void lpObjectData, struct rowSet **lppRowSet, bool bCacheTableData, bool bTableLimit)
609	620	{

815	826	return er;
816	827	}
817	828
818
819	829	ECCompanyStatsTable::ECCompanyStatsTable(ECSession *lpSession, unsigned int ulFlags, const ECLocale &locale) : ECGenericObjectTable(lpSession, MAPI_STATUS, ulFlags, locale)
820	830	{
821	831	m_lpfnQueryRowData = QueryRowData;

849	859	delete lpCompanies;
850	860	return er;
851	861	}
852
853	862
854	863	ECRESULT ECCompanyStatsTable::QueryRowData(ECGenericObjectTable lpThis, struct soap soap, ECSession lpSession, ECObjectTableList lpRowList, struct propTagArray lpsPropTagArray, void lpObjectData, struct rowSet **lppRowSet, bool bCacheTableData, bool bTableLimit)
855	864	{

905	914	// company gone missing since last call, all quota props should be set to ignore
906	915	bNoQuotaDetails = true;
907	916
908
909	917	if (lpSession->GetSecurity()->GetUserSize(iterRowList->ulObjId, &llStoreSize) != erSuccess)
910	918	llStoreSize = 0;
911	919

1028	1036	return erSuccess;
1029	1037	}
1030	1038
1031
1032	1039	ECRESULT ECServerStatsTable::QueryRowData(ECGenericObjectTable lpThis, struct soap soap, ECSession lpSession, ECObjectTableList lpRowList, struct propTagArray lpsPropTagArray, void lpObjectData, struct rowSet **lppRowSet, bool bCacheTableData, bool bTableLimit)
1033	1040	{
1034	1041	gsoap_size_t i;

+0

-8

provider/libserver/ECStoreObjectTable.cpp less more

67	67	#include "ECSession.h"
68	68
69	69	#include <map>
70
71		#ifdef _DEBUG
72		#define new DEBUG_NEW
73		#endif
74	70
75	71	extern ECStatsCollector* g_lpStatsCollector;
76	72

780	776	memset(&lpsRowSet->__ptr[ulRowNum].__ptr[iterColumns->second], 0, sizeof(lpsRowSet->__ptr[ulRowNum].__ptr[iterColumns->second]));
781	777	}
782	778
783
784	779	if(CopyDatabasePropValToSOAPPropVal(soap, lpDBRow, lpDBLen, &lpsRowSet->__ptr[ulRowNum].__ptr[iterColumns->second]) != erSuccess) {
785	780	// This can happen if a subquery returned a NULL field or if your database contains bad data (eg a NULL field where there shouldn't be)
786	781	++iterColumns;

806	801	if(lpDBResult) lpDatabase->FreeResult(lpDBResult);
807	802	lpDBResult = NULL;
808	803	}
809
810	804
811	805	for (iterColumns = mapColumns.begin(); iterColumns != mapColumns.end(); ++iterColumns) {
812	806	ASSERT(lpsRowSet->__ptr[ulRowNum].__ptr[iterColumns->second].ulPropTag == 0);

1041	1035	return er;
1042	1036	}
1043	1037
1044
1045	1038	ECRESULT ECStoreObjectTable::GetMVRowCount(unsigned int ulObjId, unsigned int *lpulCount)
1046	1039	{
1047	1040	ECRESULT er = erSuccess;

1305	1298
1306	1299	}
1307	1300
1308
1309	1301	/**
1310	1302	* Get all deferred changes for a specific folder
1311	1303	*/

+0

-1

provider/libserver/ECStringCompat.cpp less more

101	101	// deleting a NULL ptr is allowed.
102	102	delete m_lpConverter;
103	103	}
104
105	104
106	105	ECRESULT FixPropEncoding(struct soap soap, const ECStringCompat &stringCompat, enum EncodingFixDirection type, struct propVal lpProp, bool bNoTagUpdate)
107	106	{

+0

-4

provider/libserver/ECSubRestriction.cpp less more

28	28	#include "SOAPUtils.h"
29	29
30	30	#include "ECSessionManager.h"
31
32		#ifdef _DEBUG
33		#define new DEBUG_NEW
34		#endif
35	31
36	32	static ECRESULT GetSubRestrictionRecursive(struct restrictTable *lpRestrict,
37	33	unsigned int *lpulCount, unsigned int ulSubRestriction,

+0

-6

provider/libserver/ECTableManager.cpp less more

47	47	#include <kopano/mapiext.h>
48	48	#include <edkmdb.h>
49	49
50		#ifdef _DEBUG
51		#define new DEBUG_NEW
52		#endif
53
54	50	void FreeRowSet(struct rowSet *lpRowSet, bool bBasePointerDel);
55	51
56	52	unsigned int sContentsProps[] = { PR_ENTRYID, PR_DISPLAY_NAME, PR_MESSAGE_FLAGS, PR_SUBJECT, PR_STORE_ENTRYID, PR_STORE_RECORD_KEY, PR_STORE_SUPPORT_MASK, PR_INSTANCE_KEY, PR_RECORD_KEY, PR_ACCESS, PR_ACCESS_LEVEL };

149	145	pthread_mutex_unlock(&hListMutex);
150	146
151	147	}
152
153	148
154	149	ECRESULT ECTableManager::OpenOutgoingQueueTable(unsigned int ulStoreId, unsigned int *lpulTableId)
155	150	{

650	645	{
651	646	ECRESULT er = erSuccess;
652	647	std::map<unsigned int, TABLE_ENTRY *>::const_iterator iterTables;
653		std::map<unsigned int, unsigned int>::const_iterator iterFolders;
654	648
655	649	sObjectTableKey sRow;
656	650

+8

-8

provider/libserver/ECTestProtocol.cpp less more

30	30	{
31	31	ECRESULT er = erSuccess;
32	32
33		if(stricmp(szCommand, "purge_deferred") == 0) {
	33	if(strcasecmp(szCommand, "purge_deferred") == 0) {
34	34	while (1) {
35	35	unsigned int ulFolderId = 0;
36	36	ECDatabase *lpDatabase = NULL;

50	50	return er;
51	51	}
52	52
53		} else if (stricmp(szCommand, "indexer_syncrun") == 0) {
	53	} else if (strcasecmp(szCommand, "indexer_syncrun") == 0) {
54	54	if (parseBool(g_lpSessionManager->GetConfig()->GetSetting("search_enabled"))) {
55	55	er = ECSearchClient(
56	56	g_lpSessionManager->GetConfig()->GetSetting("search_socket"),
57	57	60 * 10 /* 10 minutes should be enough for everyone */
58	58	).SyncRun();
59	59	}
60		} else if (stricmp(szCommand, "run_searchfolders") == 0) {
	60	} else if (strcasecmp(szCommand, "run_searchfolders") == 0) {
61	61	lpSession->GetSessionManager()->GetSearchFolders()->FlushAndWait();
62		} else if (stricmp(szCommand, "kill_sessions") == 0) {
	62	} else if (strcasecmp(szCommand, "kill_sessions") == 0) {
63	63	ECSESSIONID id = lpSession->GetSessionId();
64	64
65	65	// Remove all sessions except our own
66	66	er = lpSession->GetSessionManager()->CancelAllSessions(id);
67		} else if(stricmp(szCommand, "sleep") == 0) {
	67	} else if(strcasecmp(szCommand, "sleep") == 0) {
68	68	if(ulArgs == 1 && args[0])
69	69	Sleep(atoui(args[0]) * 1000);
70	70	}

75	75	{
76	76	ECRESULT er = erSuccess;
77	77
78		if(stricmp(szVarName, "cell_cache_disabled") == 0) {
	78	if(strcasecmp(szVarName, "cell_cache_disabled") == 0) {
79	79	if(atoi(szValue) > 0)
80	80	g_lpSessionManager->GetCacheManager()->DisableCellCache();
81	81	else
82	82	g_lpSessionManager->GetCacheManager()->EnableCellCache();
83	83
84		} else if (stricmp(szVarName, "search_enabled") == 0) {
	84	} else if (strcasecmp(szVarName, "search_enabled") == 0) {
85	85	// Since there's no object that represents the indexer, it's probably cleanest to
86	86	// update the configuration.
87	87	if (atoi(szValue) > 0)

97	97	{
98	98	ECRESULT er = erSuccess;
99	99
100		if(!stricmp(szVarName, "ping")) {
	100	if(!strcasecmp(szVarName, "ping")) {
101	101	*szValue = s_strcpy(soap, "pong");
102	102	} else {
103	103	er = KCERR_NOT_FOUND;

+9

-69

provider/libserver/ECUserManagement.cpp less more

34	34	#include "SymmetricCrypt.h"
35	35	#include "ECPamAuth.h"
36	36	#include "ECKrbAuth.h"
37		#ifdef LINUX
38	37	#include <kopano/UnixUtil.h>
39		#else
40		#include "WinUtil.h"
41		#endif
42
43	38	#include <kopano/base64.h>
44	39
45	40	#include "ECICS.h"

57	52	#include <boost/algorithm/string.hpp>
58	53	namespace ba = boost::algorithm;
59	54
60		#ifdef _DEBUG
61		#define new DEBUG_NEW
62		#endif
63	55	#ifndef AB_UNICODE_OK
64	56	#define AB_UNICODE_OK ((ULONG) 0x00000040)
65	57	#endif

98	90	for (i = lstEnv.begin(); i != lstEnv.end(); ++i)
99	91	env[n++] = i->c_str();
100	92	env[n] = NULL;
101
102		#ifdef LINUX
103	93	return unix_system(scriptname, scriptname, env);
104		#else
105		return win_system(scriptname, scriptname, env);
106		#endif
107		}
108
109		#if 0
110		static std::string HostnameFromSoap(struct soap *soap)
111		{
112		/*
113		* Is the client connecting using an IP address or fully qualified hostname?
114		* SOAP knows... SOAP is all-knowing.
115		*/
116		if (soap->host[0] == '\0') {
117		/* Use the endpoint which is something like: http://<ip>:<port>/<path>*/
118		std::string ip = soap->endpoint;
119		size_t pos;
120
121		pos = ip.find("://");
122		if (pos != std::string::npos)
123		ip.erase(0, ip.find_first_not_of(":/", pos));
124
125		pos = ip.find_first_of(":/");
126		if (pos != std::string::npos)
127		ip.erase(pos, std::string::npos);
128
129		return ip;
130		}
131		return std::string(soap->host);
132		}
133		#endif
	94	}
134	95
135	96	static const char *ObjectClassToName(objectclass_t objclass)
136	97	{

1230	1191	if ((OBJECTCLASS_TYPE(objclass) == OBJECTTYPE_UNKNOWN \|\|
1231	1192	objclass == OBJECTCLASS_USER \|\|
1232	1193	objclass == ACTIVE_USER) &&
1233		stricmp(szName, KOPANO_ACCOUNT_SYSTEM) == 0)
	1194	strcasecmp(szName, KOPANO_ACCOUNT_SYSTEM) == 0)
1234	1195	{
1235	1196	*lpulObjectId = KOPANO_UID_SYSTEM;
1236	1197	return er;
1237	1198	} else if ((OBJECTCLASS_TYPE(objclass) == OBJECTTYPE_UNKNOWN \|\|
1238	1199	objclass == OBJECTCLASS_DISTLIST \|\|
1239	1200	objclass == DISTLIST_SECURITY) &&
1240		stricmp(szName, KOPANO_FULLNAME_EVERYONE) == 0)
	1201	strcasecmp(szName, KOPANO_FULLNAME_EVERYONE) == 0)
1241	1202	{
1242	1203	*lpulObjectId = KOPANO_UID_EVERYONE;
1243	1204	return er;

1731	1692	return er;
1732	1693
1733	1694	// Special case: SYSTEM
1734		if (stricmp(szSearchString, KOPANO_ACCOUNT_SYSTEM) == 0) {
	1695	if (strcasecmp(szSearchString, KOPANO_ACCOUNT_SYSTEM) == 0) {
1735	1696	// Hide user SYSTEM when requested
1736	1697	if (lpSecurity->GetUserId() != KOPANO_UID_SYSTEM) {
1737	1698	szHideSystem = m_lpConfig->GetSetting("hide_system");

1741	1702
1742	1703	*lpulID = KOPANO_UID_SYSTEM;
1743	1704	return erSuccess;
1744		} else if (stricmp(szSearchString, KOPANO_ACCOUNT_EVERYONE) == 0) {
	1705	} else if (strcasecmp(szSearchString, KOPANO_ACCOUNT_EVERYONE) == 0) {
1745	1706	// Hide group everyone when requested
1746	1707	if (lpSecurity->GetUserId() != KOPANO_UID_SYSTEM) {
1747	1708	szHideEveryone = m_lpConfig->GetSetting("hide_everyone");

2318	2279	list<objectid_t> lstExternIDs;
2319	2280	map<objectid_t, unsigned int> mapLocalIDs;
2320	2281	std::map<objectid_t, unsigned int>::const_iterator iterLocalIDs;
2321		string strQuery;
2322	2282	objectid_t sExternID;
2323	2283	unsigned int ulLocalID = 0;
2324	2284

2558	2518	ECRESULT ECUserManagement::CheckUserLicense(unsigned int *lpulLicenseStatus)
2559	2519	{
2560	2520	ECRESULT er;
2561		std::string strQuery;
2562	2521	unsigned int ulTotalUsers = 0;
2563	2522	unsigned int ulActive = 0;
2564	2523	unsigned int ulNonActive = 0;

2728	2687	case NONACTIVE_ROOM:
2729	2688	case NONACTIVE_EQUIPMENT:
2730	2689	strUserServer = details.GetPropString(OB_PROP_S_SERVERNAME);
2731		if (!bDistributed \|\| stricmp(strUserServer.c_str(), strThisServer.c_str()) == 0) {
	2690	if (!bDistributed \|\| strcasecmp(strUserServer.c_str(), strThisServer.c_str()) == 0) {
2732	2691	execute_script(m_lpConfig->GetSetting("createuser_script"),
2733	2692	"KOPANO_USER", details.GetPropString(OB_PROP_S_LOGIN).c_str(),
2734	2693	NULL);

2742	2701	break;
2743	2702	case CONTAINER_COMPANY:
2744	2703	strUserServer = details.GetPropString(OB_PROP_S_SERVERNAME);
2745		if (!bDistributed \|\| stricmp(strUserServer.c_str(), strThisServer.c_str()) == 0) {
	2704	if (!bDistributed \|\| strcasecmp(strUserServer.c_str(), strThisServer.c_str()) == 0) {
2746	2705	execute_script(m_lpConfig->GetSetting("createcompany_script"),
2747	2706	"KOPANO_COMPANY", details.GetPropString(OB_PROP_S_FULLNAME).c_str(),
2748	2707	NULL);

3262	3221	if(er != erSuccess)
3263	3222	goto exit;
3264	3223
3265		// Object didn't exist locally, so no delete has occured
	3224	// Object didn't exist locally, so no delete has occurred
3266	3225	if (ulDeletedRows == 0) {
3267	3226	er = lpDatabase->Commit();
3268	3227	if (er != erSuccess)

3516	3475	struct propVal *lpPropVal;
3517	3476	unsigned int ulOrder = 0;
3518	3477	ECSecurity *lpSecurity = NULL;
3519		std::string strEncExId;
3520	3478	struct propValArray sPropVals{__gszeroinit};
3521	3479	struct propValArray *lpPropVals = &sPropVals;
3522	3480	ULONG ulMapiType = 0;

4085	4043	struct propVal *lpPropVal;
4086	4044	unsigned int ulOrder = 0;
4087	4045	ECSecurity *lpSecurity = NULL;
4088		std::string strEncExId;
4089	4046	ULONG ulMapiType = 0;
4090	4047
4091	4048	er = GetSecurity(&lpSecurity);

4411	4368	if(lpSession)
4412	4369	lpSession->GetClientApp(&strApp);
4413	4370
4414		if(strnicmp(strApp.c_str(), "blackberry", 10) == 0) {
	4371	if(strncasecmp(strApp.c_str(), "blackberry", 10) == 0) {
4415	4372	// For blackberry, we pose as being the Exchange AddressList. We have to do this
4416	4373	// since it searches for the GAB by restricting by this GUID, otherwise the Lookup
4417	4374	// function will not function properly.

4684	4641	ECRESULT ECUserManagement::ProcessModification(unsigned int ulId, const std::string &newsignature)
4685	4642	{
4686	4643	ECRESULT er;
4687		std::string strQuery;
4688	4644	ECDatabase *lpDatabase = NULL;
4689	4645	ABEID eid(MAPI_ABCONT, MUIDECSAB, 1);
4690	4646	SOURCEKEY sSourceKey;

4849	4805	return erSuccess;
4850	4806	}
4851	4807
4852		ECRESULT ECUserManagement::RemoveAllObjectsAndSync(unsigned int ulObjId)
4853		{
4854		ECRESULT er;
4855		UserPlugin *lpPlugin = NULL;
4856		objectid_t id;
4857
4858		er = GetThreadLocalPlugin(m_lpPluginFactory, &lpPlugin);
4859		if(er != erSuccess)
4860		return er;
4861		er = GetExternalId(ulObjId, &id);
4862		if(er != erSuccess)
4863		return er;
4864		lpPlugin->removeAllObjects(id);
4865		return SyncAllObjects();
4866		}
4867
4868	4808	ECRESULT ECUserManagement::SyncAllObjects()
4869	4809	{
4870	4810	ECRESULT er = erSuccess;

+0

-3

provider/libserver/ECUserManagement.h less more

212	212	/* Create an ABEID in version 1 or version 0 */
213	213	ECRESULT CreateABEntryID(struct soap soap, unsigned int ulVersion, unsigned int ulObjId, unsigned int ulType, objectid_t sExternId, gsoap_size_t lpcbEID, ABEID *lppEid);
214	214
215		/* Completely remove all users, groups, etc except for the passed object */
216		ECRESULT RemoveAllObjectsAndSync(unsigned int ulObjId);
217
218	215	/* Resync all objects from the plugin. */
219	216	ECRESULT SyncAllObjects();
220	217

+0

-5

provider/libserver/ECUserManagementOffline.cpp less more

17	17	#include <kopano/platform.h>
18	18
19	19	#include "ECUserManagementOffline.h"
20
21		#ifdef _DEBUG
22		#define new DEBUG_NEW
23		#endif
24	20
25	21	ECUserManagementOffline::ECUserManagementOffline(ECSession *lpSession,
26	22	ECPluginFactory lpPluginFactory, ECConfig lpConfig) :

74	70
75	71	lpUsers->push_back(localuserdetails_t(m_ulUserId, details));
76	72
77
78	73	*lppUsers = lpUsers;
79	74	return erSuccess;
80	75	}

+0

-4

provider/libserver/ECUserStoreTable.cpp less more

26	26	#include "ECGenProps.h"
27	27	#include "ECSession.h"
28	28	#include <kopano/stringutil.h>
29
30		#ifdef _DEBUG
31		#define new DEBUG_NEW
32		#endif
33	29
34	30	// 1 == MAPI_STORE.. does it even matter?
35	31	ECUserStoreTable::ECUserStoreTable(ECSession *lpSession, unsigned int ulFlags, const ECLocale &locale) :

+0

-90

~~provider/libserver/Makefile.am~~ less more

0		# -- Makefile --
1
2		AM_CPPFLAGS = ${ZCPPFLAGS} ${DEBUGFLAGS} ${BOOST_CPPFLAGS} \
3		-I${top_srcdir}/mapi4linux/include \
4		-I${top_srcdir}/provider/libserver -I${top_srcdir}/provider/plugins \
5		-I${top_srcdir}/provider/include -I${top_srcdir}/provider/common \
6		-I${top_srcdir}/provider/client -I${top_builddir}/provider/soap \
7		-I${top_srcdir}/provider/soap \
8		-I${top_srcdir}/common -I${top_srcdir}/m4lcommon \
9		-DPKGLIBDIR='"${pkglibdir}"' \
10		${MYSQL_INCLUDES} ${GSOAP_CFLAGS} ${SSL_CFLAGS} \
11		${SSL_HAS_EVP_PKEY_CMP} ${KRB5_CFLAGS} ${TCMALLOC_CFLAGS}
12
13		# We are not actually using any linked symbols from tcmalloc's header files,
14		# so linking to tcmalloc is not done, not here at least. It is done in
15		# provider/*/Makefile.am. Probably such that other components including
16		# libkcserver.la (provider/plugins/) _don't_ get tcmalloc.
17
18		pkginclude_HEADERS = include/kopano/ECPluginSharedData.h
19
20		lib_LTLIBRARIES = libkcserver.la
21		#noinst_DATA = libkcserver.ldd
22
23		libkcserver_la_SOURCES = \
24		cmd.cpp cmd.hpp \
25		ECABObjectTable.cpp ECABObjectTable.h \
26		ECCacheManager.cpp ECCacheManager.h \
27		ECDBDef.h ECDatabase.h \
28		ECDatabaseFactory.cpp ECDatabaseFactory.h \
29		ECDatabaseMySQL.cpp ECDatabaseMySQL.h \
30		ECDatabaseUtils.cpp ECDatabaseUtils.h \
31		ECDatabaseUpdate.cpp ECDatabaseUpdate.h \
32		ECGenProps.cpp ECGenProps.h \
33		ECGenericObjectTable.cpp ECGenericObjectTable.h \
34		ECICS.cpp ECICS.h \
35		ECICSHelpers.cpp ECICSHelpers.h \
36		ECMAPI.h \
37		ECNotification.cpp ECNotification.h \
38		ECPluginFactory.cpp ECPluginFactory.h \
39		ECPluginSharedData.cpp ECPluginSharedData.h \
40		ECPamAuth.cpp ECPamAuth.h \
41		ECKrbAuth.cpp ECKrbAuth.h \
42		ECSecurity.cpp ECSecurity.h \
43		ECServerEntrypoint.cpp ECServerEntrypoint.h \
44		ECSession.cpp ECSession.h \
45		ECSessionGroup.cpp ECSessionGroup.h \
46		ECSessionManager.cpp ECSessionManager.h \
47		ECStoreObjectTable.cpp ECStoreObjectTable.h \
48		ECStringCompat.cpp ECStringCompat.h \
49		ECSubRestriction.cpp ECSubRestriction.h \
50		ECTableManager.cpp ECTableManager.h \
51		ECUserManagement.cpp ECUserManagement.h \
52		ECSessionManagerOffline.cpp ECSessionManagerOffline.h \
53		ECUserManagementOffline.cpp ECUserManagementOffline.h \
54		ECSecurityOffline.cpp ECSecurityOffline.h \
55		ECSearchFolders.cpp ECSearchFolders.h \
56		ECSearchObjectTable.cpp ECSearchObjectTable.h \
57		ECConvenientDepthObjectTable.cpp ECConvenientDepthObjectTable.h \
58		ECConvenientDepthABObjectTable.cpp ECConvenientDepthABObjectTable.h \
59		ECMultiStoreTable.cpp ECMultiStoreTable.h \
60		ECUserStoreTable.cpp ECUserStoreTable.h \
61		ECConversion.cpp ECConversion.h \
62		ECS3Attachment.cpp ECS3Attachment.h \
63		ECAttachmentStorage.cpp ECAttachmentStorage.h \
64		ECStatsCollector.cpp ECStatsCollector.h \
65		ECStatsTables.cpp ECStatsTables.h \
66		ECNotificationManager.cpp ECNotificationManager.h \
67		ECIndexer.cpp ECIndexer.h \
68		StreamUtil.cpp StreamUtil.h \
69		StorageUtil.cpp StorageUtil.h \
70		ECTPropsPurge.cpp ECTPropsPurge.h \
71		ECMailBoxTable.cpp ECMailBoxTable.h \
72		ECTestProtocol.cpp ECTestProtocol.h \
73		cmdutil.cpp cmdutil.hpp logontime.cpp logontime.hpp \
74		ECLockManager.cpp ECLockManager.h
75		libkcserver_la_LIBADD = \
76		../../common/libkcutil.la ../common/libkccommon.la \
77		-lpthread ${icu_i18n_LIBS} ${icu_uc_LIBS} \
78		${KRB5_LIBS} ${MYSQL_LIBS} ${PAM_LIBS} ${SSL_LIBS} \
79		${TCMALLOC_LIBS} ${s3_LIBS}
80		libkcserver_la_LDFLAGS = ${AM_LDFLAGS} \
81		-Wl,--version-script=${top_builddir}/default.sym
82		EXTRA_libkcserver_la_DEPENDENCIES = ${top_builddir}/default.sym
83
84
85		check-syntax:
86		$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \
87		-fsyntax-only -fmessage-length=0 ${CHK_SOURCES} -Wall -Wformat=2
88
89		include ../../global.am

+30

-0

provider/libserver/README.md less more

	0	Libserver
	1	=========
	2
	3	Libserver is splitted for historical reasons in libserver/server.
	4	There is no reason to keep this code in different places.
	5
	6
	7	ECCacheManager
	8	--------------
	9
	10	The ECCacheManager caches some specific MySQL table items in a hash map.
	11	For example for the hierarchtable it is stored as <id, (hierarchyid, parentid, fooid>.
	12	When the cache limit is hit, we randomly remove 5% of the items.
	13
	14	The sort() operation on unordered hashmaps is very expensive
	15	so you might notice cache spikes everytime the cache is cleaned.
	16	A possible solution is randomly removing the cache entries.
	17
	18	+-------------------------------------------------------------+
	19	\| \|
	20	\| \|
	21	cache --+\| xxxxxxxx xxxxxxxx xxxxxxxxxx xxxxxxxxxxxxxx\|
	22	limit \| xxx x x x x x x \|
	23	\| xxxx x x x \|
	24	\| xxxx \|
	25	\| xx \|
	26	\| xxx \|
	27	\| xxxx \|
	28	\|xxx \|
	29	xx------------------------------------------------------------+

+0

-5

provider/libserver/StorageUtil.cpp less more

27	27	// External objects
28	28	extern ECSessionManager *g_lpSessionManager; // ECServerEntrypoint.cpp
29	29
30
31	30	ECRESULT CreateAttachmentStorage(ECDatabase lpDatabase, ECAttachmentStorage *lppAttachmentStorage)
32	31	{
33	32	return ECAttachmentStorage::CreateAttachmentStorage(lpDatabase, g_lpSessionManager->GetConfig(), lppAttachmentStorage);
34	33	}
35
36	34
37	35	ECRESULT CreateObject(ECSession lpecSession, ECDatabase lpDatabase, unsigned int ulParentObjId, unsigned int ulParentType, unsigned int ulObjType, unsigned int ulFlags, unsigned int *lpulObjId)
38	36	{

78	76	return erSuccess;
79	77	}
80	78
81
82	79	/* Get the size of an object, PR_MESSAGE_SIZE or PR_ATTACH_SIZE */
83	80	ECRESULT GetObjectSize(ECDatabase* lpDatabase, unsigned int ulObjId, unsigned int* lpulSize)
84	81	{

117	114
118	115	return er;
119	116	}
120
121	117
122	118	ECRESULT CalculateObjectSize(ECDatabase* lpDatabase, unsigned int objid, unsigned int ulObjType, unsigned int* lpulSize)
123	119	{

201	197
202	198	return er;
203	199	}
204
205	200
206	201	ECRESULT UpdateObjectSize(ECDatabase* lpDatabase, unsigned int ulObjId, unsigned int ulObjType, eSizeUpdateAction updateAction, long long llSize)
207	202	{

+2

-45

provider/libserver/StreamUtil.cpp less more

43	43	#include <map>
44	44	#include <string>
45	45
46		#ifdef _DEBUG
47		#define new DEBUG_NEW
48		#endif
49
50	46	/*
51	47	streams are as follows:
52	48	<version>

58	54	<# of sub objects>:32bit
59	55	<subobject>
60	56
61
62	57	properties are as follows:
63	58	<prop tag>:32bit
64	59	[<length in bytes>:32bit]
65	60	<data bytes>
66	61	[<guid, kind, [id\|bytes+string>]
67
68	62
69	63	subobjects are as follows:
70	64	<type>:32bit

114	108	nameidmap_t m_mapNameIds;
115	109	namestringmap_t m_mapNameStrings;
116	110	};
117
118	111
119	112	NamedPropertyMapper::NamedPropertyMapper(ECDatabase *lpDatabase)
120	113	: m_lpDatabase(lpDatabase)

172	165	// *lpulId now contains the local propid, update the cache
173	166	m_mapNameIds.insert(nameidmap_t::value_type(key, *lpulId));
174	167
175
176	168	exit:
177	169	if (lpResult)
178	170	m_lpDatabase->FreeResult(lpResult);

230	222	// *lpulId now contains the local propid, update the cache
231	223	m_mapNameStrings.insert(namestringmap_t::value_type(key, *lpulId));
232	224
233
234	225	exit:
235	226	if (lpResult)
236	227	m_lpDatabase->FreeResult(lpResult);
237	228
238	229	return er;
239	230	}
240
241	231
242	232	// Utility Functions
243	233	ECRESULT SerializeDatabasePropVal(LPCSTREAMCAPS lpStreamCaps, DB_ROW lpRow, DB_LENGTHS lpLen, ECSerializer *lpSink)

338	328	er = KCERR_NOT_FOUND;
339	329	goto exit;
340	330	}
341		li = _atoi64(lpRow[FIELD_NR_LONGINT]);
	331	li = atoll(lpRow[FIELD_NR_LONGINT]);
342	332	er = lpSink->Write(&li, sizeof(li), 1);
343	333	break;
344	334	case PT_STRING8:

505	495	ulLastPos = 0;
506	496	for (unsigned int x = 0; er == erSuccess && x < ulCount; ++x) {
507	497	ParseMVProp(lpRow[FIELD_NR_LONGINT], lpLen[FIELD_NR_LONGINT], &ulLastPos, &strData);
508		li = _atoi64(strData.c_str());
	498	li = atoll(strData.c_str());
509	499	er = lpSink->Write(&li, sizeof(li), 1);
510	500	}
511	501	break;

553	543	unsigned int ulLen;
554	544	unsigned char b;
555	545	unsigned int ulPropTag = sPropVal.ulPropTag;
556		std::string strData;
557	546	convert_context converter;
558	547	NamedPropDefMap::const_iterator iNamedPropDef;
559	548

1419	1408	CopyPropVal(lpsPropval, lpPropValArray->__ptr + lpPropValArray->__size++);
1420	1409	}
1421	1410
1422
1423	1411	// Make sure we dont have a colliding PR_SOURCE_KEY. This can happen if a user imports an exported message for example.
1424	1412	if (lpsPropval->ulPropTag == PR_SOURCE_KEY) {
1425	1413	// don't use the sourcekey if found.

1440	1428	// We can't use lpDBRow here except for checking if it was NULL.
1441	1429	if (lpDBRow != NULL)
1442	1430	continue;
1443
1444	1431
1445	1432	strQuery = "REPLACE INTO indexedproperties(hierarchyid,tag,val_binary) VALUES (" + stringify(ulObjId) + "," + stringify(PROP_ID(PR_SOURCE_KEY)) + "," + lpDatabase->EscapeBinary(lpsPropval->Value.bin->__ptr, lpsPropval->Value.bin->__size) + ")";
1446	1433	er = lpDatabase->DoInsert(strQuery);

1648	1635	if (er != erSuccess)
1649	1636	goto exit;
1650	1637
1651
1652
1653	1638	if (ulParentType == MAPI_FOLDER) {
1654	1639	sObjectTableKey key(ulObjId, 0);
1655	1640	propVal sProp;

1676	1661	if (er != erSuccess)
1677	1662	goto exit;
1678	1663	}
1679
1680
1681	1664
1682	1665	if (ulRealObjType == MAPI_MESSAGE \|\| ulRealObjType == MAPI_ATTACH) {
1683	1666	unsigned int ulSubObjCount = 0;

1796	1779	return er;
1797	1780	}
1798	1781
1799
1800	1782	ECRESULT GetValidatedPropType(DB_ROW lpRow, unsigned int *lpulType)
1801	1783	{
1802	1784	ECRESULT er = KCERR_DATABASE_ERROR;

1889	1871	*lpulType = ulType;
1890	1872	return erSuccess;
1891	1873	}
1892
1893		ECRESULT GetValidatedPropCount(ECDatabase lpDatabase, DB_RESULT lpDBResult, unsigned int lpulCount)
1894		{
1895		ECRESULT er;
1896		unsigned int ulCount = 0;
1897		DB_ROW lpRow;
1898
1899		if (lpDatabase == NULL \|\| lpDBResult == NULL \|\| lpulCount == 0)
1900		return KCERR_INVALID_PARAMETER;
1901
1902		while ((lpRow = lpDatabase->FetchRow(lpDBResult)) != NULL) {
1903		unsigned int ulType;
1904		er = GetValidatedPropType(lpRow, &ulType); // Ignore ulType, we just need the validation
1905		if (er == KCERR_DATABASE_ERROR) {
1906		ec_log_err("GetValidatedPropCount(): GetValidatedPropType failed");
1907		continue;
1908		} else if (er != erSuccess)
1909		return er;
1910		++ulCount;
1911		}
1912
1913		lpDatabase->ResetResult(lpDBResult);
1914		*lpulCount = ulCount;
1915		return erSuccess;
1916		}

+0

-1

provider/libserver/StreamUtil.h less more

49	49	ECRESULT DeserializeObject(ECSession lpecSession, ECDatabase lpDatabase, ECAttachmentStorage lpAttachmentStorage, LPCSTREAMCAPS lpStreamInfo, unsigned int ulObjId, unsigned int ulStoreId, GUID lpsGuid, bool bNewItem, unsigned long long ullIMAP, ECSerializer lpSource, struct propValArray *lppPropValArray);
50	50
51	51	ECRESULT GetValidatedPropType(DB_ROW lpRow, unsigned int *lpulType);
52		ECRESULT GetValidatedPropCount(ECDatabase lpDatabase, DB_RESULT lpDBResult, unsigned int lpulCount);
53	52
54	53	#endif // ndef STREAMUTIL_H

+23

-66

provider/libserver/cmd.cpp less more

72	72	#include "ECTPropsPurge.h"
73	73	#include "versions.h"
74	74	#include "ECTestProtocol.h"
75		#include "ECTPropsPurge.h"
76	75
77	76	#include <kopano/ECDefs.h>
78	77	#include <kopano/EMSAbTag.h>

88	87	#include "logontime.hpp"
89	88
90	89	#if defined(HAVE_GPERFTOOLS_MALLOC_EXTENSION_H)
91		# include <gperftools/malloc_extension.h>
	90	# include <gperftools/malloc_extension_c.h>
92	91	#elif defined(HAVE_GOOGLE_MALLOC_EXTENSION_H)
93		# include <google/malloc_extension.h>
	92	# include <google/malloc_extension_c.h>
94	93	#endif
95	94
96	95	#define STRIN_FIX(s) (bSupportUnicode ? (s) : ECStringCompat::WTF1252_to_UTF8(soap, (s)))

99	98
100	99	#define LOG_SOAP_DEBUG(_msg, ...) \
101	100	ec_log(EC_LOGLEVEL_DEBUG \| EC_LOGLEVEL_SOAP, "soap: " _msg, ##__VA_ARGS__)
102
103		#ifdef _DEBUG
104		#define new DEBUG_NEW
105		#endif
106	101
107	102	extern ECSessionManager* g_lpSessionManager;
108	103	extern ECStatsCollector* g_lpStatsCollector;

242	237	if (ulUserId == 2) // Everyone, public in single tennant
243	238	*lpbHasLocalStore = true;
244	239	else
245		*lpbHasLocalStore = (stricmp(sDetails.GetPropString(OB_PROP_S_SERVERNAME).c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) == 0);
	240	*lpbHasLocalStore = (strcasecmp(sDetails.GetPropString(OB_PROP_S_SERVERNAME).c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) == 0);
246	241	} else // Archive store
247	242	*lpbHasLocalStore = sDetails.PropListStringContains((property_key_t)PR_EC_ARCHIVE_SERVERS_A, g_lpSessionManager->GetConfig()->GetSetting("server_name"), true);
248	243	} else // Single tennant

289	284
290	285	// First check if we're connecting through unix-socket/named-pipe and if the request url matches this server
291	286	if (SOAP_CONNECTION_TYPE_NAMED_PIPE(soap) &&
292		stricmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) == 0)
	287	strcasecmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) == 0)
293	288	bResult = true;
294	289
295	290	else

587	582	goto exit;
588	583
589	584	lpszEnabled = g_lpSessionManager->GetConfig()->GetSetting("enable_sso");
590		if (!(lpszEnabled && stricmp(lpszEnabled, "yes") == 0))
	585	if (!(lpszEnabled && strcasecmp(lpszEnabled, "yes") == 0))
591	586	goto nosso;
592	587
593	588	lpsResponse->lpszVersion = const_cast<char *>("0," PROJECT_VERSION_SERVER_STR);

784	779	} \
785	780	return SOAP_OK;
786	781
787
788	782	// This is the variadic macro we would like to use. Unfortunately, the win32 vc++ compiler
789	783	// doesn't understand variadic macro's, so we have to split them into the cases below...
790	784	#define SOAP_ENTRY_START(fname,resultvar,...) \

795	789	#define SOAP_ENTRY_END() \
796	790	SOAP_ENTRY_FUNCTION_FOOTER \
797	791	}
798
799	792
800	793	#define ALLOC_DBRESULT() \
801	794	DB_ROW UNUSED_VAR lpDBRow = NULL; \

823	816	#define ROLLBACK_ON_ERROR() \
824	817	if (lpDatabase && FAILED(er)) \
825	818	lpDatabase->Rollback(); \
826
827	819
828	820	static ECRESULT PurgeSoftDelete(ECSession *lpecSession,
829	821	unsigned int ulLifetime, unsigned int *lpulMessages,

1083	1075	}
1084	1076
1085	1077	/* Do we own the store? */
1086		if (stricmp(strThisServer.c_str(), strStoreServer.c_str()) != 0)
	1078	if (strcasecmp(strThisServer.c_str(), strStoreServer.c_str()) != 0)
1087	1079	{
1088	1080	if ((ulFlags & EC_OVERRIDE_HOMESERVER) == 0) {
1089	1081	er = GetBestServerPath(soap, lpecSession, strStoreServer, &strServerPath);

1177	1169	er = KCERR_NOT_FOUND;
1178	1170	goto exit;
1179	1171	}
1180		if (stricmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) != 0) {
	1172	if (strcasecmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) != 0) {
1181	1173	er = GetBestServerPath(soap, lpecSession, strServerName, &strServerPath);
1182	1174	if (er != erSuccess)
1183	1175	goto exit;

1519	1511	if(er != erSuccess)
1520	1512	goto exit;
1521	1513
1522
1523	1514	exit:
1524	1515	FREE_DBRESULT();
1525	1516

1649	1640	if(lpDBRow == NULL \|\| lpDBRow[0] == NULL)
1650	1641	llSize = 0;
1651	1642	else
1652		llSize = _atoi64(lpDBRow[0]);
	1643	llSize = atoll(lpDBRow[0]);
1653	1644
1654	1645	// Free results
1655	1646	if(lpDBResult) { lpDatabase->FreeResult(lpDBResult); lpDBResult = NULL; }

2025	2016
2026	2017	if (lpfHaveChangeKey && lpPropValArray->__ptr[i].ulPropTag == PR_CHANGE_KEY)
2027	2018	*lpfHaveChangeKey = true;
2028
2029	2019
2030	2020	if((PROP_TYPE(lpPropValArray->__ptr[i].ulPropTag) & MV_FLAG) == MV_FLAG) {
2031	2021	// Make sure string prop_types become PT_MV_STRING8

2303	2293
2304	2294	g_lpSessionManager->GetCacheManager()->SetObjectProp(PROP_ID(PR_SOURCE_KEY), sSourceKey.size(), sSourceKey, ulObjId);
2305	2295	}
2306
2307	2296
2308	2297	if(ulParentType == MAPI_FOLDER) {
2309	2298	// Add a PR_EC_IMAP_ID to the newly created message

2706	2695	++n;
2707	2696	}
2708	2697
2709
2710	2698	// set actual array size
2711	2699	lpsReturnObj->delProps.__size = n;
2712	2700	lpsReturnObj->modProps.__size = n;

3193	3181	goto exit;
3194	3182	}
3195	3183
3196		if (stricmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) != 0) {
	3184	if (strcasecmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) != 0) {
3197	3185	er = KCERR_UNABLE_TO_COMPLETE; // Reason 2
3198	3186	goto exit;
3199	3187	}

3232	3220	ulParentObjType = MAPI_FOLDER;
3233	3221	} else if(ulObjType == MAPI_FOLDER) {
3234	3222
3235
3236	3223	// Disable searchfolder for delegate stores without admin permissions
3237	3224	if ( (ulObjFlags&FOLDER_SEARCH) && lpecSession->GetSecurity()->GetAdminLevel() == 0 &&
3238	3225	lpecSession->GetSecurity()->IsStoreOwner(ulObjId) != erSuccess)

3334	3321	if(er != erSuccess)
3335	3322	goto exit;
3336	3323
3337
3338	3324	while (!bExist && (lpDBRow = lpDatabase->FetchRow(lpDBResult)) != NULL) {
3339	3325	if (lpDBRow[0] == NULL \|\| lpDBRow[1] == NULL) {
3340	3326	er = KCERR_DATABASE_ERROR;

3342	3328	goto exit;
3343	3329	}
3344	3330
3345		if (stricmp(lpDBRow[1], name) == 0)
	3331	if (strcasecmp(lpDBRow[1], name) == 0)
3346	3332	bExist = true;
3347	3333	}
3348
3349	3334
3350	3335	if(bExist && !ulSyncId) {
3351	3336	// Check folder read access

3499	3484
3500	3485	// Update all tables viewing this folder
3501	3486	g_lpSessionManager->UpdateTables(ECKeyTable::TABLE_ROW_ADD, 0, ulParentId, ulFolderId, MAPI_FOLDER);
3502
3503	3487
3504	3488	// Update notification, grandparent of the mainfolder
3505	3489	g_lpSessionManager->UpdateTables(ECKeyTable::TABLE_ROW_MODIFY, 0, ulGrandParent, ulParentId, MAPI_FOLDER);

4162	4146	ECMultiStoreTable *lpMultiStoreTable = NULL;
4163	4147	ECListInt lObjectList;
4164	4148
4165
4166	4149	if(lpEntryList == NULL) {
4167	4150	er = KCERR_INVALID_PARAMETER;
4168	4151	goto exit;

4826	4809	er = KCERR_NOT_FOUND;
4827	4810	}
4828	4811
4829
4830	4812	exit:
4831	4813	FREE_DBRESULT();
4832	4814	}

4915	4897	FREE_DBRESULT();
4916	4898	}
4917	4899
4918
4919	4900	strQuery = "SELECT objid, id FROM receivefolder WHERE storeid="+stringify(ulStoreid)+" AND messageclass='"+lpDatabase->Escape(lpszMessageClass)+"'";
4920	4901	er = lpDatabase->DoSelect(strQuery, &lpDBResult);
4921	4902	if(er != erSuccess)

4952	4933	er = lpecSession->GetSecurity()->CheckPermission(ulStoreid, ecSecurityCreate);
4953	4934	if(er != erSuccess)
4954	4935	goto exit;
4955
4956	4936
4957	4937	if(bIsUpdate) {
4958	4938	strQuery = "UPDATE receivefolder SET objid="+stringify(ulId);

5150	5130	if(er != erSuccess)
5151	5131	goto exit;
5152	5132
5153
5154	5133	while( (lpDBRow = lpDatabase->FetchRow(lpDBResult)) )
5155	5134	{
5156	5135	if(lpDBRow[0] == NULL \|\| lpDBRow[1] == NULL){

5193	5172	er = lpDatabase->DoUpdate(strQuery);
5194	5173	if(er != erSuccess)
5195	5174	goto exit;
5196
5197	5175
5198	5176	er = UpdateTProp(lpDatabase, PR_MESSAGE_FLAGS, ulParent, &lHierarchyIDs); // FIXME ulParent is not constant for all lHierarchyIDs
5199	5177	if(er != erSuccess)

5727	5705	er = g_lpSessionManager->GetCacheManager()->PurgeCache(ulFlags);
5728	5706
5729	5707	#ifdef HAVE_TCMALLOC
5730		MallocExtension::instance()->ReleaseFreeMemory();
	5708	{
	5709	auto rfm = reinterpret_cast<decltype(MallocExtension_ReleaseFreeMemory) *>
	5710	(dlsym(NULL, "MallocExtension_ReleaseFreeMemory"));
	5711	if (rfm != NULL)
	5712	rfm();
	5713	}
5731	5714	#endif
5732	5715
5733	5716	g_lpStatsCollector->SetTime(SCN_SERVER_LAST_CACHECLEARED, time(NULL));

5916	5899	if(er != erSuccess)
5917	5900	goto exit;
5918	5901
5919
5920	5902	// Set ACL's on public store
5921	5903	if(ulStoreType == ECSTORE_TYPE_PUBLIC) {
5922	5904	// ulUserId == a group

7150	7132	if(er != erSuccess)
7151	7133	goto exit;
7152	7134
7153
7154	7135	// Remove messge from the outgoing queue
7155	7136	g_lpSessionManager->UpdateOutgoingTables(ECKeyTable::TABLE_ROW_DELETE, ulStoreId, ulObjId, ulFlags, MAPI_MESSAGE);
7156	7137

7265	7246	g_lpSessionManager->NotificationModified(MAPI_MESSAGE, ulObjId, ulParentId);
7266	7247	g_lpSessionManager->GetCacheManager()->Update(fnevObjectModified, ulParentId);
7267	7248	g_lpSessionManager->NotificationModified(MAPI_FOLDER, ulParentId);
7268
7269	7249
7270	7250	g_lpSessionManager->UpdateTables(ECKeyTable::TABLE_ROW_MODIFY, 0, ulParentId, ulObjId, MAPI_MESSAGE);
7271	7251	if(g_lpSessionManager->GetCacheManager()->GetParent(ulParentId, &ulGrandParentId) == erSuccess) {

7428	7408	goto exit;
7429	7409	}
7430	7410
7431		if (stricmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) != 0) {
	7411	if (strcasecmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) != 0) {
7432	7412	if ((ulFlags & OPENSTORE_OVERRIDE_HOME_MDB) == 0) {
7433	7413	string strServerPath;
7434	7414

7695	7675	// Check whether it is a move to the same parent, and if so, skip them.
7696	7676	if(iterCopyItems->ulParent == ulDestFolderId && (iterCopyItems->ulFlags&MSGFLAG_DELETED) == 0)
7697	7677	continue;
7698
7699	7678
7700	7679	er = g_lpSessionManager->GetCacheManager()->GetEntryIdFromObject(iterCopyItems->ulId, NULL, 0, &lpsOldEntryId);
7701	7680	if(er != erSuccess) {

7903	7882	}
7904	7883	}
7905	7884
7906
7907	7885	lstParent.sort();
7908	7886	lstParent.unique();
7909	7887

8175	8153	lpsNewEntryId = NULL;
8176	8154	}
8177	8155
8178
8179	8156	// Get child items of the message like , attachment, recipient...
8180	8157	strQuery = "SELECT id FROM hierarchy WHERE parent="+stringify(ulObjId);
8181	8158	er = lpDatabase->DoSelect(strQuery, &lpDBResult);
8182	8159	if (er != erSuccess) {
8183		ec_log_err("CopyObject: failed retriving child items of mesage: %s (%x)", GetMAPIErrorMessage(er), er);
	8160	ec_log_err("CopyObject: failed retrieving child items of message: %s (%x)", GetMAPIErrorMessage(er), er);
8184	8161	goto exit;
8185	8162	}
8186	8163

8320	8297	}
8321	8298	}
8322	8299
8323
8324	8300	g_lpSessionManager->GetCacheManager()->Update(fnevObjectModified, ulDestFolderId);
8325	8301
8326	8302	if(bDoNotification){

8498	8474	GetSourceKey(ulNewDestFolderId, &sSourceKey);
8499	8475
8500	8476	AddChange(lpecSession, ulSyncId, sSourceKey, sParentSourceKey, ICS_FOLDER_CHANGE);
8501
8502	8477
8503	8478	//Select all Messages of the home folder
8504	8479	// Skip deleted and associated items

9103	9078	er = lpDatabase->DoSelect(strQuery, &lpDBResult);
9104	9079	if(er != erSuccess)
9105	9080	goto exit;
9106
9107	9081
9108	9082	ulRows = lpDatabase->GetNumRows(lpDBResult);
9109	9083

10465	10439
10466	10440	SOAP_ENTRY_START(getLicenseAuth, lpsResponse->er, struct xsd__base64Binary sAuthData, struct getLicenseAuthResponse *lpsResponse)
10467	10441	{
10468		#ifdef LINUX
10469	10442	ECLicenseClient *lpLicenseClient = new ECLicenseClient();
10470		unsigned char *data = NULL;
	10443	void *data = NULL;
10471	10444
10472	10445	er = lpLicenseClient->Auth(sAuthData.__ptr, sAuthData.__size, &data, reinterpret_cast<unsigned int *>(&lpsResponse->sAuthResponse.__size));
10473	10446	if (er != erSuccess)

10477	10450	memcpy(lpsResponse->sAuthResponse.__ptr, data, lpsResponse->sAuthResponse.__size);
10478	10451
10479	10452	exit:
10480		delete[] data;
	10453	free(data);
10481	10454	delete lpLicenseClient;
10482		#else
10483		er = KCERR_NOT_IMPLEMENTED;
10484		#endif
10485	10455	}
10486	10456	SOAP_ENTRY_END()
10487	10457
10488	10458	SOAP_ENTRY_START(getLicenseCapa, lpsResponse->er, unsigned int ulServiceType, struct getLicenseCapaResponse *lpsResponse)
10489	10459	{
10490		#ifdef LINUX
10491	10460	ECLicenseClient *lpLicenseClient = new ECLicenseClient();
10492	10461	std::vector<std::string> lstCapabilities;
10493	10462

10503	10472	exit:
10504	10473
10505	10474	delete lpLicenseClient;
10506		#else
10507		er = KCERR_NOT_IMPLEMENTED;
10508		#endif
10509	10475	}
10510	10476	SOAP_ENTRY_END()
10511	10477
10512	10478	SOAP_ENTRY_START(getLicenseUsers, lpsResponse->er, unsigned int ulServiceType, struct getLicenseUsersResponse *lpsResponse)
10513	10479	{
10514		#ifdef LINUX
10515	10480	unsigned int ulUsers = 0;
10516	10481
10517	10482	ECLicenseClient *lpLicenseClient = new ECLicenseClient();

10526	10491	exit:
10527	10492
10528	10493	delete lpLicenseClient;
10529		#else
10530		er = KCERR_NOT_IMPLEMENTED;
10531		#endif
10532	10494	}
10533	10495	SOAP_ENTRY_END()
10534	10496

10562	10524	goto exit;
10563	10525
10564	10526	lpsResponse->lpszServerPath = STROUT_FIX_CPY(strServerPath.c_str());
10565		lpsResponse->bIsPeer = stricmp(g_lpSessionManager->GetConfig()->GetSetting("server_name"), lpszPseudoUrl + 9) == 0;
	10527	lpsResponse->bIsPeer = strcasecmp(g_lpSessionManager->GetConfig()->GetSetting("server_name"), lpszPseudoUrl + 9) == 0;
10566	10528
10567	10529	exit:
10568	10530	;

10611	10573	goto exit;
10612	10574
10613	10575
10614		if (stricmp(sDetails.GetServerName().c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) == 0)
	10576	if (strcasecmp(sDetails.GetServerName().c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) == 0)
10615	10577	lpsResponse->sServerList.__ptr[i].ulFlags \|= EC_SDFLAG_IS_PEER;
10616	10578
10617	10579	// note: "contains a public of a company" is also a possibility
10618		if (!strPublicServer.empty() && stricmp(sDetails.GetServerName().c_str(), strPublicServer.c_str()) == 0)
	10580	if (!strPublicServer.empty() && strcasecmp(sDetails.GetServerName().c_str(), strPublicServer.c_str()) == 0)
10619	10581	lpsResponse->sServerList.__ptr[i].ulFlags \|= EC_SDFLAG_HAS_PUBLIC;
10620	10582
10621	10583	if ((ulFlags & EC_SERVERDETAIL_NO_NAME) != EC_SERVERDETAIL_NO_NAME)

10682	10644	MTOMSessionInfo *lpSessionInfo;
10683	10645	} MTOMStreamInfo;
10684	10646
10685
10686	10647	typedef MTOMStreamInfo * LPMTOMStreamInfo;
10687	10648
10688	10649	static ECRESULT SerializeObject(void *arg)

10808	10769	delete lpInfo->lpThreadPool;
10809	10770	delete lpInfo;
10810	10771	}
10811
10812	10772
10813	10773	SOAP_ENTRY_START(exportMessageChangesAsStream, lpsResponse->er, unsigned int ulFlags, struct propTagArray sPropTags, struct sourceKeyPairArray sSourceKeyPairs, unsigned int ulPropTag, exportMessageChangesAsStreamResponse *lpsResponse)
10814	10774	{

11108	11068	soap->error = SOAP_FATAL_ERROR;
11109	11069	}
11110	11070	}
11111
11112	11071
11113	11072	SOAP_ENTRY_START(importMessageFromStream, result, unsigned int ulFlags, unsigned int ulSyncId, entryId sFolderEntryId, entryId sEntryId, bool bIsNew, struct propVal lpsConflictItems, struct xsd__Binary sStreamData, unsigned int *result)
11114	11073	{

11418	11377	if (er != erSuccess)
11419	11378	goto exit;
11420	11379
11421
11422	11380	// Get the Change Key
11423	11381	strQuery = "SELECT val_binary FROM properties "
11424	11382	"WHERE tag = " + stringify(PROP_ID(PR_CHANGE_KEY)) +

11445	11403	}
11446	11404
11447	11405	FREE_DBRESULT();
11448
11449	11406
11450	11407	// Get the Predecessor Change List
11451	11408	strQuery = "SELECT val_binary FROM properties "

+1

-10

provider/libserver/cmdutil.cpp less more

16	16
17	17	#include <kopano/platform.h>
18	18
19		// STL defines
20	19	#include <exception>
21	20	#include <set>
22	21	#include <string>
23	22	#include <list>
24	23	#include <map>
25	24
26		// mapi defines
27	25	#include <mapidefs.h>
28	26	#include <mapitags.h>
29	27	#include <kopano/mapiext.h>

48	46	#define FIELD_NR_NAMEID (FIELD_NR_MAX + 1)
49	47	#define FIELD_NR_NAMESTR (FIELD_NR_MAX + 2)
50	48	#define FIELD_NR_NAMEGUID (FIELD_NR_MAX + 3)
51
52		#ifdef _DEBUG
53		#define new DEBUG_NEW
54		#endif
55	49
56	50	extern ECSessionManager* g_lpSessionManager; // FIXME: remove this global and change the depended source code!
57	51	extern ECStatsCollector* g_lpStatsCollector;

510	504	PARENTINFO pi;
511	505
512	506	std::map<unsigned int, PARENTINFO> mapFolderCounts;
513		std::map<unsigned int, PARENTINFO>::const_iterator iterFolderCounts;
514	507
515	508	// Build where condition
516	509	for (iterDeleteItems=lstDeleteItems.begin();

1343	1336	return erSuccess;
1344	1337	}
1345	1338
1346
1347	1339	ECRESULT CheckQuota(ECSession *lpecSession, ULONG ulStoreId)
1348	1340	{
1349	1341	ECRESULT er;

1384	1376	ECRESULT UpdateFolderCounts(ECDatabase lpDatabase, ULONG ulParentId, ULONG ulFlags, propValArray lpModProps)
1385	1377	{
1386	1378	ECRESULT er = erSuccess;
1387		struct propVal *lpPropMessageFlags = NULL; // non-free
1388	1379
1389	1380	if (ulFlags & MAPI_ASSOCIATED)
1390	1381	er = UpdateFolderCount(lpDatabase, ulParentId, PR_ASSOC_CONTENT_COUNT, 1);
1391	1382	else {
1392	1383	er = UpdateFolderCount(lpDatabase, ulParentId, PR_CONTENT_COUNT, 1);
1393
	1384	struct propVal *lpPropMessageFlags = NULL;
1394	1385	lpPropMessageFlags = FindProp(lpModProps, PR_MESSAGE_FLAGS);
1395	1386	if (er == erSuccess && (!lpPropMessageFlags \|\| (lpPropMessageFlags->Value.ul & MSGFLAG_READ) == 0))
1396	1387	er = UpdateFolderCount(lpDatabase, ulParentId, PR_CONTENT_UNREAD, 1);

+0

-12

provider/libserver/cmdutil.hpp less more

74	74	return d->usType;
75	75	}
76	76
77		#if 0
78		unsigned int flags() const {
79		auto d = reinterpret_cast<EID_V0 >(const_cast<char >(m_data.data()));
80		if (m_data.size() < offsetof(EID_V0, usFlags) + sizeof(d->usFlags)) {
81		ec_log_err("%s: entryid has size %zu; not enough for EID_V0.usFlags",
82		__func__, m_data.size());
83		throw runtime_error("entryid is not of type EID_V0");
84		}
85		return d->usFlags;
86		}
87		#endif
88
89	77	void setFlags(unsigned int ulFlags) {
90	78	auto d = reinterpret_cast<EID_V0 >(const_cast<char >(m_data.data()));
91	79	if (m_data.size() < offsetof(EID_V0, usFlags) + sizeof(d->usFlags)) {

+0

-6

provider/libserver/include/kopano/ECPluginSharedData.h less more

53	53	unsigned int m_ulRefCount;
54	54
55	55	/**
56		* Constructor
57		*
58	56	* @param[in] lpParent
59	57	* Pointer to ECConfig to read configuration option from the server
60	58	* @param[in] lpStatsCollector

70	68	* while the plugin doesn't support multi-server.
71	69	*/
72	70	ECPluginSharedData(ECConfig lpParent, ECStatsCollector , bool bHosted, bool bDistributed);
73
74		/**
75		* Default destructor
76		*/
77	71	virtual ~ECPluginSharedData(void);
78	72
79	73	public:

+10

-13

provider/plugins/DBBase.cpp less more

96	96	objectdetails_t details;
97	97	objectid_t lastid;
98	98	objectid_t curid;
99		std::list<objectid_t>::const_iterator iterID;
100	99
101	100	if(objectids.empty())
102	101	return std::unique_ptr<std::map<objectid_t, objectdetails_t> >(mapdetails);

182	181	details.SetPropString(OB_PROP_O_SYSADMIN, lpDBRow[3]);
183	182	} else if (strcmp(lpDBRow[2], OB_AB_HIDDEN) == 0)
184	183	details.SetPropString(OB_PROP_B_AB_HIDDEN, lpDBRow[3]);
185		else if (strnicmp(lpDBRow[2], "0x", strlen("0x")) == 0) {
	184	else if (strncasecmp(lpDBRow[2], "0x", strlen("0x")) == 0) {
186	185	unsigned int key = xtoi(lpDBRow[2]);
187	186	if (PROP_TYPE(key) == PT_BINARY)
188	187	details.SetPropString((property_key_t)key, base64_decode(lpDBRow[3]));

231	230
232	231	lastid = curid;
233	232
234		if (strnicmp(lpDBRow[0], "0x", strlen("0x")) == 0) {
	233	if (strncasecmp(lpDBRow[0], "0x", strlen("0x")) == 0) {
235	234	unsigned int key = xtoi(lpDBRow[0]);
236	235	if (PROP_TYPE(key) == PT_BINARY \|\| PROP_TYPE(key) == PT_MV_BINARY)
237	236	iterDetails->second.AddPropString((property_key_t)key, base64_decode(lpDBRow[1]));

303	302	bool bFirstOne = true;
304	303	bool bFirstDel = true;
305	304	string strData;
306		string strMD5Pw;
307	305	property_map anonymousProps;
308	306	property_map::const_iterator iterAnonymous;
309	307	property_mv_map anonymousMVProps;

395	393	while (sValidProps[i].column != NULL) {
396	394	string propvalue = details.GetPropString(sValidProps[i].id);
397	395
398		if (stricmp(sValidProps[i].column, OP_PASSWORD) == 0 && !propvalue.empty()) {
	396	if (strcasecmp(sValidProps[i].column, OP_PASSWORD) == 0 && !propvalue.empty()) {
399	397	// Password value has special treatment
400	398	if (CreateMD5Hash(propvalue, &propvalue) != erSuccess) // WARNING input and output point to the same data
401	399	throw runtime_error(string("db_changeUser: create md5"));

718	716	std::unique_ptr<signatures_t> DBPlugin::searchObjects(const std::string &match,
719	717	const char *search_props, const char return_prop, unsigned int ulFlags)
720	718	{
721		string signature;
722	719	objectid_t objectid;
723	720	std::unique_ptr<signatures_t> lpSignatures(new signatures_t());
724	721

807	804
808	805	if (bGetUserDefault) {
809	806	if (objectid.objclass != CONTAINER_COMPANY && strcmp(lpDBRow[0], OP_UD_HARDQUOTA) == 0)
810		lpDetails->llHardSize = _atoi64(lpDBRow[1]);
	807	lpDetails->llHardSize = atoll(lpDBRow[1]);
811	808	else if(objectid.objclass != CONTAINER_COMPANY && strcmp(lpDBRow[0], OP_UD_SOFTQUOTA) == 0)
812		lpDetails->llSoftSize = _atoi64(lpDBRow[1]);
	809	lpDetails->llSoftSize = atoll(lpDBRow[1]);
813	810	else if(strcmp(lpDBRow[0], OP_UD_WARNQUOTA) == 0)
814		lpDetails->llWarnSize = _atoi64(lpDBRow[1]);
	811	lpDetails->llWarnSize = atoll(lpDBRow[1]);
815	812	else if(strcmp(lpDBRow[0], OP_UD_USEDEFAULTQUOTA) == 0)
816	813	lpDetails->bUseDefaultQuota = !!atoi(lpDBRow[1]);
817	814	} else {
818	815	if (objectid.objclass != CONTAINER_COMPANY && strcmp(lpDBRow[0], OP_HARDQUOTA) == 0)
819		lpDetails->llHardSize = _atoi64(lpDBRow[1]);
	816	lpDetails->llHardSize = atoll(lpDBRow[1]);
820	817	else if(objectid.objclass != CONTAINER_COMPANY && strcmp(lpDBRow[0], OP_SOFTQUOTA) == 0)
821		lpDetails->llSoftSize = _atoi64(lpDBRow[1]);
	818	lpDetails->llSoftSize = atoll(lpDBRow[1]);
822	819	else if(strcmp(lpDBRow[0], OP_WARNQUOTA) == 0)
823		lpDetails->llWarnSize = _atoi64(lpDBRow[1]);
	820	lpDetails->llWarnSize = atoll(lpDBRow[1]);
824	821	else if(strcmp(lpDBRow[0], OP_USEDEFAULTQUOTA) == 0)
825	822	lpDetails->bUseDefaultQuota = !!atoi(lpDBRow[1]);
826	823	}

1078	1075	throw runtime_error(string("db_query: ") + strerror(er));
1079	1076
1080	1077	while ((lpDBRow = m_lpDatabase->FetchRow(lpResult)) != NULL)
1081		if (lpDBRow[1] != NULL && stricmp(lpDBRow[1], strPropValue.c_str()) == 0)
	1078	if (lpDBRow[1] != NULL && strcasecmp(lpDBRow[1], strPropValue.c_str()) == 0)
1082	1079	throw collision_error(string("Object exist: ") + strPropValue);
1083	1080
1084	1081	if (CoCreateGuid(&guidExternId) != S_OK)

+0

-13

provider/plugins/DBBase.h less more

73	73	class DB_RESULT_AUTOFREE {
74	74	public:
75	75	/**
76		* Constructor
77		*
78	76	* @param[in] lpDatabase
79	77	* The database to which the result belongs
80	78	*/

83	81	m_lpResult = NULL;
84	82	};
85	83
86		/**
87		* Destructor
88		*
89		* Calls ECDatabase::FreeResult()
90		*/
91	84	~DB_RESULT_AUTOFREE() {
92	85	if(m_lpDatabase && m_lpResult)
93	86	m_lpDatabase->FreeResult(m_lpResult);

129	122	class DBPlugin : public UserPlugin {
130	123	public:
131	124	/**
132		* Constructor
133		*
134	125	* @param[in] pluginlock
135	126	* The plugin mutex
136	127	* @param[in] shareddata

138	129	* @throw std::exception
139	130	*/
140	131	DBPlugin(pthread_mutex_t pluginlock, ECPluginSharedData shareddata);
141
142		/**
143		* Destructor
144		*/
145	132	virtual ~DBPlugin();
146	133
147	134	/**

+2

-7

provider/plugins/DBUserPlugin.cpp less more

23	23
24	24	#include <cerrno>
25	25	#include <cassert>
26		#ifdef HAVE_MALLOC_H
27		#include <malloc.h>
28		#endif
29
30	26	#include <kopano/EMSAbTag.h>
31	27	#include <kopano/ECConfig.h>
32	28	#include <kopano/ECDefs.h>

151	147	if (lpDBRow[0] == NULL \|\| lpDBRow[1] == NULL \|\| lpDBRow[3] == NULL)
152	148	throw runtime_error(string("db_row_failed: object null"));
153	149
154		if (stricmp(lpDBRow[3], name.c_str()) != 0)
	150	if (strcasecmp(lpDBRow[3], name.c_str()) != 0)
155	151	continue;
156	152
157	153	lpDBLen = m_lpDatabase->FetchRowLengths(lpResult);

167	163
168	164	throw objectnotfound(name);
169	165	}
170
171	166
172	167	objectsignature_t DBUserPlugin::authenticateUser(const string &username, const string &password, const objectid_t &company)
173	168	{

222	217	if (lpDBRow[0] == NULL \|\| lpDBRow[1] == NULL \|\| lpDBRow[2] == NULL \|\| lpDBRow[4] == NULL)
223	218	throw runtime_error("Trying to authenticate failed: database error");
224	219
225		if (stricmp(lpDBRow[4], username.c_str()) != 0)
	220	if (strcasecmp(lpDBRow[4], username.c_str()) != 0)
226	221	continue;
227	222
228	223	lpDBLen = m_lpDatabase->FetchRowLengths(lpResult);

+4

-6

provider/plugins/DBUserPlugin.h less more

40	40	class DBUserPlugin _kc_final : public DBPlugin {
41	41	public:
42	42	/**
43		* Constructor
44		*
45	43	* @param[in] pluginlock
46	44	* The plugin mutex
47	45	* @param[in] shareddata

69	67	* The company beneath which the name should be searched
70	68	* This objectid can be empty.
71	69	* @return The object signature of the resolved object
72		* @throw runtime_error When a Database error occured.
	70	* @throw runtime_error When a Database error occurred.
73	71	* @throw objectnotfound When no object was found.
74	72	* @throw toomanyobjects When more then one object was found.
75	73	*/

86	84	* The objectid of the company to which the user belongs.
87	85	* This objectid can be empty.
88	86	* @return The objectsignature of the authenticated user
89		* @throw runtime_error When a Database error occured.
	87	* @throw runtime_error When a Database error occurred.
90	88	* @throw login_error When no user was found or the password was incorrect.
91	89	*/
92	90	virtual objectsignature_t authenticateUser(const string &username, const string &password, const objectid_t &company);

129	127	* The objectid which should be updated
130	128	* @param[in] quotadetails
131	129	* The quota information which should be written to the object
132		* @throw runtime_error When a Database error occured.
	130	* @throw runtime_error When a Database error occurred.
133	131	* @throw objectnotfound When the object was not found.
134	132	*/
135	133	virtual void setQuota(const objectid_t &id, const quotadetails_t &quotadetails);

178	176	* The parent object.
179	177	* @param[in] childobject
180	178	* The child object.
181		* @throw runtime_error When a Database error occured
	179	* @throw runtime_error When a Database error occurred
182	180	* @throw objectnotfound When the parent does not exist.
183	181	*/
184	182	virtual void addSubObjectRelation(userobject_relation_t relation,

+3

-3

provider/plugins/LDAPCache.cpp less more

175	175	/* Key should be larger then current guess, but has to be smaller then the userobject dn */
176	176	/* If key matches the end of the userobject dn, we have a positive match */
177	177	if (it->second.size() > parent_dn.size() && it->second.size() < dn.size() &&
178		stricmp(dn.c_str() + (dn.size() - it->second.size()), it->second.c_str()) == 0) {
	178	strcasecmp(dn.c_str() + (dn.size() - it->second.size()), it->second.c_str()) == 0) {
179	179	parent_dn = it->second;
180	180	entry = it->first;
181	181	}

197	197	/* Key should be larger then root DN */
198	198	/* If key matches the end of the root dn, we have a positive match */
199	199	if (iter->second.size() > dn.size() &&
200		stricmp(iter->second.c_str() + (iter->second.size() - dn.size()), dn.c_str()) == 0)
	200	strcasecmp(iter->second.c_str() + (iter->second.size() - dn.size()), dn.c_str()) == 0)
201	201	list->push_back(iter->second);
202	202
203	203	return list;

220	220	/* Key should be larger or equal then user DN */
221	221	/* If key matches the end of the user dn, we have a positive match */
222	222	if (iter->size() <= dn.size() &&
223		stricmp(dn.c_str() + (dn.size() - iter->size()), iter->c_str()) == 0)
	223	strcasecmp(dn.c_str() + (dn.size() - iter->size()), iter->c_str()) == 0)
224	224	return true;
225	225
226	226	return false;

+68

-94

provider/plugins/LDAPUserPlugin.cpp less more

27	27	#include <cerrno>
28	28	#include <cassert>
29	29	#include <sys/time.h> /* gettimeofday */
30		#ifdef HAVE_MALLOC_H
31		#include <malloc.h>
32		#endif
33
34	30	#include <kopano/EMSAbTag.h>
35	31	#include <kopano/ECConfig.h>
36	32	#include <kopano/ECLogger.h>

493	489	goto fail;
494	490	}
495	491
496		#if 0 // OpenLDAP stupidly closes the connection when TLS is not configured on the server.
497		#ifdef LINUX // Only available in Windows XP, so we can't use this on windows platform.
498		#ifdef HAVE_LDAP_START_TLS_S
499		// Initialize TLS-secured connection - this is the first command
500		// after ldap_init, so it will be the call that actually connects
501		// to the server.
502		if ((rc = ldap_start_tls_s(ld, NULL, NULL)) != LDAP_SUCCESS) {
503		ec_log_err("Failed to enable TLS on LDAP session: %s", ldap_err2string(rc));
504		goto fail;
505		}
506		#endif
507		#endif
508		#endif
509
510	492	// Bind
511	493	// For these two values: if they are both NULL, anonymous bind
512	494	// will be used (ldap_binddn, ldap_bindpw)

735	717	const char *class_dynamic_type = m_config->GetSetting("ldap_dynamicgroup_type_attribute_value");
736	718
737	719	FOREACH_ATTR(entry) {
738		if (class_attr && stricmp(att, class_attr) == 0)
	720	if (class_attr && strcasecmp(att, class_attr) == 0)
739	721	objclasses = getLDAPAttributeValues(att, entry);
740	722
741		if (nonactive_attr && stricmp(att, nonactive_attr) == 0) {
	723	if (nonactive_attr && strcasecmp(att, nonactive_attr) == 0) {
742	724	nonactive_type = getLDAPAttributeValue(att, entry);
743	725
744	726	}
745	727
746		if (resource_attr && stricmp(att, resource_attr) == 0)
	728	if (resource_attr && strcasecmp(att, resource_attr) == 0)
747	729	resource_type = getLDAPAttributeValue(att, entry);
748	730
749		if (security_attr && stricmp(att, security_attr) == 0) {
	731	if (security_attr && strcasecmp(att, security_attr) == 0) {
750	732	security_type = getLDAPAttributeValue(att, entry);
751	733
752	734	}
753	735
754		if (user_unique_attr && stricmp(att, user_unique_attr) == 0)
	736	if (user_unique_attr && strcasecmp(att, user_unique_attr) == 0)
755	737	user_unique = getLDAPAttributeValue(att, entry);
756	738
757		if (group_unique_attr && stricmp(att, group_unique_attr) == 0)
	739	if (group_unique_attr && strcasecmp(att, group_unique_attr) == 0)
758	740	group_unique = getLDAPAttributeValue(att, entry);
759	741
760		if (company_unique_attr && stricmp(att, company_unique_attr) == 0)
	742	if (company_unique_attr && strcasecmp(att, company_unique_attr) == 0)
761	743	company_unique = getLDAPAttributeValue(att, entry);
762	744
763		if (addresslist_unique_attr && stricmp(att, addresslist_unique_attr) == 0)
	745	if (addresslist_unique_attr && strcasecmp(att, addresslist_unique_attr) == 0)
764	746	addresslist_unique = getLDAPAttributeValue(att, entry);
765	747
766		if (dynamicgroup_unique_attr && stricmp(att, dynamicgroup_unique_attr) == 0)
	748	if (dynamicgroup_unique_attr && strcasecmp(att, dynamicgroup_unique_attr) == 0)
767	749	dynamicgroup_unique = getLDAPAttributeValue(att, entry);
768	750	}
769	751	END_FOREACH_ATTR

832	814
833	815	if (objclass == NONACTIVE_USER && !resource_type.empty()) {
834	816	/* Overwrite objectclass, a resource is allowed to overwrite the nonactive type */
835		if (stricmp(resource_type.c_str(), "room") == 0)
	817	if (strcasecmp(resource_type.c_str(), "room") == 0)
836	818	objclass = NONACTIVE_ROOM;
837		else if (stricmp(resource_type.c_str(), "equipment") == 0)
	819	else if (strcasecmp(resource_type.c_str(), "equipment") == 0)
838	820	objclass = NONACTIVE_EQUIPMENT;
839	821	}
840	822

847	829	}
848	830
849	831	if (objclass == OBJECTCLASS_DISTLIST) {
850		if (!stricmp(security_attr_type, "ads")) {
	832	if (!strcasecmp(security_attr_type, "ads")) {
851	833	if(atoi(security_type.c_str()) & 0x80000000)
852	834	objclass = DISTLIST_SECURITY;
853	835	else

872	854	if (objclass == CONTAINER_ADDRESSLIST) {
873	855	object_uid = addresslist_unique;
874	856	}
875
876	857
877	858	return objectid_t(object_uid, objclass);
878	859	}

920	901	/* Needed for cache */
921	902	CONFIG_TO_ATTR(request_attrs, modify_attr, "ldap_last_modification_attribute");
922	903
923
924	904	FOREACH_PAGING_SEARCH((char *)basedn.c_str(), scope,
925	905	(char )search_filter.c_str(), (char *)request_attrs->get(),
926	906	FETCH_ATTR_VALS, res)

935	915	}
936	916
937	917	FOREACH_ATTR(entry) {
938		if (modify_attr && stricmp(att, modify_attr) == 0)
	918	if (modify_attr && strcasecmp(att, modify_attr) == 0)
939	919	signature = getLDAPAttributeValue(att, entry);
940	920	}
941	921	END_FOREACH_ATTR

1140	1120	string search_data;
1141	1121
1142	1122	// Set binary uniqueid to escaped string
1143		if(attr_type && stricmp(attr_type, LDAP_DATA_TYPE_BINARY) == 0)
	1123	if(attr_type && strcasecmp(attr_type, LDAP_DATA_TYPE_BINARY) == 0)
1144	1124	BintoEscapeSequence(data.c_str(), data.size(), &search_data);
1145	1125	else
1146	1126	search_data = StringEscapeSequence(data);

1257	1237	}
1258	1238
1259	1239	FOREACH_ATTR(entry) {
1260		if (stricmp(att, lpAttr) == 0) {
	1240	if (strcasecmp(att, lpAttr) == 0) {
1261	1241	strData = getLDAPAttributeValue(att, entry);
1262	1242	bDataAttrFound = true;
1263	1243	}

1303	1283	}
1304	1284
1305	1285	FOREACH_ATTR(entry) {
1306		if (stricmp(att, lpAttr) == 0) {
	1286	if (strcasecmp(att, lpAttr) == 0) {
1307	1287	strData = getLDAPAttributeValue(att, entry);
1308	1288	bAttrFound = true;
1309	1289	}

1508	1488	* and we must incur the penalty of having to resolve each entry one by one.
1509	1489	* When the relation attribute is not the DN, we can optimize the lookup
1510	1490	* by creating a single query that obtains all the required data in a single query. */
1511		if (lpAttrType && stricmp(lpAttrType, LDAP_DATA_TYPE_DN) == 0) {
	1491	if (lpAttrType && strcasecmp(lpAttrType, LDAP_DATA_TYPE_DN) == 0) {
1512	1492	signatures = objectDNtoObjectSignatures(objclass, objects);
1513	1493	} else {
1514	1494	/* We have the full member list, create a new query that

1626	1606	gettimeofday(&tstart, NULL);
1627	1607
1628	1608	try {
1629		if (!stricmp(authmethod, "password")) {
	1609	if (!strcasecmp(authmethod, "password")) {
1630	1610	id = authenticateUserPassword(username, password, company);
1631	1611	} else {
1632	1612	id = authenticateUserBind(username, password, company);

1720	1700	}
1721	1701
1722	1702	FOREACH_ATTR(entry) {
1723		if (loginname_attr && !stricmp(att, loginname_attr)) {
	1703	if (loginname_attr && !strcasecmp(att, loginname_attr)) {
1724	1704	d.SetPropString(OB_PROP_S_LOGIN, m_iconv->convert(getLDAPAttributeValue(att, entry)));
1725		} else if (password_attr && !stricmp(att, password_attr)) {
	1705	} else if (password_attr && !strcasecmp(att, password_attr)) {
1726	1706	d.SetPropString(OB_PROP_S_PASSWORD, getLDAPAttributeValue(att, entry));
1727	1707	}
1728	1708
1729		if (unique_attr && !stricmp(att, unique_attr)) {
	1709	if (unique_attr && !strcasecmp(att, unique_attr)) {
1730	1710	signature.id.id = getLDAPAttributeValue(att, entry);
1731	1711	signature.id.objclass = ACTIVE_USER; // only users can authenticate
1732	1712	}
1733	1713
1734		if (nonactive_attr && !stricmp(att, nonactive_attr)) {
	1714	if (nonactive_attr && !strcasecmp(att, nonactive_attr)) {
1735	1715	if (parseBool(getLDAPAttributeValue(att, entry)))
1736	1716	throw login_error("Cannot login as nonactive user");
1737	1717	}

1747	1727	if (signature.id.id.empty())
1748	1728	throw login_error("Trying to authenticate failed: uniqueid is empty or unreadable");
1749	1729
1750		if (!strnicmp("{CRYPT}", strCryptedpw.c_str(), 7)) {
	1730	if (!strncasecmp("{CRYPT}", strCryptedpw.c_str(), 7)) {
1751	1731	if(checkPassword(PASSWORD_CRYPT, strPasswordConverted.c_str(), &(strCryptedpw.c_str()[7])) != 0)
1752	1732	throw login_error("Trying to authenticate failed: wrong username or password");
1753		} else if (!strnicmp("{MD5}", strCryptedpw.c_str(), 5)) {
	1733	} else if (!strncasecmp("{MD5}", strCryptedpw.c_str(), 5)) {
1754	1734	if(checkPassword(PASSWORD_MD5, strPasswordConverted.c_str(), &(strCryptedpw.c_str()[5])) != 0)
1755	1735	throw login_error("Trying to authenticate failed: wrong username or password");
1756		} else if (!strnicmp("{SMD5}", strCryptedpw.c_str(), 6)) {
	1736	} else if (!strncasecmp("{SMD5}", strCryptedpw.c_str(), 6)) {
1757	1737	if(checkPassword(PASSWORD_SMD5, strPasswordConverted.c_str(), &(strCryptedpw.c_str()[6])) != 0)
1758	1738	throw login_error("Trying to authenticate failed: wrong username or password");
1759		} else if (!strnicmp("{SSHA}", strCryptedpw.c_str(), 6)) {
	1739	} else if (!strncasecmp("{SSHA}", strCryptedpw.c_str(), 6)) {
1760	1740	if(checkPassword(PASSWORD_SSHA, strPasswordConverted.c_str(), &(strCryptedpw.c_str()[6])) != 0)
1761	1741	throw login_error("Trying to authenticate failed: wrong username or password");
1762		} else if (!strnicmp("{SHA}", strCryptedpw.c_str(), 5)) {
	1742	} else if (!strncasecmp("{SHA}", strCryptedpw.c_str(), 5)) {
1763	1743	if(checkPassword(PASSWORD_SHA, strPasswordConverted.c_str(), &(strCryptedpw.c_str()[5])) != 0)
1764	1744	throw login_error("Trying to authenticate failed: wrong username or password");
1765		} else if(!strnicmp("{MD5CRYPT}", strCryptedpw.c_str(), 10)) {
	1745	} else if(!strncasecmp("{MD5CRYPT}", strCryptedpw.c_str(), 10)) {
1766	1746	throw login_error("Trying to authenticate failed: unsupported encryption scheme");
1767	1747	} else {
1768	1748	if(strcmp(strCryptedpw.c_str(), strPasswordConverted.c_str()) != 0) { //Plain password

1793	1773	else
1794	1774	return string();
1795	1775	}
1796
1797	1776
1798	1777	list<string> LDAPUserPlugin::getLDAPAttributeValues(char attribute, LDAPMessage entry) {
1799	1778	list<string> r;

1847	1826	/* That was easy ... */
1848	1827	if (objectids.empty())
1849	1828	return mapdetails;
1850
1851	1829
1852	1830	bool bCutOff = false;
1853	1831

2005	1983	ldap_filter += ")";
2006	1984	}
2007	1985
2008
2009	1986	FOREACH_PAGING_SEARCH((char *)ldap_basedn.c_str(), LDAP_SCOPE_SUBTREE,
2010	1987	(char )ldap_filter.c_str(), (char *)request_attrs->get(),
2011	1988	FETCH_ATTR_VALS, res)

2028	2005	* We check the attribute for every match possible,
2029	2006	* because an attribute can be used in multiple config options
2030	2007	*/
2031		if (ldap_addressbook_hide_attr && !stricmp(att, ldap_addressbook_hide_attr)) {
	2008	if (ldap_addressbook_hide_attr && !strcasecmp(att, ldap_addressbook_hide_attr)) {
2032	2009	ldap_attr = getLDAPAttributeValue(att, entry);
2033	2010	sObjDetails.SetPropBool(OB_PROP_B_AB_HIDDEN, parseBool(ldap_attr.c_str()));
2034	2011	}
2035
2036	2012
2037	2013	for (std::list<configsetting_t>::const_iterator iter = lExtraAttrs.begin();
2038	2014	iter != lExtraAttrs.end(); ++iter) {

2042	2018	* The value should be set to something, as protection to make sure
2043	2019	* the name is a property tag all names should be prefixed with '0x'.
2044	2020	*/
2045		if (stricmp(iter->szValue, att) != 0 \|\| strnicmp(iter->szName, "0x", strlen("0x")) != 0)
	2021	if (strcasecmp(iter->szValue, att) != 0 \|\| strncasecmp(iter->szName, "0x", strlen("0x")) != 0)
2046	2022	continue;
2047	2023
2048	2024	ulPropTag = xtoi(iter->szName);

2148	2124	case NONACTIVE_ROOM:
2149	2125	case NONACTIVE_EQUIPMENT:
2150	2126	case NONACTIVE_CONTACT:
2151		if (loginname_attr && !stricmp(att, loginname_attr)) {
	2127	if (loginname_attr && !strcasecmp(att, loginname_attr)) {
2152	2128	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2153	2129	sObjDetails.SetPropString(OB_PROP_S_LOGIN, ldap_attr);
2154	2130	}
2155	2131
2156		if (user_fullname_attr && !stricmp(att, user_fullname_attr)) {
	2132	if (user_fullname_attr && !strcasecmp(att, user_fullname_attr)) {
2157	2133	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2158	2134	sObjDetails.SetPropString(OB_PROP_S_FULLNAME, ldap_attr);
2159	2135	}
2160	2136
2161		if (password_attr && !stricmp(att, password_attr)) {
	2137	if (password_attr && !strcasecmp(att, password_attr)) {
2162	2138	ldap_attr = getLDAPAttributeValue(att, entry);
2163	2139	sObjDetails.SetPropString(OB_PROP_S_PASSWORD, ldap_attr);
2164	2140	}
2165	2141
2166		if (emailaddress_attr && !stricmp(att, emailaddress_attr)) {
	2142	if (emailaddress_attr && !strcasecmp(att, emailaddress_attr)) {
2167	2143	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2168	2144	sObjDetails.SetPropString(OB_PROP_S_EMAIL, ldap_attr);
2169	2145	}
2170	2146
2171		if (emailaliases_attr && !stricmp(att, emailaliases_attr)) {
	2147	if (emailaliases_attr && !strcasecmp(att, emailaliases_attr)) {
2172	2148	ldap_attrs = getLDAPAttributeValues(att, entry);
2173	2149	sObjDetails.SetPropListString(OB_PROP_LS_ALIASES, ldap_attrs);
2174	2150	}
2175	2151
2176		if (isadmin_attr && !stricmp(att, isadmin_attr)) {
	2152	if (isadmin_attr && !strcasecmp(att, isadmin_attr)) {
2177	2153	ldap_attr = getLDAPAttributeValue(att, entry);
2178	2154	sObjDetails.SetPropInt(OB_PROP_I_ADMINLEVEL, min(2, atoi(ldap_attr.c_str())));
2179	2155	}
2180	2156
2181		if (resource_type_attr && !stricmp(att, resource_type_attr)) {
	2157	if (resource_type_attr && !strcasecmp(att, resource_type_attr)) {
2182	2158	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2183	2159	sObjDetails.SetPropString(OB_PROP_S_RESOURCE_DESCRIPTION, ldap_attr);
2184	2160	}
2185	2161
2186		if (resource_capacity_attr && !stricmp(att, resource_capacity_attr)) {
	2162	if (resource_capacity_attr && !strcasecmp(att, resource_capacity_attr)) {
2187	2163	ldap_attr = getLDAPAttributeValue(att, entry);
2188	2164	sObjDetails.SetPropInt(OB_PROP_I_RESOURCE_CAPACITY, atoi(ldap_attr.c_str()));
2189	2165	}
2190	2166
2191		if (usercert_attr && !stricmp(att, usercert_attr)) {
	2167	if (usercert_attr && !strcasecmp(att, usercert_attr)) {
2192	2168	ldap_attrs = getLDAPAttributeValues(att, entry);
2193	2169	sObjDetails.SetPropListString(OB_PROP_LS_CERTIFICATE, ldap_attrs);
2194	2170	}
2195	2171
2196		if (sendas_attr && !stricmp(att, sendas_attr)) {
	2172	if (sendas_attr && !strcasecmp(att, sendas_attr)) {
2197	2173	postaction p;
2198	2174
2199	2175	p.objectid = objectid;

2212	2188	}
2213	2189
2214	2190	#ifdef WITH_MULTISERVER
2215		if (user_server_attr && !stricmp(att, user_server_attr)) {
	2191	if (user_server_attr && !strcasecmp(att, user_server_attr)) {
2216	2192	ldap_attr = getLDAPAttributeValue(att, entry);
2217	2193	sObjDetails.SetPropString(OB_PROP_S_SERVERNAME, ldap_attr);
2218	2194	}

2220	2196	break;
2221	2197	case DISTLIST_GROUP:
2222	2198	case DISTLIST_SECURITY:
2223		if (group_fullname_attr && !stricmp(att, group_fullname_attr)) {
	2199	if (group_fullname_attr && !strcasecmp(att, group_fullname_attr)) {
2224	2200	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2225	2201	sObjDetails.SetPropString(OB_PROP_S_LOGIN, ldap_attr);
2226	2202	sObjDetails.SetPropString(OB_PROP_S_FULLNAME, ldap_attr);
2227	2203	}
2228	2204
2229		if (emailaddress_attr && !stricmp(att, emailaddress_attr)) {
	2205	if (emailaddress_attr && !strcasecmp(att, emailaddress_attr)) {
2230	2206	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2231	2207	sObjDetails.SetPropString(OB_PROP_S_EMAIL, ldap_attr);
2232	2208	}
2233	2209
2234		if (emailaliases_attr && !stricmp(att, emailaliases_attr)) {
	2210	if (emailaliases_attr && !strcasecmp(att, emailaliases_attr)) {
2235	2211	ldap_attrs = getLDAPAttributeValues(att, entry);
2236	2212	sObjDetails.SetPropListString(OB_PROP_LS_ALIASES, ldap_attrs);
2237	2213	}
2238	2214
2239		if (sendas_attr && !stricmp(att, sendas_attr)) {
	2215	if (sendas_attr && !strcasecmp(att, sendas_attr)) {
2240	2216	postaction p;
2241	2217
2242	2218	p.objectid = objectid;

2255	2231	}
2256	2232	break;
2257	2233	case DISTLIST_DYNAMIC:
2258		if (dynamicgroup_name_attr && !stricmp(att, dynamicgroup_name_attr)) {
	2234	if (dynamicgroup_name_attr && !strcasecmp(att, dynamicgroup_name_attr)) {
2259	2235	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2260	2236	sObjDetails.SetPropString(OB_PROP_S_LOGIN, ldap_attr);
2261	2237	sObjDetails.SetPropString(OB_PROP_S_FULLNAME, ldap_attr);
2262	2238	}
2263	2239
2264		if (emailaddress_attr && !stricmp(att, emailaddress_attr)) {
	2240	if (emailaddress_attr && !strcasecmp(att, emailaddress_attr)) {
2265	2241	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2266	2242	sObjDetails.SetPropString(OB_PROP_S_EMAIL, ldap_attr);
2267	2243	}
2268	2244
2269		if (emailaliases_attr && !stricmp(att, emailaliases_attr)) {
	2245	if (emailaliases_attr && !strcasecmp(att, emailaliases_attr)) {
2270	2246	ldap_attrs = getLDAPAttributeValues(att, entry);
2271	2247	sObjDetails.SetPropListString(OB_PROP_LS_ALIASES, ldap_attrs);
2272	2248	}
2273	2249	break;
2274	2250	case CONTAINER_COMPANY:
2275		if (company_fullname_attr && !stricmp(att, company_fullname_attr)) {
	2251	if (company_fullname_attr && !strcasecmp(att, company_fullname_attr)) {
2276	2252	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2277	2253	sObjDetails.SetPropString(OB_PROP_S_LOGIN, ldap_attr);
2278	2254	sObjDetails.SetPropString(OB_PROP_S_FULLNAME, ldap_attr);
2279	2255	}
2280	2256
2281	2257	#ifdef WITH_MULTISERVER
2282		if (company_server_attr && !stricmp(att, company_server_attr)) {
	2258	if (company_server_attr && !strcasecmp(att, company_server_attr)) {
2283	2259	ldap_attr = getLDAPAttributeValue(att, entry);
2284	2260	sObjDetails.SetPropString(OB_PROP_S_SERVERNAME, ldap_attr);
2285	2261	}
2286	2262	#endif
2287	2263
2288		if (sysadmin_attr && !stricmp(att, sysadmin_attr)) {
	2264	if (sysadmin_attr && !strcasecmp(att, sysadmin_attr)) {
2289	2265	postaction p;
2290	2266
2291	2267	p.objectid = objectid;

2301	2277
2302	2278	break;
2303	2279	case CONTAINER_ADDRESSLIST:
2304		if (addresslist_name_attr && !stricmp(att, addresslist_name_attr)) {
	2280	if (addresslist_name_attr && !strcasecmp(att, addresslist_name_attr)) {
2305	2281	ldap_attr = m_iconv->convert(getLDAPAttributeValue(att, entry));
2306	2282	sObjDetails.SetPropString(OB_PROP_S_LOGIN, ldap_attr);
2307	2283	sObjDetails.SetPropString(OB_PROP_S_FULLNAME, ldap_attr);

2601	2577	if(member_attr_rel == NULL \|\| strlen(member_attr_rel) == 0)
2602	2578	member_attr_rel = unique_attr;
2603	2579
2604		if (member_attr_type && stricmp(member_attr_type, LDAP_DATA_TYPE_DN) == 0) {
	2580	if (member_attr_type && strcasecmp(member_attr_type, LDAP_DATA_TYPE_DN) == 0) {
2605	2581	//ads
2606	2582	member_data = objectUniqueIDtoObjectDN(childobject);
2607	2583	} else { //LDAP_DATA_TYPE_ATTRIBUTE
2608	2584	//posix ldap
2609	2585	// FIXME: No binary support for member_attr_rel
2610		if (stricmp(member_attr_rel, unique_attr) == 0)
	2586	if (strcasecmp(member_attr_rel, unique_attr) == 0)
2611	2587	member_data = childobject.id;
2612	2588	else
2613	2589	member_data = objectUniqueIDtoAttributeData(childobject, member_attr_rel);

2772	2748	// Get the DN for each of the returned entries
2773	2749	FOREACH_ENTRY(res) {
2774	2750	FOREACH_ATTR(entry) {
2775		if (member_attr && !stricmp(att, member_attr))
	2751	if (member_attr && !strcasecmp(att, member_attr))
2776	2752	memberlist = getLDAPAttributeValues(att, entry);
2777	2753	}
2778	2754	END_FOREACH_ATTR

2788	2764	dn = GetLDAPEntryDN(entry);
2789	2765
2790	2766	FOREACH_ATTR(entry) {
2791		if (member_attr && !stricmp(att, member_attr))
	2767	if (member_attr && !strcasecmp(att, member_attr))
2792	2768	ldap_member_filter = getLDAPAttributeValue(att, entry);
2793		if (base_attr && !stricmp(att, base_attr))
	2769	if (base_attr && !strcasecmp(att, base_attr))
2794	2770	ldap_basedn = getLDAPAttributeValue(att, entry);
2795	2771	}
2796	2772	END_FOREACH_ATTR

2889	2865	LDAPMessage *entry = NULL;
2890	2866	string ldap_basedn;
2891	2867	string search_filter;
2892		string subfilter;
2893	2868	std::unique_ptr<objectdetails_t> details(new objectdetails_t(CONTAINER_COMPANY));
2894	2869
2895	2870	if (!m_bDistributed)

2931	2906	}
2932	2907
2933	2908	FOREACH_ATTR(entry) {
2934		if (unique_attr && !stricmp(att, unique_attr))
	2909	if (unique_attr && !strcasecmp(att, unique_attr))
2935	2910	details->SetPropString(OB_PROP_S_SERVERNAME, m_iconv->convert(getLDAPAttributeValue(att, entry)));
2936	2911	}
2937	2912	END_FOREACH_ATTR

2953	2928	if (!m_bDistributed)
2954	2929	throw objectnotfound("Distributed not enabled");
2955	2930
2956
2957	2931	LOG_PLUGIN_DEBUG("%s", __FUNCTION__);
2958	2932
2959	2933	string strName;

2975	2949	FOREACH_ENTRY(res)
2976	2950	{
2977	2951	FOREACH_ATTR(entry) {
2978		if (name_attr && !stricmp(att, name_attr)) {
	2952	if (name_attr && !strcasecmp(att, name_attr)) {
2979	2953	strName = m_iconv->convert(getLDAPAttributeValue(att, entry));
2980	2954	serverlist->push_back(strName);
2981	2955	}

3051	3025	}
3052	3026
3053	3027	FOREACH_ATTR(entry) {
3054		if (address_attr && !stricmp(att, address_attr)) {
	3028	if (address_attr && !strcasecmp(att, address_attr)) {
3055	3029	strAddress = m_iconv->convert(getLDAPAttributeValue(att, entry));
3056	3030	}
3057		if (http_port_attr && !stricmp(att, http_port_attr)) {
	3031	if (http_port_attr && !strcasecmp(att, http_port_attr)) {
3058	3032	strHttpPort = m_iconv->convert(getLDAPAttributeValue(att, entry));
3059	3033	}
3060		if (ssl_port_attr && !stricmp(att, ssl_port_attr)) {
	3034	if (ssl_port_attr && !strcasecmp(att, ssl_port_attr)) {
3061	3035	strSslPort = m_iconv->convert(getLDAPAttributeValue(att, entry));
3062	3036	}
3063		if (file_path_attr && !stricmp(att, file_path_attr)) {
	3037	if (file_path_attr && !strcasecmp(att, file_path_attr)) {
3064	3038	strFilePath = m_iconv->convert(getLDAPAttributeValue(att, entry));
3065	3039	}
3066		if (proxy_path_attr && !stricmp(att, proxy_path_attr)) {
	3040	if (proxy_path_attr && !strcasecmp(att, proxy_path_attr)) {
3067	3041	strProxyPath = m_iconv->convert(getLDAPAttributeValue(att, entry));
3068	3042	}
3069	3043	}

3179	3153	// work parsing the results from the ber structs.
3180	3154	FOREACH_ENTRY(res) {
3181	3155	FOREACH_ATTR(entry) {
3182		if (usedefaults_attr && !stricmp(att, usedefaults_attr)) {
	3156	if (usedefaults_attr && !strcasecmp(att, usedefaults_attr)) {
3183	3157	// Workarround quotaoverride == !usedefaultquota
3184	3158	quotaDetails->bUseDefaultQuota = !parseBool(getLDAPAttributeValue(att, entry));
3185		} else if (warnquota_attr && !stricmp(att, warnquota_attr)) {
	3159	} else if (warnquota_attr && !strcasecmp(att, warnquota_attr)) {
3186	3160	quotaDetails->llWarnSize = fromstring<string, long long>(getLDAPAttributeValue(att, entry)) * multiplier;
3187		} else if (id.objclass != CONTAINER_COMPANY && softquota_attr && !stricmp(att, softquota_attr)) {
	3161	} else if (id.objclass != CONTAINER_COMPANY && softquota_attr && !strcasecmp(att, softquota_attr)) {
3188	3162	quotaDetails->llSoftSize = fromstring<string, long long>(getLDAPAttributeValue(att, entry)) * multiplier;
3189		} else if (id.objclass != CONTAINER_COMPANY && hardquota_attr && !stricmp(att, hardquota_attr)) {
	3163	} else if (id.objclass != CONTAINER_COMPANY && hardquota_attr && !strcasecmp(att, hardquota_attr)) {
3190	3164	quotaDetails->llHardSize = fromstring<string, long long>(getLDAPAttributeValue(att, entry)) * multiplier;
3191	3165	}
3192	3166	}

+1

-6

provider/plugins/LDAPUserPlugin.h less more

66	66	* ldap_search_s.
67	67	*/
68	68	LDAPUserPlugin(pthread_mutex_t pluginlock, ECPluginSharedData shareddata);
69
70		/**
71		* Destructor
72		*/
73	69	virtual ~LDAPUserPlugin();
74	70
75	71	/**

488	484	* @param[in] uniqueid
489	485	* The unique id which should be converted
490	486	* @return the DN for the object
491		* @throw runtime_error When an error occured during the LDAP query.
	487	* @throw runtime_error When an error occurred during the LDAP query.
492	488	* @throw objectnotfound When no object was found with the given objectid.
493	489	* @throw toomanyobjects When more then one object was returned with the objectid.
494	490	*/

529	525	* The length of the binary data
530	526	* @param[out] lpEscaped
531	527	* Escaped string
532		* @return HRESULT
533	528	*/
534	529	HRESULT BintoEscapeSequence(const char* lpdata, size_t size, string* lpEscaped);
535	530

+0

-57

~~provider/plugins/Makefile.am~~ less more

0		AM_CPPFLAGS = ${ZCPPFLAGS} $(DEBUGFLAGS) $(BOOST_CPPFLAGS) \
1		-I${top_srcdir}/common -I${top_srcdir}/m4lcommon \
2		-I${top_srcdir}/provider/libserver \
3		-I${top_srcdir}/provider/common -I${top_srcdir}/mapi4linux/include
4
5		COMMON_PLUGIN_FILES = plugin.h
6		COMMON_DBPLUGIN_FILES = DBBase.h DBBase.cpp
7
8
9		pkglib_LTLIBRARIES =
10		noinst_DATA =
11
12		if WITH_UNIX
13		pkglib_LTLIBRARIES += unixplugin.la
14		#noinst_DATA += unixplugin.ldd
15		unixplugin_la_CPPFLAGS = ${AM_CPPFLAGS} $(MYSQL_INCLUDES)
16		unixplugin_la_SOURCES = UnixUserPlugin.cpp UnixUserPlugin.h $(COMMON_PLUGIN_FILES) $(COMMON_DBPLUGIN_FILES)
17		unixplugin_la_LDFLAGS = ${AM_LDFLAGS} -module -avoid-version
18		unixplugin_la_LIBADD = \
19		${top_builddir}/common/libkcutil.la \
20		../libserver/libkcserver.la ${MYSQL_LIBS} ${CRYPT_LIBS}
21		endif
22
23		if WITH_LDAP
24		pkglib_LTLIBRARIES += ldapplugin.la
25		#noinst_DATA += ldapplugin.ldd
26		noinst_DATA += .libs/ldapmsplugin.so
27		ldapplugin_la_CPPFLAGS = ${AM_CPPFLAGS} $(LDAP_FLAGS) -DLDAP_THREAD_SAFE -DWITH_MULTISERVER
28		ldapplugin_la_SOURCES = LDAPUserPlugin.cpp LDAPUserPlugin.h LDAPCache.cpp LDAPCache.h ldappasswords.cpp ldappasswords.h $(COMMON_PLUGIN_FILES)
29		ldapplugin_la_LDFLAGS = ${AM_LDFLAGS} -module -avoid-version
30		ldapplugin_la_LIBADD = \
31		${top_builddir}/common/libkcutil.la \
32		../libserver/libkcserver.la ${CRYPTO_LIBS} ${LDAP_LIBS}
33
34		.libs/ldapmsplugin.so: ldapplugin.la
35		${AM_V_GEN}ln -fs ldapplugin.so .libs/ldapmsplugin.so
36
37		install-exec-local:
38		ln -fs ldapplugin.so ${DESTDIR}${pkglibdir}/ldapmsplugin.so
39
40		endif
41
42		# default plugin
43		pkglib_LTLIBRARIES += dbplugin.la
44		#noinst_DATA += dbplugin.ldd
45		dbplugin_la_CPPFLAGS = ${AM_CPPFLAGS} $(MYSQL_INCLUDES)
46		dbplugin_la_SOURCES = DBUserPlugin.cpp DBUserPlugin.h $(COMMON_PLUGIN_FILES) $(COMMON_DBPLUGIN_FILES)
47		dbplugin_la_LDFLAGS = -module -avoid-version
48		dbplugin_la_LIBADD = \
49		${top_builddir}/common/libkcutil.la \
50		../libserver/libkcserver.la ${MYSQL_LIBS}
51
52		check-syntax:
53		$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(LDAP_FLAGS) \
54		-fsyntax-only -fmessage-length=0 ${CHK_SOURCES} -Wall -Wformat=2
55
56		include ../../global.am

+7

-12

provider/plugins/UnixUserPlugin.cpp less more

33	33	#include <shadow.h>
34	34	#include <cerrno>
35	35	#endif
36		#ifdef HAVE_MALLOC_H
37		#include <malloc.h>
38		#endif
39
40	36	#include <kopano/EMSAbTag.h>
41	37	#include <kopano/ECConfig.h>
42	38	#include <kopano/ECDefs.h>

319	315	// username or fullname
320	316	if(ulFlags & EMS_AB_ADDRESS_LOOKUP) {
321	317	matched =
322		(stricmp(pw->pw_name, (char*)match.c_str()) == 0) \|\|
323		(stricmp((char)m_iconv->convert(pw->pw_gecos).c_str(), (char)match.c_str()) == 0);
	318	(strcasecmp(pw->pw_name, (char*)match.c_str()) == 0) \|\|
	319	(strcasecmp((char)m_iconv->convert(pw->pw_gecos).c_str(), (char)match.c_str()) == 0);
324	320	} else {
325	321	matched =
326		(strnicmp(pw->pw_name, (char*)match.c_str(), match.size()) == 0) \|\|
327		(strnicmp((char)m_iconv->convert(pw->pw_gecos).c_str(), (char)match.c_str(), match.size()) == 0);
	322	(strncasecmp(pw->pw_name, (char*)match.c_str(), match.size()) == 0) \|\|
	323	(strncasecmp((char)m_iconv->convert(pw->pw_gecos).c_str(), (char)match.c_str(), match.size()) == 0);
328	324	}
329	325
330	326	if (matched)

334	330	if(ulFlags & EMS_AB_ADDRESS_LOOKUP)
335	331	matched = (email == match);
336	332	else
337		matched = (strnicmp((char)email.c_str(), (char)match.c_str(), match.size()) == 0);
	333	matched = (strncasecmp((char)email.c_str(), (char)match.c_str(), match.size()) == 0);
338	334
339	335	return matched;
340	336	}

344	340	bool matched = false;
345	341
346	342	if(ulFlags & EMS_AB_ADDRESS_LOOKUP)
347		matched = stricmp(gr->gr_name, (char*)match.c_str()) == 0;
	343	matched = strcasecmp(gr->gr_name, (char*)match.c_str()) == 0;
348	344	else
349		matched = strnicmp(gr->gr_name, (char*)match.c_str(), match.size()) == 0;
	345	matched = strncasecmp(gr->gr_name, (char*)match.c_str(), match.size()) == 0;
350	346
351	347	return matched;
352	348	}

907	903	return mapdetails;
908	904	}
909	905
910
911	906	// -------------
912	907	// private
913	908	// -------------

+0

-6

provider/plugins/UnixUserPlugin.h less more

47	47	class UnixUserPlugin: public DBPlugin {
48	48	public:
49	49	/**
50		* Constructor
51		*
52	50	* @param[in] pluginlock
53	51	* The plugin mutex
54	52	* @param[in] lpSharedData

57	55	* @throw notsupported When multi-server or multi-company support is enabled.
58	56	*/
59	57	UnixUserPlugin(pthread_mutex_t pluginlock, ECPluginSharedData lpSharedData);
60
61		/**
62		* Destructor
63		*/
64	58	virtual ~UnixUserPlugin();
65	59
66	60	/**

+0

-3

provider/plugins/ldappasswords.cpp less more

30	30	#include "ldappasswords.h"
31	31
32	32	using namespace std;
33
34	33
35	34	static const char b64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
36	35

232	231	else
233	232	return 1;
234	233	}
235
236	234
237	235	char encryptPassword(int type, const char password) {
238	236	switch(type) {

251	249	}
252	250	}
253	251
254
255	252	int checkPassword(int type, const char password, const char crypted) {
256	253	switch(type) {
257	254	case PASSWORD_CRYPT:

+0

-22

provider/plugins/plugin.h less more

31	31	#include <stdexcept>
32	32	#include <iostream>
33	33	#include <sstream>
34		#include <memory>
35	34	#include <pthread.h>
36	35	#include <kopano/ECPluginSharedData.h>
37	36

122	121	class UserPlugin {
123	122	public:
124	123	/**
125		* Constructor
126		*
127	124	* @param[in] pluginlock
128	125	* The plugin mutex
129	126	* @param[in] shareddata

137	134	m_bDistributed(shareddata->IsDistributed())
138	135	{}
139	136
140		/**
141		* Destructor
142		*/
143	137	virtual ~UserPlugin(void) {}
144	138
145	139	/**

454	448	class objectnotfound: public runtime_error {
455	449	public:
456	450	/**
457		* Constructor
458		*
459	451	* @param[in] arg
460	452	* The description why the exception was thrown
461	453	*/

473	465	class toomanyobjects: public runtime_error {
474	466	public:
475	467	/**
476		* Constructor
477		*
478	468	* @param[in] arg
479	469	* The description why the exception was thrown
480	470	*/

492	482	class collision_error: public runtime_error {
493	483	public:
494	484	/**
495		* Constructor
496		*
497	485	* @param[in] arg
498	486	* The description why the exception was thrown
499	487	*/

511	499	class data_error: public runtime_error {
512	500	public:
513	501	/**
514		* Constructor
515		*
516	502	* @param[in] arg
517	503	* The description why the exception was thrown
518	504	*/

530	516	class notimplemented: public runtime_error {
531	517	public:
532	518	/**
533		* Constructor
534		*
535	519	* @param[in] arg
536	520	* The description why the exception was thrown
537	521	*/

551	535	class notsupported : public runtime_error {
552	536	public:
553	537	/**
554		* Constructor
555		*
556	538	* @param[in] arg
557	539	* The description why the exception was thrown
558	540	*/

569	551	class login_error: public runtime_error {
570	552	public:
571	553	/**
572		* Constructor
573		*
574	554	* @param[in] arg
575	555	* The description why the exception was thrown
576	556	*/

588	568	int m_ldaperror;
589	569	public:
590	570	/**
591		* Constructor
592		*
593	571	* @param[in] arg
594	572	* The description why the exception was thrown
595	573	* @param[in] ldaperror

+6

-9

provider/server/ECClientUpdate.cpp less more

69	69
70	70	ECLicenseClient *lpLicenseClient = NULL;
71	71	unsigned int ulLicenseResponse = 0;
72		unsigned char *lpLicenseResponse = NULL;
	72	void *lpLicenseResponse = NULL;
73	73	ECRESULT er = erSuccess;
74	74	ClientVersion currentVersion = {0};
75	75	ClientVersion latestVersion = {0};
76	76	std::string strClientMSIName;
77	77	FILE *fd = NULL;
78
79	78
80	79	// Get the server.cfg setting
81	80	szClientUpdatePath = g_lpConfig->GetSetting("client_update_path");

109	108	goto exit;
110	109	}
111	110
112		strLicenseResponse = base64_encode(lpLicenseResponse, ulLicenseResponse);
	111	strLicenseResponse = base64_encode(static_cast<const unsigned char *>(lpLicenseResponse), ulLicenseResponse);
113	112
114	113	soap->http_content = "binary";
115	114	soap_response(soap, SOAP_FILE);

187	186	nRet = SOAP_OK;
188	187
189	188	exit:
190		delete[] lpLicenseResponse;
	189	free(lpLicenseResponse);
191	190	delete lpLicenseClient;
192	191
193	192	if (fd)

405	404	ClientVersion sCurrentVersion = {0};
406	405	ClientVersion sLatestVersion;
407	406	unsigned int ulLicenseResponse = 0;
408		unsigned char *lpLicenseResponse = NULL;
	407	void *lpLicenseResponse = NULL;
409	408	ECLicenseClient *lpLicenseClient = NULL;
410	409	std::string strClientMSIName;
411	410	std::string strPath;

475	474	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Client update: trackid: 0x%08X, unknown username '%s'", sClientUpdateInfo.ulTrackId, sClientUpdateInfo.szUsername);
476	475	}
477	476
478
479	477	if(lpecSession->GetUserManagement()->IsInternalObject(ulUserID)) {
480	478	er = KCERR_NO_ACCESS;
481	479	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);

499	497	goto exit;
500	498	}
501	499
502		if (stricmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) != 0) {
	500	if (strcasecmp(strServerName.c_str(), g_lpSessionManager->GetConfig()->GetSetting("server_name")) != 0) {
503	501	string strServerPath;
504	502
505	503	er = GetBestServerPath(soap, lpecSession, strServerName, &strServerPath);

601	599	}
602	600
603	601	lpsResponse->er = er;
604
605		delete[] lpLicenseResponse;
	602	free(lpLicenseResponse);
606	603	delete lpLicenseClient;
607	604
608	605	if (er && fd)

+15

-114

provider/server/ECServer.cpp less more

27	27	#include <kopano/ECLogger.h>
28	28
29	29	#include <kopano/ECConfig.h>
30		#include "ECDatabase.h"
31	30	#include "ECPluginFactory.h"
32	31	#include "ECNotificationManager.h"
33	32	#include "ECSessionManager.h"

35	34	#include "ECStatsTables.h"
36	35	#include <climits>
37	36	#include <csignal>
38
39		#ifdef LINUX
40	37	#include <kopano/UnixUtil.h>
41	38	#include <pwd.h>
42		#endif
43
44	39	#include <sys/stat.h>
45	40	#include <kopano/ECScheduler.h>
46	41	#include <kopano/kcodes.h>

60	55	#endif
61	56
62	57	#include "TmpPath.h"
63
64		#ifdef _DEBUG
65		#define new DEBUG_NEW
66		#endif
67	58
68	59	// The following value is based on:
69	60	// http://dev.mysql.com/doc/refman/5.0/en/server-system-variables.html#sysvar_thread_stack

87	78	// Reports information on the current state of the license
88	79	void* ReportLicense(void *);
89	80
90		int running_server(char szName, const char config, int argc, char *argv[]);
91
	81	static int running_server(char , const char , int, char , int, char );
92	82
93	83	int g_Quit = 0;
94	84	int daemonize = 1;

108	98	ECScheduler* g_lpScheduler = NULL;
109	99	ECSoapServerConnection* g_lpSoapServerConn = NULL;
110	100
111		#ifdef LINUX
112	101	pthread_t signal_thread;
113	102	sigset_t signal_mask;
114	103	bool m_bNPTL = true;
115		#endif
116	104	bool m_bDatabaseUpdateIgnoreSignals = false;
117	105
118	106	// This is the callback function for libserver/* so that it can notify that a delayed soap

139	127	{
140	128	ZLOG_AUDIT(g_lpAudit, "server signalled sig=%d", sig);
141	129
142		#ifdef LINUX
143	130	if (!m_bNPTL)
144		#endif
145	131	{
146	132	// Win32 has unix semantics and therefore requires us to reset the signal handler.
147	133	signal(sig, process_signal);
148		#ifdef LINUX
149	134	if(pthread_equal(pthread_self(), mainthread)==0)
150	135	return; // soap threads do not handle this signal
151		#endif
152	136	}
153	137
154	138	if (m_bDatabaseUpdateIgnoreSignals) {

170	154	if (g_lpSoapServerConn)
171	155	g_lpSoapServerConn->ShutDown();
172	156
173		#ifdef LINUX
174	157	// unblock the signals so the server can exit
175	158	sigprocmask(SIG_UNBLOCK, &signal_mask, NULL);
176	159	signal(SIGPIPE, SIG_IGN);
177		#endif
178	160	signal(SIGTERM, SIG_IGN);
179	161	signal(SIGINT, SIG_IGN);
180	162

217	199	}
218	200	}
219	201
220		#ifdef LINUX
221	202	/**
222	203	* Signal handler thread.
223	204	*

249	230	generic_sigsegv_handler(g_lpLogger, "Server",
250	231	PROJECT_VERSION_SERVER_STR, signr, si, uc);
251	232	}
252		#endif
253	233
254	234	static ECRESULT check_database_innodb(ECDatabase *lpDatabase)
255	235	{

288	268	string strQuery;
289	269	DB_RESULT lpResult = NULL;
290	270	DB_ROW lpRow = NULL;
291
292	271
293	272	er = lpDatabase->DoSelect("SELECT value FROM settings WHERE name = 'attachment_storage'", &lpResult);
294	273	if (er != erSuccess) {

378	357	{
379	358	ECRESULT er = erSuccess;
380	359
381		#ifdef LINUX
382	360	FILE *tmpfile = NULL;
383	361	string strtestpath;
384	362

398	376	fclose(tmpfile);
399	377	unlink(strtestpath.c_str());
400	378	}
401		#endif
402
403	379	return er;
404	380	}
405	381

566	542	if (hostname[0] != '\0')
567	543	g_lpConfig->AddSetting("server_hostname", hostname);
568	544
569
570	545	if (aiResult)
571	546	freeaddrinfo(aiResult);
572	547

589	564	serverdetails_t sServerDetails;
590	565	unsigned ulPort = 0;
591	566
592
593	567	// Upgrade 'enable_sso_ntlmauth' to 'enable_sso'
594	568	bCheck = parseBool(g_lpConfig->GetSetting("enable_sso_ntlmauth"));
595	569	if (bCheck)

599	573	bCheck = parseBool(g_lpConfig->GetSetting("enable_sso"));
600	574	if (bCheck && check_server_fqdn() != erSuccess)
601	575	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "WARNING: Unable to find FQDN, please specify in 'server_hostname'. Now using '%s'.", g_lpConfig->GetSetting("server_hostname"));
602
603	576
604	577	// all other checks are only required for multi-server environments
605	578	bCheck = parseBool(g_lpConfig->GetSetting("enable_distributed_kopano"));

690	663	return er;
691	664	}
692	665
693		/**
694		* NSPR initialization is not properly guarded for threaded operation;
695		* so call it now before we create threads if it is part of the process image.
696		*/
697		static void nspr_thread_workaround(void)
698		{
699		auto f = reinterpret_cast<void (*)(int, int, int)>(dlsym(NULL, "PR_Init"));
700		if (f == NULL)
701		return;
702		ec_log_warn("Calling NSPR's PR_Init now to workaround KC-104.");
703		f(0, 0, 0);
704		}
705
706	666	int main(int argc, char* argv[])
707	667	{
708	668	int nReturn = 0;
709		#ifdef LINUX
710	669	const char *config = ECConfig::GetDefaultPath("server.cfg");
711		#else
712		const char *config = "server.cfg";
713		#endif
714	670	const char *default_config = config;
715	671
716	672	enum {

795	751	break;
796	752	};
797	753	}
798		nspr_thread_workaround();
799		nReturn = running_server(argv[0], config, argc - optind, &argv[optind]);
	754	nReturn = running_server(argv[0], config, argc, argv,
	755	argc - optind, &argv[optind]);
800	756	return nReturn;
801	757	}
802	758

809	765	bind_textdomain_codeset("kopano", "UTF-8");
810	766	}
811	767
812		int running_server(char szName, const char szConfig, int argc, char *argv[])
	768	static int running_server(char szName, const char szConfig,
	769	int argc, char argv, int trim_argc, char trim_argv)
813	770	{
814	771	int retval = -1;
815	772	ECRESULT er = erSuccess;

824	781	bool hosted = false;
825	782	bool distributed = false;
826	783
827		#ifdef LINUX
828	784	// SIGSEGV backtrace support
829	785	stack_t st = {0};
830	786	struct sigaction act = {{0}};
831	787	int tmplock = -1;
832	788	struct stat dir = {0};
833	789	struct passwd *runasUser = NULL;
834		#endif
835	790
836	791	const configsetting_t lpDefaults[] = {
837	792	// Aliases

853	808	{ "server_read_timeout", "60", CONFIGSETTING_RELOADABLE }, // timeout during reading of XML request
854	809	{ "server_send_timeout", "60", CONFIGSETTING_RELOADABLE },
855	810	{ "server_max_keep_alive_requests", "100" },
856		#ifdef LINUX
857	811	{ "thread_stacksize", "512" },
858	812	{ "allow_local_users", "yes", CONFIGSETTING_RELOADABLE }, // allow any user connect through the unix socket
859	813	{ "local_admin_users", "root", CONFIGSETTING_RELOADABLE }, // this local user is admin

861	815	{ "run_as_group", "kopano" },
862	816	{ "pid_file", "/var/run/kopano/server.pid" },
863	817	{ "running_path", "/var/lib/kopano" },
	818	{"allocator_library", "libtcmalloc_minimal.so.4"},
864	819	{ "coredump_enabled", "yes" },
865	820
866	821	{ "license_path", "/etc/kopano/license", CONFIGSETTING_UNUSED },
867	822	{ "license_socket", "/var/run/kopano/licensed.sock" },
868	823	{ "license_timeout", "10", CONFIGSETTING_RELOADABLE},
869		#else
870		{ "local_admin_users", "SYSTEM" }, // this local user is admin
871		{ "license_path", "license", CONFIGSETTING_UNUSED },
872		#endif
873	824	{ "system_email_address", "postmaster@localhost", CONFIGSETTING_RELOADABLE },
874	825
875	826	{ "server_ssl_enabled", "no" },

881	832	{ "server_ssl_protocols", "!SSLv2" },
882	833	{ "server_ssl_ciphers", "ALL:!LOW:!SSLv2:!EXP:!aNULL" },
883	834	{ "server_ssl_prefer_server_ciphers", "no" },
884		#ifdef LINUX
885	835	{ "sslkeys_path", "/etc/kopano/sslkeys" }, // login keys
886		#else
887		{ "sslkeys_path", "sslkeys" },
888		#endif
889	836	// Database options
890	837	{ "database_engine", "mysql" },
891	838	// MySQL Settings

925	872	{ "audit_log_timestamp", "0" },
926	873
927	874	// user plugin
928		#ifdef LINUX
929	875	{ "plugin_path", PKGLIBDIR },
930	876	{ "user_plugin", "db" },
931	877	{ "user_plugin_config", "/etc/kopano/ldap.cfg" },

935	881	{ "deletegroup_script", "/etc/kopano/userscripts/deletegroup", CONFIGSETTING_RELOADABLE},
936	882	{ "createcompany_script", "/etc/kopano/userscripts/createcompany", CONFIGSETTING_RELOADABLE },
937	883	{ "deletecompany_script", "/etc/kopano/userscripts/deletecompany", CONFIGSETTING_RELOADABLE },
938		#else
939		{ "plugin_path", "plugins" },
940		{ "user_plugin", "ldap" },
941		{ "user_plugin_config", "ldap.cfg" },
942		{ "createuser_script", "createuser.bat", CONFIGSETTING_RELOADABLE },
943		{ "deleteuser_script", "deleteuser.bat", CONFIGSETTING_RELOADABLE },
944		{ "creategroup_script", "creategroup.bat", CONFIGSETTING_RELOADABLE },
945		{ "deletegroup_script", "deletegroup.bat", CONFIGSETTING_RELOADABLE },
946		{ "createcompany_script", "", CONFIGSETTING_RELOADABLE },
947		{ "deletecompany_script", "", CONFIGSETTING_RELOADABLE },
948		#endif
949	884	{ "user_safe_mode", "no", CONFIGSETTING_RELOADABLE },
950	885
951	886	// Storename format

994	929
995	930	{ "client_update_enabled", "no" },
996	931	{ "client_update_log_level", "1", CONFIGSETTING_RELOADABLE },
997		#ifdef LINUX
998	932	{ "client_update_path", "/var/lib/kopano/client", CONFIGSETTING_RELOADABLE },
999	933	{ "client_update_log_path", "/var/log/kopano/autoupdate", CONFIGSETTING_RELOADABLE },
1000		#else
1001		{ "client_update_path", "c:\\client_update_path", CONFIGSETTING_RELOADABLE },
1002		{ "client_update_log_path", "C:\\TEMP", CONFIGSETTING_RELOADABLE },
1003		#endif
1004	934	{ "index_services_enabled", "", CONFIGSETTING_UNUSED },
1005	935	{ "index_services_path", "", CONFIGSETTING_UNUSED },
1006	936	{ "index_services_search_timeout", "", CONFIGSETTING_UNUSED },

1030	960	{ NULL, NULL },
1031	961	};
1032	962
1033		#ifdef LINUX
1034	963	char buffer[256];
1035	964	confstr(_CS_GNU_LIBPTHREAD_VERSION, buffer, sizeof(buffer));
1036	965	if (strncmp(buffer, "linuxthreads", strlen("linuxthreads")) == 0)
1037	966	m_bNPTL = false;
1038		#endif
1039	967
1040	968	// Init random generator
1041	969	rand_init();

1048	976	// Load settings
1049	977	g_lpConfig = ECConfig::Create(lpDefaults);
1050	978
1051		if (!g_lpConfig->LoadSettings(szConfig) \|\| !g_lpConfig->ParseParams(argc, argv, NULL) \|\| (!m_bIgnoreUnknownConfigOptions && g_lpConfig->HasErrors()) ) {
	979	if (!g_lpConfig->LoadSettings(szConfig) \|\|
	980	!g_lpConfig->ParseParams(trim_argc, trim_argv, NULL) \|\|
	981	(!m_bIgnoreUnknownConfigOptions && g_lpConfig->HasErrors()) ) {
1052	982	g_lpLogger = new ECLogger_File(EC_LOGLEVEL_INFO, 0, "-", false); // create info logger without a timestamp to stderr
1053	983	ec_log_set(g_lpLogger);
1054	984	LogConfigErrors(g_lpConfig);
1055	985	er = MAPI_E_UNCONFIGURED;
1056	986	goto exit;
1057	987	}
	988
	989	kc_reexec_with_allocator(argv, g_lpConfig->GetSetting("allocator_library"));
1058	990
1059	991	// setup logging
1060	992	g_lpLogger = CreateLogger(g_lpConfig, szName, "KopanoServer");

1088	1020	er = KCERR_DATABASE_ERROR;
1089	1021	goto exit;
1090	1022	}
1091		#ifdef LINUX
1092	1023	if (stat(g_lpConfig->GetSetting("attachment_path"), &dir) != 0) {
1093	1024	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Unable to stat attachment directory '%s', error: %s", g_lpConfig->GetSetting("attachment_path"), strerror(errno));
1094	1025	er = KCERR_DATABASE_ERROR;

1107	1038	goto exit;
1108	1039	}
1109	1040	}
1110		#endif
1111	1041	#ifdef HAVE_LIBS3_H
1112	1042	} else if (strcmp(g_lpConfig->GetSetting("attachment_storage"), "s3") == 0) {
1113	1043	// @todo check S3 settings and connectivity

1118	1048	g_lpConfig->AddSetting("attachment_storage", "database");
1119	1049	}
1120	1050
1121		if (stricmp(g_lpConfig->GetSetting("user_plugin"), "db") == 0 && parseBool(g_lpConfig->GetSetting("sync_gab_realtime")) == false) {
	1051	if (strcasecmp(g_lpConfig->GetSetting("user_plugin"), "db") == 0 && parseBool(g_lpConfig->GetSetting("sync_gab_realtime")) == false) {
1122	1052	g_lpLogger->Log(EC_LOGLEVEL_INFO, "Unsupported sync_gab_realtime = no when using DB plugin. Enabling sync_gab_realtime.");
1123	1053	g_lpConfig->AddSetting("sync_gab_realtime", "yes");
1124	1054	}

1139	1069	bSSLEnabled = true;
1140	1070	else
1141	1071	bSSLEnabled = false;
1142
1143	1072
1144	1073	soap_ssl_init(); // Always call this in the main thread once!
1145	1074

1173	1102	}
1174	1103	}
1175	1104
1176		#ifdef LINUX
1177	1105	// Set max open file descriptors to FD_SETSIZE .. higher than this number
1178	1106	// is a bad idea, as it will start breaking select() calls.
1179	1107	struct rlimit limit;

1191	1119	er = MAPI_E_CALL_FAILED;
1192	1120	goto exit;
1193	1121	}
1194		#endif
	1122
1195	1123	// Priority queue is always enabled, create as first socket, so this socket is returned first too on activity
1196	1124	er = g_lpSoapServerConn->ListenPipe(g_lpConfig->GetSetting("server_pipe_priority"), true);
1197	1125	if (er != erSuccess) {

1226	1154
1227	1155	hosted = parseBool(g_lpConfig->GetSetting("enable_hosted_kopano"));
1228	1156	distributed = parseBool(g_lpConfig->GetSetting("enable_distributed_kopano"));
1229		#ifdef LINUX
1230	1157	// fork if needed and drop privileges as requested.
1231	1158	// this must be done before we do anything with pthreads
1232	1159	if (daemonize && unix_daemonize(g_lpConfig, g_lpLogger)) {

1236	1163	if (!daemonize)
1237	1164	setsid();
1238	1165	unix_create_pidfile(szName, g_lpConfig, g_lpLogger);
1239		#endif
1240	1166
1241	1167	mainthread = pthread_self();
1242	1168
1243		#ifdef LINUX
1244	1169	// SIGSEGV backtrace support
1245	1170	memset(&st, 0, sizeof(st));
1246	1171	memset(&act, 0, sizeof(act));

1256	1181	sigaction(SIGSEGV, &act, NULL);
1257	1182	sigaction(SIGBUS , &act, NULL);
1258	1183	sigaction(SIGABRT, &act, NULL);
1259
1260	1184
1261	1185	if (m_bNPTL) {
1262	1186	// normally ignore these signals

1277	1201	pthread_create(&signal_thread, NULL, signal_handler, NULL);
1278	1202	set_thread_name(signal_thread, "SignalHThread");
1279	1203	} else
1280		#endif
1281	1204	{
1282	1205	// reset signals to normal server usage
1283	1206	signal(SIGTERM , process_signal);
1284	1207	signal(SIGINT , process_signal); //CTRL+C
1285		#ifdef LINUX
1286	1208	signal(SIGHUP , process_signal); // logrotate
1287	1209	signal(SIGUSR1, process_signal);
1288	1210	signal(SIGUSR2, process_signal);
1289	1211	signal(SIGPIPE, process_signal);
1290		#endif
1291	1212	}
1292	1213
1293	1214	// ignore ignorable signals that might stop the server during database upgrade
1294	1215	// all these signals will be reset after the database upgrade part.
1295	1216	m_bDatabaseUpdateIgnoreSignals = true;
1296	1217
1297		#ifdef LINUX
1298	1218	// add a lock file to disable the /etc/init.d scripts
1299	1219	tmplock = open(upgrade_lock_file, O_CREAT \| O_EXCL, S_IRUSR \| S_IWUSR);
1300	1220
1301	1221	if (tmplock == -1)
1302	1222	g_lpLogger->Log(EC_LOGLEVEL_WARNING, "WARNING: Unable to place upgrade lockfile: %s", strerror(errno));
1303		#endif
1304	1223
1305	1224	#ifdef EMBEDDED_MYSQL
1306	1225	{

1322	1241
1323	1242	// perform database upgrade .. may take a very long time
1324	1243	er = lpDatabaseFactory->UpdateDatabase(m_bForceDatabaseUpdate, dbError);
1325
1326		#ifdef LINUX
1327	1244	// remove lock file
1328	1245	if (tmplock != -1) {
1329	1246	if (unlink(upgrade_lock_file) == -1)

1331	1248
1332	1249	close(tmplock);
1333	1250	}
1334		#endif
1335	1251
1336	1252	if(er == KCERR_INVALID_VERSION) {
1337	1253	g_lpLogger->Log(EC_LOGLEVEL_WARNING, "WARNING: %s", dbError.c_str());

1373	1289	er = check_attachment_storage_permissions();
1374	1290	if (er != erSuccess)
1375	1291	goto exit;
1376
1377	1292
1378	1293	// check upgrade problem with wrong sequence in tproperties table primary key
1379	1294	er = check_database_tproperties_key(lpDatabase);

1440	1355	}
1441	1356	// Close All sessions
1442	1357	kopano_removeallsessions();
1443
1444		#ifdef LINUX
1445	1358	if (m_bNPTL) {
1446	1359	g_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Joining signal thread");
1447	1360	pthread_join(signal_thread, NULL);
1448	1361	}
1449		#endif
1450
1451	1362	exit:
1452		if (er != erSuccess \|\| retval != 0) {
1453		std::string msg;
1454
1455		if (er != erSuccess)
1456		msg = format("An error occured (%x).", er);
1457		else
1458		msg = "An error occurred.";
1459
	1363	if (er != erSuccess) {
	1364	auto msg = format("An error occurred (%x).", er);
1460	1365	if (g_lpConfig)
1461	1366	msg += format(" Please check %s for details.", g_lpConfig->GetSetting("log_file"));
1462	1367	else

1471	1376	delete g_lpSoapServerConn;
1472	1377
1473	1378	delete g_lpScheduler;
1474
1475		#ifdef LINUX
1476	1379	free(st.ss_sp);
1477		#endif
1478	1380	delete lpDatabase;
1479	1381	delete lpDatabaseFactory;
1480
1481	1382
1482	1383	kopano_exit();
1483	1384

+9

-137

provider/server/ECSoapServerConnection.cpp less more

28	28	#include "ECSoapServerConnection.h"
29	29	#include "ECServerEntrypoint.h"
30	30	#include "ECClientUpdate.h"
31		#ifdef LINUX
32	31	# include <dirent.h>
33	32	# include <fcntl.h>
34	33	# include <unistd.h>
35	34	# include <kopano/UnixUtil.h>
36		#endif
37	35
38	36	extern ECLogger *g_lpLogger;
39	37

42	40	struct soap* lpSoap;
43	41	};
44	42
45		#ifdef LINUX
46	43	/**
47	44	* Creates a AF_UNIX socket in a given location and starts to listen
48	45	* on that socket.

73	70	}
74	71	memset(&saddr,0,sizeof(saddr));
75	72	saddr.sun_family = AF_UNIX;
76		strncpy(saddr.sun_path, unix_socket, sizeof(saddr.sun_path));
	73	kc_strlcpy(saddr.sun_path, unix_socket, sizeof(saddr.sun_path));
77	74	unlink(unix_socket);
78	75
79	76	if (bind(s, (struct sockaddr*)&saddr, 2 + strlen(unix_socket)) == -1) {
80	77	lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to bind to socket %s (%s). This is usually caused by another process (most likely another server) already using this port. This program will terminate now.", unix_socket, strerror(errno));
81		#ifdef LINUX
82	78	kill(0, SIGTERM);
83		#endif
84	79	exit(1);
85	80	}
86	81
87	82	er = chmod(unix_socket,mode);
88	83	if(er) {
89	84	lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to chmod socket %s. Error: %s", unix_socket, strerror(errno));
90		closesocket(s);
	85	close(s);
91	86	return -1;
92	87	}
93	88
94		#ifdef LINUX
95	89	if(er) {
96	90	lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to chown socket %s, to %s:%s. Error: %s", unix_socket, lpConfig->GetSetting("run_as_user"), lpConfig->GetSetting("run_as_group"), strerror(errno));
97		closesocket(s);
	91	close(s);
98	92	return -1;
99	93	}
100		#endif
101	94
102	95	if (listen(s, SOMAXCONN) == -1) {
103	96	lpLogger->Log(EC_LOGLEVEL_FATAL, "Can't listen on unix socket %s", unix_socket);
104		closesocket(s);
	97	close(s);
105	98	return -1;
106	99	}
107	100
108	101	return s;
109	102	}
110
111		#else
112
113		// Named pipe functions
114
115		// Create a namedpipe in windows
116		// the function must be called very time you have used the pipe
117		static int create_pipe_socket(const char lpszPipename, ECConfig lpConfig,
118		ECLogger *lpLogger, bool bInit, int mode)
119		{
120		HANDLE hPipe;
121
122		DWORD dwOpenMode = PIPE_ACCESS_DUPLEX \| // read/write access
123		FILE_FLAG_OVERLAPPED; // overlapped mode
124
125		if (bInit) {
126		// block create multiple instances of a pipe
127		dwOpenMode \|= FILE_FLAG_FIRST_PIPE_INSTANCE;
128		}
129
130		hPipe = CreateNamedPipeA(
131		lpszPipename, // pipe name
132		dwOpenMode,
133		PIPE_TYPE_BYTE \| // byte-oriented
134		PIPE_READMODE_BYTE \|
135		PIPE_WAIT, // blocking mode
136		PIPE_UNLIMITED_INSTANCES, // max. instances
137		0x10000, // output buffer size
138		0x10000, // input buffer size
139		1000, // client time-out
140		NULL); // default security attribute
141
142		if (hPipe == INVALID_HANDLE_VALUE)
143		{
144		lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to create pipe %s", lpszPipename);
145		return SOAP_INVALID_SOCKET;
146		}
147
148		return (int)hPipe;
149		}
150
151		// Override the soap function fsend
152		// Send data over a namedpipe
153		int gsoap_win_fsend(struct soap soap, const char s, size_t n)
154		{
155		DWORD ulWritten;
156
157		if(WriteFile((HANDLE)soap->socket, s, n, &ulWritten, NULL))
158		return SOAP_OK;
159		else
160		return SOAP_ERR;
161		}
162
163		// Override the soap function frecv
164		// receive date from a namedpipe
165		size_t gsoap_win_frecv(struct soap soap, char s, size_t n)
166		{
167		DWORD ulRead;
168
169		if(ReadFile((HANDLE)soap->socket, s, n, &ulRead, NULL))
170		return ulRead;
171		else
172		return 0;
173		}
174
175		// Override the soap function tcp_disconnect
176		// close the namedpipe
177		int gsoap_win_fclose(struct soap *soap)
178		{
179		if((HANDLE)soap->socket == INVALID_HANDLE_VALUE)
180		return SOAP_OK;
181
182		kopano_disconnect_soap_connection(soap);
183
184		// Flush the data so the client gets any left-over data, then disconnect and close the socket
185		FlushFileBuffers((HANDLE)soap->socket);
186		DisconnectNamedPipe((HANDLE)soap->socket);
187		CloseHandle((HANDLE)soap->socket); // ignore errors
188
189		// Master and socket are the same
190		soap->socket = (int)INVALID_HANDLE_VALUE;
191		soap->master = (int)INVALID_HANDLE_VALUE;
192
193		return SOAP_OK;
194		}
195
196		// Override the soap function tcp_disconnect
197		// close master, ignored by using namedpipe
198		int gsoap_win_closesocket(struct soap *soap, SOAP_SOCKET fd)
199		{
200		// is used only to close the master socket in a server upon soap_done()
201		// skip this for namedpipe
202		return SOAP_OK;
203		}
204
205		// Override the soap function tcp_shutdownsocket
206		// shutdown a socket ignored by using namedpipe
207		int gsoap_win_shutdownsocket(struct soap *soap, SOAP_SOCKET fd, int how)
208		{
209		// is used after completing a send operation to send TCP FIN
210		return SOAP_OK;
211		}
212
213
214		// TCP/SSL socket functions
215		#endif // #ifdef LINUX
216	103
217	104	/*
218	105	* Handles the HTTP GET command from soap, only the client update install may be downloaded.

245	132	m_lpLogger = lpLogger;
246	133	m_lpLogger->AddRef();
247	134
248		#ifdef LINUX
249	135	#ifdef USE_EPOLL
250	136	m_lpDispatcher = new ECDispatcherEPoll(lpLogger, lpConfig, ECSoapServerConnection::CreatePipeSocketCallback, this);
251	137	m_lpLogger->Log(EC_LOGLEVEL_INFO, "Using epoll events");

253	139	m_lpDispatcher = new ECDispatcherSelect(lpLogger, lpConfig, ECSoapServerConnection::CreatePipeSocketCallback, this);
254	140	m_lpLogger->Log(EC_LOGLEVEL_INFO, "Using select events");
255	141	#endif
256		#else
257		m_lpDispatcher = new ECDispatcherWin32(lpLogger, lpConfig, ECSoapServerConnection::CreatePipeSocketCallback, this);
258		#endif
259	142	}
260	143
261	144	ECSoapServerConnection::~ECSoapServerConnection(void)

282	165	if (bEnableGET)
283	166	lpsSoap->fget = http_get;
284	167
285		#ifdef LINUX
286	168	lpsSoap->bind_flags = SO_REUSEADDR;
287		#endif
288
289	169	lpsSoap->socket = socket = soap_bind(lpsSoap, *lpServerName == '\0' ? NULL : lpServerName, nServerPort, 100);
290	170	if (socket == -1) {
291	171	m_lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to bind to port %d: %s. This is usually caused by another process (most likely another server) already using this port. This program will terminate now.", nServerPort, lpsSoap->fault->faultstring);
292		#ifdef LINUX
293	172	kill(0, SIGTERM);
294		#endif
295	173	exit(1);
296	174	}
297	175

370	248	ssl_neg = true;
371	249	}
372	250
373		if (strcmp_ci(ssl_name, SSL_TXT_SSLV2) == 0)
	251	if (strcasecmp(ssl_name, SSL_TXT_SSLV2) == 0)
374	252	ssl_proto = 0x01;
375		else if (strcmp_ci(ssl_name, SSL_TXT_SSLV3) == 0)
	253	else if (strcasecmp(ssl_name, SSL_TXT_SSLV3) == 0)
376	254	ssl_proto = 0x02;
377		else if (strcmp_ci(ssl_name, SSL_TXT_TLSV1) == 0)
	255	else if (strcasecmp(ssl_name, SSL_TXT_TLSV1) == 0)
378	256	ssl_proto = 0x04;
379	257	#ifdef SSL_TXT_TLSV1_1
380		else if (strcmp_ci(ssl_name, SSL_TXT_TLSV1_1) == 0)
	258	else if (strcasecmp(ssl_name, SSL_TXT_TLSV1_1) == 0)
381	259	ssl_proto = 0x08;
382	260	#endif
383	261	#ifdef SSL_TXT_TLSV1_2
384		else if (strcmp_ci(ssl_name, SSL_TXT_TLSV1_2) == 0)
	262	else if (strcasecmp(ssl_name, SSL_TXT_TLSV1_2) == 0)
385	263	ssl_proto = 0x10;
386	264	#endif
387	265	else {

434	312
435	313	// request certificate from client, is OK if not present.
436	314	SSL_CTX_set_verify(lpsSoap->ctx, SSL_VERIFY_PEER \| SSL_VERIFY_CLIENT_ONCE, NULL);
437
438		#ifdef LINUX
439	315	lpsSoap->bind_flags = SO_REUSEADDR;
440		#endif
441
442	316	lpsSoap->socket = socket = soap_bind(lpsSoap, *lpServerName == '\0' ? NULL : lpServerName, nServerPort, 100);
443	317	if (socket == -1) {
444	318	m_lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to bind to port %d: %s (SSL). This is usually caused by another process (most likely another server) already using this port. This program will terminate now.", nServerPort, lpsSoap->fault->faultstring);
445		#ifdef LINUX
446	319	kill(0, SIGTERM);
447		#endif
448	320	exit(1);
449	321	}
450	322

+0

-5

provider/server/ECThreadManager.cpp less more

286	286	ECThreadManager::~ECThreadManager()
287	287	{
288	288	unsigned int ulThreads;
289		std::list<ECWorkerThread *>::const_iterator iterThreads;
290	289
291	290	// Wait for the threads to exit
292	291	while(1) {

706	705	return erSuccess;
707	706	}
708	707
709		#ifdef LINUX
710	708	ECDispatcherSelect::ECDispatcherSelect(ECLogger lpLogger, ECConfig lpConfig, CREATEPIPESOCKETCALLBACK lpCallback, void *lpCallbackParam) : ECDispatcher(lpLogger, lpConfig, lpCallback, lpCallbackParam)
711	709	{
712	710	int pipes[2];

722	720	ECRESULT er = erSuccess;
723	721	ECWatchDog *lpWatchDog = NULL;
724	722	std::map<int, ACTIVESOCKET>::iterator iterSockets;
725		std::map<int, ACTIVESOCKET>::const_iterator iterErase;
726	723	std::map<int, struct soap *>::const_iterator iterListenSockets;
727	724	int maxfds = 0;
728	725	char s = 0;

730	727	struct timeval tv;
731	728	CONNECTION_TYPE ulType;
732	729	int n = 0;
733
734	730
735	731	// This will start the threads
736	732	m_lpThreadManager = new ECThreadManager(m_lpLogger, this, atoui(m_lpConfig->GetSetting("threads")));

1144	1140	return erSuccess;
1145	1141	}
1146	1142	#endif
1147		#endif

+0

-38

~~provider/server/Makefile.am~~ less more

0		# -- Makefile --
1
2		AM_CPPFLAGS = ${ZCPPFLAGS} $(DEBUGFLAGS) $(BOOST_CPPFLAGS) \
3		-I${top_srcdir}/mapi4linux/include \
4		-I${top_srcdir}/provider/libserver -I${top_srcdir}/provider/plugins \
5		-I${top_srcdir}/provider/include -I${top_srcdir}/provider/common \
6		-I${top_srcdir}/provider/client -I${top_builddir}/provider/soap \
7		-I${top_srcdir}/provider/soap \
8		-I${top_srcdir}/common -I${top_srcdir}/m4lcommon \
9		-DPKGLIBDIR='"${pkglibdir}"' \
10		$(MYSQL_INCLUDES) $(GSOAP_CFLAGS) $(SSL_CFLAGS) $(SSL_HAS_EVP_PKEY_CMP) $(EPOLL_CFLAGS) $(KRB5_CFLAGS)
11
12		sbin_PROGRAMS = kopano-server
13		noinst_DATA = kopano-server.ldx
14
15		kopano_server_LDFLAGS = ${AM_LDFLAGS} -Wl,-E $(BOOST_FILESYSTEM_LDFLAGS)
16		kopano_server_LDADD = \
17		${top_builddir}/provider/libserver/libkcserver.la \
18		${GSOAP_LIBS} \
19		${top_builddir}/provider/soap/libkcsoapserver.la \
20		${top_builddir}/provider/common/libkccommon.la \
21		${top_builddir}/common/libkcutil.la \
22		${top_builddir}/common/libkcmapi.la \
23		${top_builddir}/common/libkcssl.la \
24		$(PROG_LIBS) ${icu_uc_LIBS} \
25		$(BOOST_FILESYSTEM_LIBS) $(BOOST_SYSTEM_LIBS) $(ICU_LIBS) $(DL_LIBS) \
26		$(MYSQL_LIBS) $(SSL_LIBS) $(PAM_LIBS) $(KRB5_LIBS) -lrt
27
28		kopano_server_SOURCES = ECServer.cpp \
29		ECSoapServerConnection.h ECSoapServerConnection.cpp \
30		ECClientUpdate.h ECClientUpdate.cpp \
31		ECThreadManager.h ECThreadManager.cpp
32
33		check-syntax:
34		$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \
35		-fsyntax-only -fmessage-length=0 ${CHK_SOURCES} -Wall -Wformat=2
36
37		include ../../global.am

+0

-43

~~provider/soap/Makefile.am~~ less more

0		# -- Makefile --
1
2		AM_CPPFLAGS = ${ZCPPFLAGS} -I${top_srcdir}/mapi4linux/include \
3		-I${top_srcdir}/provider/include ${GSOAP_CFLAGS}
4		AM_CXXFLAGS = ${ZCXXFLAGS} -Wno-sign-compare
5
6		lib_LTLIBRARIES = libkcsoapserver.la libkcsoapclient.la
7		#noinst_DATA = libkcsoapserver.ldd libkcsoapclient.ldd
8
9		nodist_libkcsoapserver_la_SOURCES = soapC.cpp soapServer.cpp
10		libkcsoapserver_la_LIBADD = ${GSOAP_LIBS}
11		libkcsoapserver_la_LDFLAGS = ${AM_LDFLAGS} \
12		-Wl,--version-script=${top_builddir}/default.sym
13		EXTRA_libkcsoapserver_la_DEPENDENCIES = ${top_builddir}/default.sym
14
15		nodist_libkcsoapclient_la_SOURCES = soapC.cpp soapClient.cpp
16		libkcsoapclient_la_LIBADD = ${GSOAP_LIBS}
17		libkcsoapclient_la_LDFLAGS = ${AM_LDFLAGS} \
18		-Wl,--version-script=${top_builddir}/default.sym
19		EXTRA_libkcsoapclient_la_DEPENDENCIES = ${top_builddir}/default.sym
20
21		SOAPHEADER = ${top_srcdir}/provider/include/proto.h
22		SOAP_INC = ${top_srcdir}/provider/include/
23		SOAP_NS = KCmd.nsmap KCmd.wsdl
24
25		SOAP_H_FILES = soapH.h soapStub.h
26		SOAP_CPP_CLIENT = soapClient.cpp soapC.cpp
27		SOAP_LIB_FILES = soapClientLib.cpp soapServerLib.cpp soapKCmdObject.h
28		SOAP_CPP_SRC=$(SOAP_CPP_CLIENT) soapServer.cpp $(SOAP_H_FILES) $(SOAP_NS) $(SOAP_LIB_FILES)
29
30		$(SOAP_CPP_SRC) : ns.xsd
31		ns.xsd: $(SOAPHEADER)
32		soapcpp2 -z1 -x -I$(SOAP_INC) $<
33
34		#libsoapserver_a_LDADD=$(SOAP_CPP_LIB)
35		BUILT_SOURCES=ns.xsd $(SOAP_CPP_SRC)
36		CLEANFILES=$(SOAP_CPP_SRC) .req.xml .res.xml .wsdl .nsmap .xsd Proxy\.h *~
37
38		check-syntax:
39		$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \
40		-fsyntax-only -fmessage-length=0 ${CHK_SOURCES} -Wall -Wformat=2
41
42		include ../../global.am

+1

-44

spooler/DAgent.cpp less more

55	55	#include <kopano/mapi_ptr.h>
56	56	#include "fileutil.h"
57	57	#include "PyMapiPlugin.h"
58
59		#ifdef LINUX
60	58	#include <cerrno>
61	59	#include <sys/types.h>
62	60	#include <sys/stat.h>
63	61	#include <unistd.h>
64		#include <climits>
65	62	#include <sys/mman.h>
66	63	#include <pwd.h>
67		#endif
68
69	64	#include "spmain.h"
70	65	#include "TmpPath.h"
71	66

104	99	#include <kopano/CommonUtil.h>
105	100	#include <kopano/Util.h>
106	101	#include <kopano/ECLogger.h>
107		#include <kopano/MAPIErrors.h>
108	102	#include <kopano/my_getopt.h>
109	103	#include <kopano/restrictionutil.h>
110	104	#include "rules.h"

123	117	#include <kopano/UnixUtil.h>
124	118	#include "LMTP.h"
125	119	#include <kopano/ecversion.h>
126		#include <kopano/platform.h>
127	120	#include <csignal>
128	121	#include "SSLUtil.h"
129	122	#include "StatsClient.h"

295	288	g_bQuit = true;
296	289	}
297	290
298		#ifdef LINUX
299	291	static void sighup(int sig)
300	292	{
301	293	if (g_lpConfig) {

327	319	generic_sigsegv_handler(g_lpLogger, "Spooler/DAgent",
328	320	PROJECT_VERSION_SPOOLER_STR, signr, si, uc);
329	321	}
330
331		#endif
332	322
333	323	/**
334	324	* Check if the message should be processed with the autoaccepter

411	401	MAPIFreeBuffer(lpProps);
412	402	return hr == hrSuccess;
413	403	}
414
415	404
416	405	/**
417	406	* Auto-respond to the passed message

588	577	MAPIFreeBuffer(lpEntryID);
589	578	return hr;
590	579	}
591
592	580
593	581	/**
594	582	* Save copy of the raw message

1413	1401	return hr;
1414	1402	}
1415	1403
1416		#ifdef LINUX
1417	1404	/**
1418	1405	* Write into the given fd, and if that fails log an error.
1419	1406	*

1791	1778	MAPIFreeBuffer(lpMessageProps);
1792	1779	return hr;
1793	1780	}
1794		#endif
1795	1781
1796	1782	/**
1797	1783	* Create an empty message for delivery

2358	2344	const WCHAR szUsername, IMAPISession *lppSession, bool bSuppress = false)
2359	2345	{
2360	2346	HRESULT hr = hrSuccess;
2361		#ifdef LINUX
2362	2347	struct passwd *pwd = NULL;
2363	2348	string strUnixUser;
2364		#endif
2365	2349
2366	2350	hr = HrOpenECSession(g_lpLogger, lppSession, "spooler/dagent", PROJECT_SVN_REV_STR, szUsername, L"", lpArgs->strPath.c_str(), 0, g_lpConfig->GetSetting("sslkey_file","",NULL), g_lpConfig->GetSetting("sslkey_pass","",NULL));
2367	2351	if (hr != hrSuccess) {

2375	2359	case MAPI_E_LOGON_FAILED:
2376	2360	// running dagent as unix user != lpRecip->strUsername and ! listed in local_admin_user, which gives this error too
2377	2361	if (!bSuppress) g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Access denied or connection failed for user %ls, using socket: '%s', error code: 0x%08X", szUsername, lpArgs->strPath.c_str(), hr);
2378		#ifdef LINUX
2379	2362	// so also log userid we're running as
2380	2363	pwd = getpwuid(getuid());
2381	2364	if (pwd && pwd->pw_name)

2383	2366	else
2384	2367	strUnixUser = stringify(getuid());
2385	2368	if (!bSuppress) g_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Current uid:%d username:%s", getuid(), strUnixUser.c_str());
2386		#endif
2387	2369	break;
2388	2370
2389	2371	default:

2466	2448	// continue, still send possible out-of-office message
2467	2449	}
2468	2450
2469		#ifdef LINUX
2470	2451	// do not send vacation message for junk messages
2471	2452	if (lpArgs->ulDeliveryMode != DM_JUNK &&
2472	2453	// do not send vacation message on delegated messages

2474	2455	{
2475	2456	SendOutOfOffice(lpAdrBook, lpStore, *lppMessage, lpRecip, lpArgs->strAutorespond);
2476	2457	}
2477		#endif
2478
2479	2458	exit:
2480	2459	if (lpUserSession)
2481	2460	lpUserSession->Release();

3573	3552	int err = 0;
3574	3553	unsigned int nMaxThreads;
3575	3554	int nCloseFDs = 0, pCloseFDs[1] = {0};
3576
3577		#ifdef LINUX
3578	3555	stack_t st;
3579	3556	struct sigaction act;
3580	3557	memset(&st, 0, sizeof(st));
3581	3558	memset(&act, 0, sizeof(act));
3582		#endif
3583	3559
3584	3560	nMaxThreads = atoui(g_lpConfig->GetSetting("lmtp_max_threads"));
3585	3561	if (nMaxThreads == 0 \|\| nMaxThreads == INT_MAX) {

3609	3585	signal(SIGTERM, sigterm);
3610	3586	signal(SIGINT, sigterm);
3611	3587
3612		#ifdef LINUX
3613	3588	signal(SIGHUP, sighup); // logrotate
3614	3589	signal(SIGCHLD, sigchld);
3615	3590	signal(SIGPIPE, SIG_IGN);

3651	3626	unix_create_pidfile(servicename, g_lpConfig, g_lpLogger);
3652	3627	g_lpLogger = StartLoggerProcess(g_lpConfig, g_lpLogger); // maybe replace logger
3653	3628	ec_log_set(g_lpLogger);
3654		#endif
	3629
3655	3630	hr = MAPIInitialize(NULL);
3656	3631	if (hr != hrSuccess) {
3657	3632	g_lpLogger->Log(EC_LOGLEVEL_FATAL, "Unable to initialize MAPI: %s (%x)",

3728	3703
3729	3704	g_lpLogger->Log(EC_LOGLEVEL_ALWAYS, "LMTP service will now exit");
3730	3705
3731		#ifdef LINUX
3732	3706	// in forked mode, send all children the exit signal
3733	3707	signal(SIGTERM, SIG_IGN);
3734	3708	kill(0, SIGTERM);

3744	3718	g_lpLogger->Log(EC_LOGLEVEL_NOTICE, "Forced shutdown with %d processes left", g_nLMTPThreads);
3745	3719	else
3746	3720	g_lpLogger->Log(EC_LOGLEVEL_INFO, "LMTP service shutdown complete");
3747		#endif
3748	3721
3749	3722	MAPIUninitialize();
3750	3723
3751	3724	exit:
3752	3725	ECChannel::HrFreeCtx();
3753		#ifdef LINUX
3754	3726	free(st.ss_sp);
3755		#endif
3756	3727	return hr;
3757	3728	}
3758	3729

3926	3897	cout << " -r\t\t Mark mail as read on delivery. Default: mark mail as new unread mail." << endl;
3927	3898	cout << " -l\t\t Run DAgent as LMTP listener" << endl;
3928	3899	cout << " -d\t\t Run DAgent as LMTP daemon, implicates -l. DAgent will run in the background." << endl;
3929		#ifdef LINUX
3930	3900	cout << endl;
3931	3901	cout << " -a responder\t path to autoresponder (e.g. /usr/local/bin/autoresponder)" << endl;
3932	3902	cout << "\t\t The autoresponder is called with </path/to/autoresponder> <from> <to> <subject> <kopano-username> <messagefile>" << endl;
3933	3903	cout << "\t\t when the autoresponder is enabled for this user, and -j is not specified" << endl;
3934		#endif
3935	3904	cout << endl;
3936	3905	cout << "<storename> is the name of the user where to deliver this mail." << endl;
3937	3906	cout << "If no file is specified with -f, it will be read from standard in." << endl;

3960	3929	sDeliveryArgs.bNewmailNotify = true;
3961	3930	sDeliveryArgs.ulDeliveryMode = DM_STORE;
3962	3931	imopt_default_delivery_options(&sDeliveryArgs.sDeliveryOpts);
3963
3964		#ifdef LINUX
3965	3932	const char *szConfig = ECConfig::GetDefaultPath("dagent.cfg");
3966		#else
3967		char *szConfig = "dagent.cfg";
3968		#if 0
3969		// FIXME
3970		ECNTService ecNTService;
3971		#endif
3972		#endif
3973	3933
3974	3934	enum {
3975	3935	OPT_HELP = UCHAR_MAX + 1,

4007	3967	static const configsetting_t lpDefaults[] = {
4008	3968	{ "server_bind", "" },
4009	3969	{ "server_bind_intf", "" },
4010		#ifdef LINUX
4011	3970	{ "run_as_user", "kopano" },
4012	3971	{ "run_as_group", "kopano" },
4013	3972	{ "pid_file", "/var/run/kopano/dagent.pid" },
4014	3973	{ "coredump_enabled", "no" },
4015		#endif
4016	3974	{ "lmtp_port", "2003" },
4017	3975	{ "lmtp_max_threads", "20" },
4018	3976	{ "process_model", "", CONFIGSETTING_UNUSED },

4203	4161	if (!bExplicitConfig && loglevel)
4204	4162	g_lpLogger->SetLoglevel(loglevel);
4205	4163
4206
4207	4164	/* Warn users that we are using the default configuration */
4208	4165	if (bDefaultConfigWarning && bExplicitConfig) {
4209	4166	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Unable to open configuration file %s", szConfig);

+6

-7

spooler/LMTP.cpp less more

39	39	#include "fileutil.h"
40	40
41	41	using namespace std;
42
43	42
44	43	LMTP::LMTP(ECChannel lpChan, const char szServerPath, ECLogger lpLog, ECConfig lpConf)
45	44	{

70	69	{
71	70	HRESULT hr = hrSuccess;
72	71
73		if (strnicmp(strCommand.c_str(), "LHLO", strlen("LHLO")) == 0)
	72	if (strncasecmp(strCommand.c_str(), "LHLO", strlen("LHLO")) == 0)
74	73	eCommand = LMTP_Command_LHLO;
75		else if (strnicmp(strCommand.c_str(), "MAIL FROM:", strlen("MAIL FROM:")) == 0)
	74	else if (strncasecmp(strCommand.c_str(), "MAIL FROM:", strlen("MAIL FROM:")) == 0)
76	75	eCommand = LMTP_Command_MAIL_FROM;
77		else if (strnicmp(strCommand.c_str(), "RCPT TO:", strlen("RCPT TO:")) == 0)
	76	else if (strncasecmp(strCommand.c_str(), "RCPT TO:", strlen("RCPT TO:")) == 0)
78	77	eCommand = LMTP_Command_RCPT_TO;
79		else if (strnicmp(strCommand.c_str(), "DATA", strlen("DATA")) == 0)
	78	else if (strncasecmp(strCommand.c_str(), "DATA", strlen("DATA")) == 0)
80	79	eCommand = LMTP_Command_DATA;
81		else if (strnicmp(strCommand.c_str(), "RSET", strlen("RSET")) == 0)
	80	else if (strncasecmp(strCommand.c_str(), "RSET", strlen("RSET")) == 0)
82	81	eCommand = LMTP_Command_RSET;
83		else if (strnicmp(strCommand.c_str(), "QUIT", strlen("QUIT")) == 0)
	82	else if (strncasecmp(strCommand.c_str(), "QUIT", strlen("QUIT")) == 0)
84	83	eCommand = LMTP_Command_QUIT;
85	84	else
86	85	hr = MAPI_E_CALL_FAILED;

+2

-2

spooler/Makefile.am less more

11	11
12	12	sbin_PROGRAMS = kopano-dagent kopano-spooler
13	13	noinst_DATA = kopano-dagent.ldx kopano-spooler.ldx
	14	CLEANFILES = ${noinst_DATA}
14	15
15	16	kopano_dagent_LDADD = ${top_builddir}/inetmapi/libkcinetmapi.la \
16	17	${top_builddir}/mapi4linux/src/libmapi.la \

39	40	PyMapiPlugin.cpp PyMapiPlugin.h PythonSWIGRuntime.h
40	41
41	42	BUILT_SOURCES=PythonSWIGRuntime.h
42
43		CLEANFILES=PythonSWIGRuntime.h
	43	CLEANFILES += PythonSWIGRuntime.h
44	44	EXTRA_DIST=PythonSWIGRuntime.h
45	45
46	46	PythonSWIGRuntime.h:

+0

-2

spooler/PyMapiPlugin.cpp less more

324	324	return hr;
325	325	}
326	326
327
328
329	327	PyMapiPluginFactory::PyMapiPluginFactory()
330	328	: m_ptrModMapiPlugin(NULL)
331	329	, m_bEnablePlugin(false)

+1

-39

spooler/Spooler.cpp less more

59	59	#include <kopano/CommonUtil.h>
60	60	#include <kopano/ECLogger.h>
61	61	#include <kopano/ECConfig.h>
62		#ifdef LINUX
63	62	#include <kopano/UnixUtil.h>
64		#endif
65		#include <kopano/MAPIErrors.h>
66	63	#include <kopano/my_getopt.h>
67	64	#include <kopano/ecversion.h>
68	65	#include <kopano/Util.h>

98	95	static int nReload = 0;
99	96	static int disconnects = 0;
100	97	static const char *szCommand = NULL;
101		#ifdef LINUX
102	98	static const char *szConfig = ECConfig::GetDefaultPath("spooler.cfg");
103		#else
104		static const char *szConfig = "spooler.cfg";
105		#endif
106	99	ECConfig *g_lpConfig = NULL;
107	100	ECLogger *g_lpLogger = NULL;
108	101
109		#ifdef LINUX
110	102	static pthread_t signal_thread;
111	103	static sigset_t signal_mask;
112	104	static bool bNPTL = true;
113		#endif
114	105
115	106	// notification
116	107	static bool bMessagesWaiting = false;

201	192	return 0;
202	193	}
203	194
204
205	195	/*
206	196	* starting fork, passes:
207	197	* -c config for all log settings and smtp server and such

212	202	* if (szSMTP) smtp host
213	203	* if (szSMTPPport) smtp port
214	204	*/
215		#ifdef LINUX
216	205	/**
217	206	* Starts a forked process which sends the actual mail, and removes it
218	207	* from the queue, in normal situations. On error, the

308	297	exit:
309	298	return hr;
310	299	}
311		#endif
312	300
313	301	/**
314	302	* Opens all required objects of the administrator to move an error

407	395	IECSpooler *lpSpooler)
408	396	{
409	397	HRESULT hr = hrSuccess;
410		std::map<pid_t, int>::const_iterator i, iDel;
	398	std::map<pid_t, int>::const_iterator i;
411	399	SendData sSendData;
412	400	bool bErrorMail;
413	401	map<pid_t, int> finished; // exit status of finished processes

905	893	return hr;
906	894	}
907	895
908		#ifdef LINUX
909	896	/**
910	897	* Segfault signal handler. Prints the backtrace of the crash in the log.
911	898	*

1009	996
1010	997	return NULL;
1011	998	}
1012		#endif
1013	999
1014	1000	/**
1015	1001	* Main program loop. Calls ProcessQueue, which logs in to MAPI. This

1099	1085	{ "smtp_server","localhost", CONFIGSETTING_RELOADABLE },
1100	1086	{ "smtp_port","25", CONFIGSETTING_RELOADABLE },
1101	1087	{ "server_socket", "default:" },
1102		#ifdef LINUX
1103	1088	{ "run_as_user", "kopano" },
1104	1089	{ "run_as_group", "kopano" },
1105	1090	{ "pid_file", "/var/run/kopano/spooler.pid" },
1106	1091	{ "running_path", "/var/lib/kopano" },
1107	1092	{ "coredump_enabled", "no" },
1108		#endif
1109	1093	{ "log_method","file" },
1110	1094	{ "log_file","-" },
1111	1095	{ "log_level", "3", CONFIGSETTING_RELOADABLE },

1136	1120	{ "tmp_path", "/tmp" },
1137	1121	{ NULL, NULL },
1138	1122	};
1139		#ifdef LINUX
1140	1123	// SIGSEGV backtrace support
1141	1124	stack_t st;
1142	1125	struct sigaction act;
1143	1126
1144	1127	memset(&st, 0, sizeof(st));
1145	1128	memset(&act, 0, sizeof(act));
1146		#endif
1147	1129
1148	1130	setlocale(LC_CTYPE, "");
1149	1131	setlocale(LC_MESSAGES, "");

1239	1221	szCommand = argv[0];
1240	1222
1241	1223	// setup logging, use pipe to log if started in forked mode and using pipe (file) logger, create normal logger for syslog
1242		#ifdef LINUX
1243	1224	if (bForked && logfd != -1)
1244	1225	g_lpLogger = new ECLogger_Pipe(logfd, 0, atoi(g_lpConfig->GetSetting("log_level")));
1245	1226	else
1246		#endif
1247	1227	g_lpLogger = CreateLogger(g_lpConfig, argv[0], "KopanoSpooler");
1248	1228
1249	1229	ec_log_set(g_lpLogger);

1253	1233	if (!TmpPath::getInstance() -> OverridePath(g_lpConfig))
1254	1234	g_lpLogger->Log(EC_LOGLEVEL_ERROR, "Ignoring invalid path-setting!");
1255	1235
1256		#ifdef LINUX
1257	1236	// detect linuxthreads, which is too broken to correctly run the spooler
1258	1237	if (!bForked) {
1259	1238	char buffer[256] = { 0 };

1266	1245	g_lpLogger->Log(EC_LOGLEVEL_WARNING, "WARNING: the kopano-spooler will only be able to send one message at a time.");
1267	1246	}
1268	1247	}
1269		#endif
1270	1248
1271	1249	// set socket filename
1272	1250	if (!szPath)

1276	1254	// keep sending mail when we're killed in forked mode
1277	1255	signal(SIGTERM, SIG_IGN);
1278	1256	signal(SIGINT, SIG_IGN);
1279		#ifdef LINUX
1280	1257	signal(SIGHUP, SIG_IGN);
1281	1258	signal(SIGUSR1, SIG_IGN);
1282	1259	signal(SIGUSR2, SIG_IGN);
1283		#endif
1284	1260	}
1285	1261	else {
1286	1262	pthread_mutex_init(&hMutexFinished, NULL);

1295	1271	sigaddset(&signal_mask, SIGUSR2);
1296	1272	}
1297	1273
1298		#ifdef LINUX
1299	1274	st.ss_sp = malloc(65536);
1300	1275	st.ss_flags = 0;
1301	1276	st.ss_size = 65536;

1307	1282	sigaction(SIGSEGV, &act, NULL);
1308	1283	sigaction(SIGBUS, &act, NULL);
1309	1284	sigaction(SIGABRT, &act, NULL);
1310		#endif
1311	1285
1312	1286	bQuit = bMessagesWaiting = false;
1313
1314		#ifdef LINUX
1315	1287	if (parseBool(g_lpConfig->GetSetting("coredump_enabled")))
1316	1288	unix_coredump_enable(g_lpLogger);
1317	1289

1335	1307	}
1336	1308	g_lpLogger = StartLoggerProcess(g_lpConfig, g_lpLogger);
1337	1309	ec_log_set(g_lpLogger);
1338		#endif
1339	1310	g_lpLogger->SetLogprefix(LP_PID);
1340	1311
1341	1312	hr = MAPIInitialize(NULL);

1345	1316	goto exit;
1346	1317	}
1347	1318
1348		#ifdef LINUX
1349	1319	if (!bForked) {
1350	1320	if (bNPTL) {
1351	1321	// valid for all threads afterwards

1363	1333	signal(SIGUSR2, process_signal);
1364	1334	}
1365	1335	}
1366		#endif
1367	1336
1368	1337	sc = new StatsClient(g_lpLogger);
1369	1338	sc->startup(g_lpConfig->GetSetting("z_statsd_stats"));

1374	1343
1375	1344	delete sc;
1376	1345
1377		#ifdef LINUX
1378	1346	if (!bForked) {
1379	1347	if (bNPTL) {
1380	1348	g_lpLogger->Log(EC_LOGLEVEL_DEBUG, "Joining signal thread");

1386	1354	signal(SIGCHLD, SIG_IGN);
1387	1355	}
1388	1356	}
1389		#endif
1390
1391	1357	MAPIUninitialize();
1392	1358
1393	1359	exit:
1394	1360	delete g_lpConfig;
1395	1361	DeleteLogger(g_lpLogger);
1396
1397		#ifdef LINUX
1398	1362	free(st.ss_sp);
1399		#endif
1400
1401	1363	switch(hr) {
1402	1364	case hrSuccess:
1403	1365	return EXIT_OK;

+0

-3

spooler/archive.cpp less more

46	46	typedef std::ostringstream tostringstream;
47	47	#endif
48	48
49
50	49	void ArchiveResult::AddMessage(MessagePtr ptrMessage) {
51	50	m_lstMessages.push_back(ptrMessage);
52	51	}

56	55	i != m_lstMessages.end(); ++i)
57	56	Util::HrDeleteMessage(lpSession, *i);
58	57	}
59
60	58
61	59	HRESULT Archive::Create(IMAPISession lpSession, ECLogger lpLogger, ArchivePtr *lpptrArchive)
62	60	{

239	237	return hr;
240	238	}
241	239
242
243	240	HRESULT Archive::HrArchiveMessageForSending(IMessage lpMessage, ArchiveResult lpResult)
244	241	{
245	242	HRESULT hr = hrSuccess;

+2

-7

spooler/mailer.cpp less more

1152	1152	lpPropValue[ulPropPos++].Value.bin.lpb = lpPropArrayOriginal[OR_SEARCH_KEY].Value.bin.lpb;
1153	1153	}
1154	1154
1155
1156	1155	// Add the original message into the errorMessage
1157	1156	hr = lpErrorMsg->CreateAttach(NULL, 0, &ulAttachNum, &lpAttach);
1158	1157	if (hr != hrSuccess) {

1868	1867	SizedSPropTagArray(3, sptaIDProps) = { 3, { PR_DISPLAY_NAME_W, PR_EC_SENDAS_USER_ENTRYIDS, PR_DISPLAY_TYPE } };
1869	1868	ULONG cValues = 0;
1870	1869
1871
1872	1870	hr = SMTPToZarafa(lpAddrBook, ulRepresentCB, lpRepresentEID, &sSpoofEID.Value.bin.cb, (LPENTRYID*)&sSpoofEID.Value.bin.lpb);
1873	1871	if (hr != hrSuccess)
1874	1872	hr = ContactToKopano(lpUserStore, lpAddrBook, ulRepresentCB, lpRepresentEID, &sSpoofEID.Value.bin.cb, (LPENTRYID*)&sSpoofEID.Value.bin.lpb);

2001	1999	LPSPropValue lpDelegates = NULL;
2002	2000	SPropValue sSpoofEID = {0};
2003	2001
2004
2005	2002	hr = SMTPToZarafa(lpAddrBook, ulRepresentCB, lpRepresentEID, &sSpoofEID.Value.bin.cb, (LPENTRYID*)&sSpoofEID.Value.bin.lpb);
2006	2003	if (hr != hrSuccess)
2007	2004	hr = ContactToKopano(lpUserStore, lpAddrBook, ulRepresentCB, lpRepresentEID, &sSpoofEID.Value.bin.cb, (LPENTRYID*)&sSpoofEID.Value.bin.lpb);

2426	2423	// ignore error if unable to open, just the copy of the mail might possibily not be done.
2427	2424	} else if(strcmp(g_lpConfig->GetSetting("allow_delegate_meeting_request"), "yes") == 0 &&
2428	2425	HrGetOneProp(lpMessage, PR_MESSAGE_CLASS_A, &lpMsgClass) == hrSuccess &&
2429		((stricmp(lpMsgClass->Value.lpszA, "IPM.Schedule.Meeting.Request" ) == 0) \|\|
2430		(stricmp(lpMsgClass->Value.lpszA, "IPM.Schedule.Meeting.Canceled" ) == 0))) {
	2426	((strcasecmp(lpMsgClass->Value.lpszA, "IPM.Schedule.Meeting.Request" ) == 0) \|\|
	2427	(strcasecmp(lpMsgClass->Value.lpszA, "IPM.Schedule.Meeting.Canceled" ) == 0))) {
2431	2428	// Meeting request can always sent as 'on behalf of' (Zarafa and SMTP user).
2432	2429	// This is needed if a user forward a meeting request. If you have permissions on a calendar,
2433	2430	// you can always sent with 'on behalve of'. This behavior is like exchange.

2604	2601	}
2605	2602	}
2606	2603
2607
2608	2604	// Now hand message to library which will send it, inetmapi will handle addressbook
2609	2605	hr = IMToINet(lpUserSession, lpAddrBook, lpMessage, lpMailer, sopt, g_lpLogger);
2610	2606

2644	2640	// We always return the processes message to the caller, whether it failed or not
2645	2641	if (lpMessage)
2646	2642	lpMessage->QueryInterface(IID_IMessage, (void**)lppMessage);
2647
2648	2643
2649	2644	if (lpMessage)
2650	2645	lpMessage->Release();

+3

-5

spooler/rules.cpp less more

221	221	++pos;
222	222	}
223	223
224
225	224	{
226	225	strHTMLForwardText = "<b>From:</b> ";
227	226	if (PROP_TYPE(ptrInfo[0].ulPropTag) != PT_ERROR)

410	409	goto exit;
411	410	}
412	411
413
414	412	// append To with original sender
415	413	// @todo get Reply-To ?
416	414	hr = lpOrigMessage->GetProps((LPSPropTagArray)&sReplyRecipient, 0, &cValues, &lpReplyRecipient);

723	721	sForwardProps[cfp++].Value.lpszW = LPWSTR(bDoPreserveSender ? L"redirect" : L"forward");
724	722	}
725	723
726		hr = lpFwdMsg->SetProps(cfp, (LPSPropValue)&sForwardProps, NULL);
	724	hr = lpFwdMsg->SetProps(cfp, sForwardProps, NULL);
727	725	if (hr != hrSuccess)
728	726	goto exit;
729	727

790	788	sNewProps[1].ulPropTag = PR_DELETE_AFTER_SUBMIT;
791	789	sNewProps[1].Value.b = TRUE;
792	790
793		hr = lpMessage->SetProps(2, (LPSPropValue)&sNewProps, NULL);
	791	hr = lpMessage->SetProps(2, sNewProps, NULL);
794	792	if (hr != hrSuccess)
795	793	goto exit;
796	794

1223	1221	GetSystemTimeAsFileTime(&sForwardProps[2].Value.ft);
1224	1222
1225	1223	// set forward in msg flag
1226		hr = (*lppMessage)->SetProps(3, (LPSPropValue)&sForwardProps, NULL);
	1224	hr = (*lppMessage)->SetProps(3, sForwardProps, NULL);
1227	1225	}
1228	1226
1229	1227	exit:

+3

-13

swig/Makefile.am less more

0		# make sure common swig lib builds first
1
2		SUBDIRS = . include/kopano python
3
4		AM_CPPFLAGS = ${ZCPPFLAGS} $(DEBUGFLAGS) \
5		-I$(top_srcdir)/mapi4linux/include -I$(top_srcdir)/provider/common \
6		-I${top_srcdir}/common -I${top_srcdir}/m4lcommon
	0	SUBDIRS = include/kopano python
7	1
8	2	EXTRA_DIST = edkmdb.i mapi.i mapiutil.i mapidefs.i mapicode.i mapix.i \
9		mapinotifsink.i typemap.i helpers.i IECExportChanges.i \
	3	mapinotifsink.i helpers.i IECExportChanges.i \
10	4	IECMultiStoreTable.i IECServiceAdmin.i IECSpooler.i \
11	5	IECTestProtocol.i IECLicense.i inetmapi.i icalmapi.i \
12		swig_iunknown.h ecdefs.i libcommon.i archiver.i licenseclient.i \
	6	ecdefs.i libcommon.i archiver.i licenseclient.i \
13	7	libfreebusy.i kopanosync.i ECLogger.i RecurrenceState.i \
14	8	RecurrenceState.swig.h
15
16		check-syntax:
17		$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \
18		-fsyntax-only -fmessage-length=0 ${CHK_SOURCES} -Wall -Wformat=2

+0

-5

swig/director_util.cpp less more

23	23	struct thread_info {
24	24	bool bCalledFromPython;
25	25	};
26
27
28		static void free_tls_data(void *lpvoid) {
29		delete (thread_info *)lpvoid;
30		}
31	26
32	27	static void make_key() {
33	28	pthread_key_create(&g_key, NULL); // We need cleanup here

+0

-3

swig/libcommon.i less more

21	21	%}
22	22
23	23	%include "wchar.i"
24		%include <windows.i>
25	24	%include "cstring.i"
26	25	%include "cwstring.i"
27	26	%include "std_string.i"

66	65	if(PyErr_Occurred())
67	66	goto fail;
68	67	}
69
70		bool ConvertFileFromUCS2ToUTF8(const std::string &, const std::string &);
71	68
72	69	// some common/rtfutil.h functions
73	70	HRESULT HrExtractHTMLFromRTF(std::string lpStrRTFIn, std::string &OUTPUT, ULONG ulCodepage);

+1

-1

swig/licenseclient.i less more

194	194	}
195	195	}
196	196
197		ECRESULT Auth(unsigned char lpData, unsigned int ulSize, unsigned char lpResponse, unsigned int lpulResponseSize);
	197	ECRESULT Auth(unsigned char lpData, unsigned int ulSize, void , unsigned int );
198	198	};

+0

-8

swig/mapi.i less more

16	16
17	17	// DIRTIEST HACK IN THE WORLD WARNING: we need to fix the broken swig output for mapi_wrap.h .....
18	18	#pragma include_alias( "mapi_wrap.h", "mapi_wrap_fixed.h" )
19
20		/*
21		* perl: CORE/thread.h can define PTHREAD_CREATE_JOINABLE to a value. This clashes with
22		* the windows pthread implementation, where it's used in an enum.
23		*/
24		#ifdef PTHREAD_CREATE_JOINABLE
25		#undef PTHREAD_CREATE_JOINABLE
26		#endif
27	19
28	20	#include "MAPINotifSink.h"
29	21	#include <kopano/director_util.h>

+9

-0

swig/python/MAPI/Tags.py less more

1288	1288	PR_EMSMDB_SECTION_UID = PROP_TAG(PT_BINARY, 0x3D15)
1289	1289	PR_EMS_AB_CONTAINERID = PROP_TAG(PT_LONG, 0xFFFD)
1290	1290
	1291	# MAPI Shortcuts
	1292	PR_WLINK_TYPE = PROP_TAG(PT_BINARY, 0x6849)
	1293	PR_WLINK_FLAGS = PROP_TAG(PT_LONG, 0x684A)
	1294	PR_WLINK_ORDINAL = PROP_TAG(PT_BINARY, 0x684B)
	1295	PR_WLINK_ENTRYID = PROP_TAG(PT_BINARY, 0x684C)
	1296	PR_WLINK_RECKEY = PROP_TAG(PT_BINARY, 0x684D)
	1297	PR_WLINK_STORE_ENTRYID = PROP_TAG(PT_BINARY, 0x684E)
	1298	PR_WLINK_SECTION = PROP_TAG(PT_BINARY, 0x6852)
	1299
1291	1300	# Freebusy properties
1292	1301	PR_FREEBUSY_START_RANGE = PROP_TAG(PT_LONG, 0x6847)
1293	1302	PR_FREEBUSY_END_RANGE = PROP_TAG(PT_LONG, 0x6848)

+21

-15

swig/python/Makefile.am less more

10	10	noinst_DATA = libkcpyconv.ldd _MAPICore.ldd _inetmapi.ldd _icalmapi.ldd \
11	11	_libcommon.ldd _archiver.ldd _libfreebusy.ldd _RecurrenceState.ldd \
12	12	_licenseclient.ldd
	13	CLEANFILES = ${noinst_DATA}
13	14
14	15	# disable warnings since code is mostly generated
15	16	AM_CPPFLAGS = ${ZCPPFLAGS} $(DEBUGFLAGS) \

18	19	$(PYTHON_INCLUDES) -I${top_srcdir}/swig -w \
19	20	-DSWIG_PYTHON_OUTPUT_TUPLE -DSWIG_TYPE_TABLE=MAPI
20	21
21		libkcpyconv_la_SOURCES = conversion.cpp conversion.h
	22	libkcpyconv_la_SOURCES = conversion.cpp
22	23	libkcpyconv_la_LDFLAGS = -Wl,--version-script=${top_builddir}/default.sym
23	24	libkcpyconv_la_LIBADD = ${PYTHON_LIBS} \
24	25	${top_builddir}/mapi4linux/src/libmapi.la
25		libkcpydirector_la_SOURCES = ../director_util.cpp ../director_util.h
	26	libkcpydirector_la_SOURCES = ../director_util.cpp
26	27	libkcpydirector_la_LDFLAGS = -Wl,--version-script=${top_builddir}/default.sym
27	28	libkcpydirector_la_LIBADD = -lpthread
28	29

61	62	${top_builddir}/ECtools/libkcarchivercore.la \
62	63	$(PROG_LIBS) $(PYTHON_LIBS)
63	64
64		_licenseclient_la_CPPFLAGS = ${AM_CPPFLAGS} -I${top_srcdir}/provider/common -I${top_builddir}/provider/soap -I${top_srcdir}/provider/soap ${GSOAP_CFLAGS}
	65	_licenseclient_la_CPPFLAGS = ${AM_CPPFLAGS} -I${top_srcdir}/provider/common -I${top_builddir}/provider/soap ${GSOAP_CFLAGS}
65	66	_licenseclient_la_LDFLAGS = ${AM_LDFLAGS} -module -avoid-version
66		_licenseclient_la_LIBADD = ${top_builddir}/provider/common/libkccommon.la \
	67	_licenseclient_la_LIBADD = ${top_builddir}/provider/libkccommon.la \
67	68	${GSOAP_LIBS} \
68		${top_builddir}/provider/soap/libkcsoapclient.la \
	69	${top_builddir}/provider/libkcsoapclient.la \
69	70	${top_builddir}/common/libkcmapi.la \
70	71	${top_builddir}/common/libkcutil.la \
71	72	${top_builddir}/common/libkcssl.la \

107	108	RecurrenceState_wrap.cxx
108	109
109	110
110		CLEANFILES = $(BUILT_SOURCES) \
	111	CLEANFILES += ${BUILT_SOURCES} \
111	112	MAPICore.py \
112	113	inetmapi.py \
113	114	icalmapi.py \

147	148	mapi_wrap.h: mapi_wrap.cxx
148	149	mapi_wrap.cxx: ../mapi.i ../mapiutil.i ../mapidefs.i ../mapicode.i ../mapix.i ../mapinotifsink.i ../mapiutil.i ../include/kopano/typemap.i ../helpers.i ../edkmdb.i ../IECServiceAdmin.i ../ecdefs.i include/kopano/typemap_python.i helpers_python.i
149	150	if test "x$(SWIG_EXEC)" = "x"; then echo "swig is required for 'make dist'"; exit 1; fi
150		${SWIG_EXEC} -I${top_srcdir}/swig -I${top_srcdir}/libsync ${SWIG_FLAGS} ${SWIG_CXXFLAGS} -o $@ $<
	151	${SWIG_EXEC} -I${top_srcdir}/libsync ${SWIG_FLAGS} ${SWIG_CXXFLAGS} -o $@ $<
151	152
152	153	inetmapi_wrap.cxx: ../inetmapi.i ../include/kopano/typemap.i ../inetmapi.i include/kopano/typemap_python.i helpers_python.i
153		${SWIG_EXEC} -I${top_srcdir}/swig ${SWIG_CXXFLAGS} -o $@ $<
	154	${SWIG_EXEC} ${SWIG_CXXFLAGS} -o $@ $<
154	155
155	156	icalmapi_wrap.cxx: ../icalmapi.i ../include/kopano/typemap.i include/kopano/typemap_python.i helpers_python.i ../../libicalmapi/icalmapi.h
156		${SWIG_EXEC} -I${top_srcdir}/libicalmapi -I${top_srcdir}/libfreebusy -I${top_srcdir/swig} ${SWIG_CXXFLAGS} -o $@ $<
	157	${SWIG_EXEC} -I${top_srcdir}/libicalmapi -I${top_srcdir}/libfreebusy ${SWIG_CXXFLAGS} -o $@ $<
157	158
158	159	archiver_wrap.cxx: ../archiver.i archiver_python.i
159	160	${SWIG_EXEC} -I${top_srcdir}/ECtools/archiver ${SWIG_CXXFLAGS} -o $@ $<
160	161
161	162	libcommon_wrap.cxx: ../libcommon.i
162		${SWIG_EXEC} -I${top_srcdir}/common -I${top_srcdir}/m4lcommon -I${top_srcdir/swig} ${SWIG_CXXFLAGS} -o $@ $<
	163	${SWIG_EXEC} -I${top_srcdir}/common -I${top_srcdir}/m4lcommon ${SWIG_CXXFLAGS} -o $@ $<
163	164
164	165	RecurrenceState_wrap.cxx: ../RecurrenceState.i
165		${SWIG_EXEC} -I${top_srcdir}/common -I${top_srcdir}/m4lcommon -I${top_srcdir/swig} ${SWIG_CXXFLAGS} -o $@ $<
	166	${SWIG_EXEC} -I${top_srcdir}/common -I${top_srcdir}/m4lcommon ${SWIG_CXXFLAGS} -o $@ $<
166	167
167	168	licenseclient_wrap.cxx: ../licenseclient.i
168		${SWIG_EXEC} -I${top_srcdir}/provider/common -I${top_srcdir}/common -I${top_srcdir}/m4lcommon -I${top_srcdir/swig} ${SWIG_CXXFLAGS} -o $@ $<
	169	${SWIG_EXEC} -I${top_srcdir}/provider/common -I${top_srcdir}/common -I${top_srcdir}/m4lcommon ${SWIG_CXXFLAGS} -o $@ $<
169	170
170	171	libfreebusy_wrap.cxx: ../libfreebusy.i
171		${SWIG_EXEC} -I${top_srcdir}/libfreebusy -I${top_srcdir/swig} ${SWIG_CXXFLAGS} -o $@ $<
	172	${SWIG_EXEC} -I${top_srcdir}/libfreebusy ${SWIG_CXXFLAGS} -o $@ $<
172	173
173	174	check-syntax:
174	175	$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) \

176	177
177	178	install-exec-local:
178	179	test "$(DISTRO)" = "suse" -o "$(DISTRO)" = "sles" && pyrpm="--record-rpm=INSTALLED_FILES"; \
179		cd ${srcdir} && ${PYTHON} setup.py install -f \
180		$${DESTDIR+--root=${DESTDIR}} \
	180	cd ${srcdir} && ${PYTHON} setup.py \
	181	build --build-base="${abs_builddir}/build" \
	182	install -f $${DESTDIR+--root=${DESTDIR}} \
181	183	--prefix="${prefix}" --install-purelib ${pythondir} $${pyrpm}
182	184	rm -Rf build
183	185
	186	uninstall-local:
	187	rm -Rf ${DESTDIR}${pythondir}/MAPI \
	188	${DESTDIR}${pythondir}/MAPI-1*.egg-info
	189
184	190	include ../../global.am

+0

-3

swig/python/archiver_conv.cpp less more

16	16
17	17	#include "archiver_conv.h"
18	18
19
20	19	PyObject* PyObject_from_Iterator(const ArchiveList::const_iterator &i) {
21	20	return Py_BuildValue("(sssi)", i->StoreName.c_str(), i->FolderName.c_str(), i->StoreOwner.c_str(), i->Rights);
22	21	}

24	23	PyObject* PyObject_from_Iterator(const UserList::const_iterator &i) {
25	24	return Py_BuildValue("s", i->UserName.c_str());
26	25	}
27
28	26
29	27	template<typename ListType>
30	28	PyObject* List_from(const ListType &lst)

59	57	return list;
60	58	}
61	59
62
63	60	PyObject* List_from_ArchiveList(const ArchiveList &lst)
64	61	{
65	62	return List_from<ArchiveList>(lst);

+1

-8

swig/python/conversion.cpp less more

103	103	#else
104	104	#define NATIVE_UNICODE 0
105	105	#endif
106
107	106
108	107	void Init()
109	108	{

488	487	return list;
489	488	}
490	489
491
492	490	void Object_to_LPSPropValue(PyObject object, LPSPropValue lpProp, ULONG ulFlags, void lpBase)
493	491	{
494	492	PyObject *ulPropTag = NULL;

727	725	CopyPyUnicode(&lpProp->Value.MVszW.lppszW[n], Value, lpBase);
728	726	}
729	727
730
731	728	Py_DECREF(elem);
732	729	++n;
733	730	}

802	799	return lpProp;
803	800	}
804	801	}
805
806	802
807	803	LPSPropValue List_to_LPSPropValue(PyObject object, ULONG cValues, ULONG ulFlags, void *lpBase)
808	804	{

2500	2496	{
2501	2497	LPMAPIERROR lpError = NULL;
2502	2498	if (MAPIAllocateBuffer(sizeof(LPMAPIERROR), (LPVOID*)&lpError) == hrSuccess)
2503		memset(lpError, 0, sizeof(LPMAPIERROR));
	2499	memset(lpError, 0, sizeof(*lpError));
2504	2500	return lpError;
2505	2501	}
2506	2502

2893	2889	return result;
2894	2890	}
2895	2891
2896
2897	2892	PyObject List_from_LPECUSER(ECUSER lpUser, ULONG cElements, ULONG ulFlags)
2898	2893	{
2899	2894	PyObject *list = PyList_New(0);

3076	3071	// @todo charset conversion ?
3077	3072	return PyObject_CallFunction(PyTypeECUserClientUpdateStatus, "(llsssl)", lpECUCUS->ulTrackId, lpECUCUS->tUpdatetime, lpECUCUS->lpszCurrentversion, lpECUCUS->lpszLatestversion, lpECUCUS->lpszComputername, lpECUCUS->ulStatus);
3078	3073	}
3079
3080	3074
3081	3075	LPROWLIST List_to_LPROWLIST(PyObject *object, ULONG ulFlags)
3082	3076	{

3308	3302	++lpSvrNameList->cServers;
3309	3303	}
3310	3304
3311
3312	3305	exit:
3313	3306	if(PyErr_Occurred()) {
3314	3307	MAPIFreeBuffer(lpSvrNameList);

+7

-2

swig/python/kopano/Makefile.am less more

9	9	kopano/daemon/version/version_info.py
10	10
11	11	install-exec-local:
12		cd ${srcdir} && ${PYTHON} setup.py install -f \
13		$${DESTDIR+--root=${DESTDIR}} \
	12	cd ${srcdir} && ${PYTHON} setup.py \
	13	build --build-base="${abs_builddir}/build" \
	14	install -f $${DESTDIR+--root=${DESTDIR}} \
14	15	--prefix="${prefix}" --install-purelib ${pythondir}
15	16	rm -Rf build
	17
	18	uninstall-local:
	19	rm -Rf ${DESTDIR}${pythondir}/kopano \
	20	${DESTDIR}${pythondir}/kopano-0*.egg-info

+93

-25

swig/python/kopano/kopano/__init__.py less more

0	0	"""
1		High-level python bindings
	1	High-level python bindings for Kopano
2	2
3	3	Copyright 2005 - 2016 Zarafa and its licensors (see LICENSE file for details)
4	4	Copyright 2016 Kopano and its licensors (see LICENSE file for details)

608	608	self.idname = REV_TAG.get(self.proptag) # XXX slow, often unused: make into properties?
609	609	self.type_ = PROP_TYPE(self.proptag)
610	610	self.typename = REV_TYPE.get(self.type_)
611		self.named = (self.id_ >= 0x8000)
	611	self.named = False
612	612	self.kind = None
613	613	self.kindname = None
614	614	self.guid = None
615	615	self.name = None
616	616	self.namespace = None
617	617
618		if self.named:
	618	if self.id_ >= 0x8000: # possible named prop
619	619	try:
620	620	lpname = self._parent_mapiobj.GetNamesFromIDs([self.proptag], None, 0)[0]
621		self.guid = bin2hex(lpname.guid)
622		self.namespace = GUID_NAMESPACE.get(lpname.guid)
623		self.name = lpname.id
624		self.kind = lpname.kind
625		self.kindname = 'MNID_STRING' if lpname.kind == MNID_STRING else 'MNID_ID'
	621	if lpname:
	622	self.guid = bin2hex(lpname.guid)
	623	self.namespace = GUID_NAMESPACE.get(lpname.guid)
	624	self.name = lpname.id
	625	self.kind = lpname.kind
	626	self.kindname = 'MNID_STRING' if lpname.kind == MNID_STRING else 'MNID_ID'
	627	self.named = True
626	628	except MAPIErrorNoSupport: # XXX user.props()?
627	629	pass
628	630

633	635	# The datetime object is of "naive" type, has local time and
634	636	# no TZ info. :-(
635	637	#
636		self._value = datetime.datetime.fromtimestamp(self.mapiobj.Value.unixtime)
637
	638	try:
	639	self._value = datetime.datetime.fromtimestamp(self.mapiobj.Value.unixtime)
	640	except ValueError: # Y10K: datetime is limited to 4-digit years
	641	self._value = datetime.datetime(9999, 1, 1)
638	642	else:
639	643	self._value = self.mapiobj.Value
640	644	return self._value

847	851	entryid = HrGetOneProp(self.mapistore, PR_STORE_ENTRYID).Value
848	852	self.pseudo_url = entryid[entryid.find(b'pseudo:'):-1] # XXX ECSERVER
849	853	self.name = self.pseudo_url[9:] # XXX get this kind of stuff from pr_ec_statstable_servers..?
850		self._archive_sessions = {}
851	854
852	855	def nodes(self): # XXX delay mapi sessions until actually needed
853	856	for row in self.table(PR_EC_STATSTABLE_SERVERS).dict_rows():

1262	1265	def hidden(self, value):
1263	1266	self._update(hidden=value)
1264	1267
1265		@property
1266		def groupid(self):
1267		return bin2hex(self._ecgroup.GroupID)
1268
1269	1268	# XXX: also does groups..
1270	1269	def add_user(self, user):
1271	1270	if isinstance(user, Group):

1497	1496	pass
1498	1497
1499	1498	@property
	1499	def findroot(self):
	1500	""" :class:`Folder` designated as search-results root """
	1501
	1502	try:
	1503	return self.root.folder('FINDER_ROOT')
	1504	except NotFoundError:
	1505	pass
	1506
	1507	@property
1500	1508	def inbox(self):
1501	1509	""" :class:`Folder` designated as inbox """
1502	1510

1539	1547
1540	1548	try:
1541	1549	return Folder(self, HrGetOneProp(self._root, PR_IPM_CONTACT_ENTRYID).Value)
	1550	except MAPIErrorNotFound:
	1551	pass
	1552
	1553	@property
	1554	def common_views(self):
	1555	""" :class:`Folder` contains folders for managing views for the message store """
	1556
	1557	try:
	1558	return Folder(self, self.prop(PR_COMMON_VIEWS_ENTRYID).value)
1542	1559	except MAPIErrorNotFound:
1543	1560	pass
1544	1561

1788	1805
1789	1806	def create_searchfolder(self, text=None): # XXX store.findroot.create_folder()?
1790	1807	import uuid # XXX username+counter? permission problems to determine number?
1791		finder_root = self.root.folder('FINDER_ROOT') # XXX store.findroot?
1792		mapiobj = finder_root.mapiobj.CreateFolder(FOLDER_SEARCH, str(uuid.uuid4()), 'comment', None, 0)
	1808	mapiobj = self.findroot.mapiobj.CreateFolder(FOLDER_SEARCH, str(uuid.uuid4()), 'comment', None, 0)
1793	1809	return Folder(self, mapiobj=mapiobj)
1794	1810
1795	1811	def permissions(self):

1797	1813
1798	1814	def permission(self, member, create=False):
1799	1815	return _permission(self, member, create)
	1816
	1817	def favorites(self):
	1818	"""Returns a list of favorite folders """
	1819
	1820	table = self.common_views.mapiobj.GetContentsTable(MAPI_ASSOCIATED)
	1821	table.SetColumns([PR_MESSAGE_CLASS, PR_SUBJECT, PR_WLINK_ENTRYID, PR_WLINK_FLAGS, PR_WLINK_ORDINAL, PR_WLINK_STORE_ENTRYID, PR_WLINK_TYPE], 0)
	1822	table.Restrict(SPropertyRestriction(RELOP_EQ, PR_MESSAGE_CLASS, SPropValue(PR_MESSAGE_CLASS, "IPM.Microsoft.WunderBar.Link")), TBL_BATCH)
	1823
	1824	for row in table.QueryRows(-1, 0):
	1825	entryid = bin2hex(row[2].Value)
	1826	store_entryid = bin2hex(row[5].Value)
	1827
	1828	if store_entryid != self.entryid: # XXX: Handle favorites from public stores
	1829	continue
	1830
	1831	try:
	1832	yield self.folder(entryid=bin2hex(row[2].Value))
	1833	except MAPIErrorNotFound:
	1834	pass
1800	1835
1801	1836	def __eq__(self, s): # XXX check same server?
1802	1837	if isinstance(s, Store):

2252	2287	searchfolder.search_wait()
2253	2288	for item in searchfolder:
2254	2289	yield item
2255		self.store.root.folder('FINDER_ROOT').mapiobj.DeleteFolder(searchfolder.entryid.decode('hex'), 0, None, 0) # XXX store.findroot
	2290	self.store.findroot.mapiobj.DeleteFolder(searchfolder.entryid.decode('hex'), 0, None, 0) # XXX store.findroot
2256	2291
2257	2292	def search_start(self, folder, text): # XXX RECURSIVE_SEARCH
2258	2293	# specific restriction format, needed to reach indexer

2308	2343	return self.primary_store.folder(entryid=entryid.encode('hex'))
2309	2344	except MAPIErrorNotFound:
2310	2345	pass
	2346
	2347	@property
	2348	def created(self):
	2349	try:
	2350	return self.prop(PR_CREATION_TIME).value
	2351	except MAPIErrorNotFound:
	2352	pass
2311	2353
2312	2354	def __eq__(self, f): # XXX check same store?
2313	2355	if isinstance(f, Folder):

2480	2522	def body(self, x):
2481	2523	self.mapiobj.SetProps([SPropValue(PR_BODY_W, unicode(x))])
2482	2524	self.mapiobj.SaveChanges(KEEP_OPEN_READWRITE)
	2525
	2526	@property
	2527	def created(self):
	2528	try:
	2529	return self.prop(PR_CREATION_TIME).value
	2530	except MAPIErrorNotFound:
	2531	pass
2483	2532
2484	2533	@property
2485	2534	def received(self):

2863	2912	for prop in self.props():
2864	2913	if (bestbody != PR_NULL and prop.proptag in (PR_BODY_W, PR_HTML, PR_RTF_COMPRESSED) and prop.proptag != bestbody):
2865	2914	continue
2866		if prop.id_ >= 0x8000: # named prop: prop.id_ system dependant..
	2915	if prop.named: # named prop: prop.id_ system dependant..
2867	2916	data = [prop.proptag, prop.mapiobj.Value, self.mapiobj.GetNamesFromIDs([prop.proptag], None, 0)[0]]
2868	2917	if not archiver and data[2].guid == PSETID_Archive:
2869	2918	continue

3724	3773	user_class = kwargs.get('user_class', self._ecuser.Class)
3725	3774	admin = kwargs.get('admin', self._ecuser.IsAdmin)
3726	3775
3727		usereid = self.server.sa.SetUser(ECUSER(Username=username, Password=password, Email=email, FullName=fullname,
3728		Class=user_class, UserID=self._ecuser.UserID, IsAdmin=admin, MVPropMap = self._ecuser.MVPropMap), MAPI_UNICODE)
	3776	# Thrown when a user tries to set his own features, handle gracefully otherwise you'll end up without a store
	3777	try:
	3778	# Pass the MVPropMAP otherwise the set values are reset
	3779	if hasattr(self._ecuser, 'MVPropMap'):
	3780	usereid = self.server.sa.SetUser(ECUSER(Username=username, Password=password, Email=email, FullName=fullname,
	3781	Class=user_class, UserID=self._ecuser.UserID, IsAdmin=admin, MVPropMap = self._ecuser.MVPropMap), MAPI_UNICODE)
	3782
	3783	else:
	3784	usereid = self.server.sa.SetUser(ECUSER(Username=username, Password=password, Email=email, FullName=fullname,
	3785	Class=user_class, UserID=self._ecuser.UserID, IsAdmin=admin), MAPI_UNICODE)
	3786	except MAPIErrorNoSupport:
	3787	pass
3729	3788
3730	3789	self._ecuser = self.server.sa.GetUser(self.server.sa.ResolveUserName(username, MAPI_UNICODE), MAPI_UNICODE)
3731	3790	if self.name != username:

3956	4015	log.info('stopping %s', service.name)
3957	4016
3958	4017	def daemonize(func, options=None, foreground=False, log=None, config=None, service=None):
3959		if log and service:
3960		log.info('starting %s', service.logname or service.name)
3961	4018	uid = gid = None
3962	4019	working_directory = '/'
3963	4020	pidfile = None

4457	4514	config2.update(config)
4458	4515	if getattr(options, 'config_file', None):
4459	4516	options.config_file = os.path.abspath(options.config_file) # XXX useful during testing. could be generalized with optparse callback?
	4517	if getattr(options, 'service', True) == False:
	4518	options.foreground = True
4460	4519	self.config = Config(config2, service=name, options=options)
4461	4520	self.config.data['server_socket'] = os.getenv("KOPANO_SOCKET") or self.config.data['server_socket']
4462	4521	if getattr(options, 'worker_processes', None):

4469	4528	self.log.error(msg)
4470	4529	sys.exit(1)
4471	4530	self.stats = collections.defaultdict(int, {'errors': 0})
	4531	self._server = None
4472	4532
4473	4533	@property
4474	4534	def server(self):
4475		return Server(options=self.options, config=self.config.data, log=self.log, service=self)
	4535	if self._server is None:
	4536	self._server = Server(options=self.options, config=self.config.data, log=self.log, service=self)
	4537	return self._server
4476	4538
4477	4539	def start(self):
4478	4540	for sig in (signal.SIGTERM, signal.SIGINT):
4479	4541	signal.signal(sig, lambda *args: sys.exit(-sig))
4480	4542	signal.signal(signal.SIGHUP, signal.SIG_IGN) # XXX long term, reload config?
	4543
	4544	self.log.info('starting %s', self.logname or self.name)
4481	4545	with log_exc(self.log):
4482		daemonize(self.main, options=self.options, log=self.log, config=self.config, service=self)
	4546	if getattr(self.options, 'service', True): # do not run-as-service (eg backup)
	4547	daemonize(self.main, options=self.options, log=self.log, config=self.config, service=self)
	4548	else:
	4549	daemon_helper(self.main, self, self.log)
4483	4550
4484	4551	class Worker(Process):
4485	4552	def __init__(self, service, name, **kwargs):

4499	4566	self.log.setLevel(loglevel)
4500	4567
4501	4568	def run(self):
	4569	self.service._server = None # do not re-use "forked" session
4502	4570	signal.signal(signal.SIGINT, signal.SIG_IGN)
4503	4571	signal.signal(signal.SIGHUP, signal.SIG_IGN)
4504	4572	signal.signal(signal.SIGTERM, lambda *args: sys.exit(0))

+6

-1

swig/python/kopano/kopano/daemon/daemon.py less more

513	513
514	514	"""
515	515	try:
516		os.setgroups([])
	516	# KC custom modification of python-daemon.
	517	# If we cannot get rid of the groups, leave them.
	518	try:
	519	os.setgroups([])
	520	except Exception, exc:
	521	pass
517	522	os.setgid(gid)
518	523	os.setuid(uid)
519	524	except Exception, exc:

+3

-3

swig/python/kopano/scripts/z-rest.py less more

67	67	if password == 'test':
68	68	try:
69	69	user = server.user(username)
70		except kopano.ZException:
	70	except kopano.Error:
71	71	return False
72	72	return True
73	73	return False

157	157	itemlist = []
158	158	try:
159	159	folder = user.store.folder(foldername)
160		except kopano.ZException:
	160	except kopano.Error:
161	161	return jsonify({'error': 'Folder does not exist'})
162	162	for item in folder.items():
163	163	itemlist.append({

174	174	def item(folderid, itemid):
175	175	try:
176	176	folder = user.store.folder(entryid=folderid)
177		except kopano.ZException:
	177	except kopano.Error:
178	178	return jsonify({'error': 'Folder does not exist'})
179	179	try:
180	180	item = folder.item(itemid)

+7

-2

swig/python/zarafa/Makefile.am less more

0	0	EXTRA_DIST = setup.py zarafa/__init__.py
1	1
2	2	install-exec-local:
3		cd ${srcdir} && ${PYTHON} setup.py install -f \
4		$${DESTDIR+--root=${DESTDIR}} \
	3	cd ${srcdir} && ${PYTHON} setup.py \
	4	build --build-base="${abs_builddir}/build" \
	5	install -f $${DESTDIR+--root=${DESTDIR}} \
5	6	--prefix="${prefix}" --install-purelib ${pythondir}
6	7	rm -Rf build
	8
	9	uninstall-local:
	10	rm -Rf ${DESTDIR}${pythondir}/zarafa \
	11	${DESTDIR}${pythondir}/zarafa-0*.egg-info

+9

-0

tools/searchfolder_create.py less more

	0	# Create a lot of dummy SFs
	1	import kopano
	2	s = kopano.Server(auth_user='bar', auth_pass='xbar')
	3	u = s.user('bar')
	4	for x in range(0, 10000):
	5	findroot = u.root.folder('FINDER_ROOT') # search folders are stored here as regular MAPI folders, but with the data coming from special DB tables
	6	print 'searchfolder count:', findroot.subfolder_count # count search folders
	7	sf = u.create_searchfolder() # create search folder in 'findroot'
	8	sf.search_start(u.inbox, 'blah')

+19

-0

tools/searchfolder_delete.py less more

	0	import datetime
	1	import kopano
	2	from MAPI.Tags import PR_CREATION_TIME
	3
	4	for u in kopano.users():
	5	print 'user', u
	6	try:
	7	findroot = u.root.folder('FINDER_ROOT')
	8	except:
	9	print 'ERROR getting findroot, skipping user'
	10	continue
	11	print findroot, findroot.subfolder_count
	12	for sf in findroot.folders():
	13	print sf, sf.entryid, sf.hierarchyid
	14	creation_time = sf.prop(PR_CREATION_TIME).value
	15	print 'created at', creation_time
	16	if creation_time < datetime.datetime.now()-datetime.timedelta(days=30):
	17	print 'DELETING!'
	18	findroot.delete(sf)

+26

-0

tools/searchfolders.txt less more

	0	# Count children of FINDER_ROOTs without using PR_SUBFOLDERS
	1	#
	2	SELECT COUNT(*)
	3	FROM properties AS p
	4	INNER JOIN hierarchy AS hp ON p.hierarchyid=hp.id AND p.tag=0x3001
	5	INNER JOIN hierarchy AS hc ON hp.id=hc.parent
	6	WHERE p.val_string="FINDER_ROOT";
	7
	8	# Uses PR_SUBFOLDERS hack to count
	9	# (It's an integer rather than a boolean in the KC DB)
	10	#
	11	SELECT SUM(p2.val_ulong)
	12	FROM properties AS p1
	13	INNER JOIN properties AS p2
	14	ON p1.hierarchyid=p2.hierarchyid AND p1.tag=0x3001 AND p2.tag=0x360A
	15	WHERE p1.val_string="FINDER_ROOT";
	16
	17	# Show distribution
	18	#
	19	SELECT p2.val_ulong
	20	FROM properties AS p1
	21	INNER JOIN properties AS p2
	22	ON p1.hierarchyid=p2.hierarchyid AND p1.tag=0x3001 AND p2.tag=0x360A
	23	WHERE p1.val_string="FINDER_ROOT"
	24	ORDER BY p2.val_ulong DESC
	25	LIMIT 25;