scmsubversion.cpp@ 80569

Last change on this file since 80569 was 80569, checked in by vboxsync, 5 years ago
Main: bugref:9341: Added VM autostart during boot support for windows host
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 55.9 KB

Line
1	/* $Id: scmsubversion.cpp 80569 2019-09-03 14:34:21Z vboxsync $ */
2	/** @file
3	* IPRT Testcase / Tool - Source Code Massager, Subversion Access.
4	*/
5
6	/*
7	* Copyright (C) 2010-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#define SCM_WITH_DYNAMIC_LIB_SVN
19
20
21	/*********************************************************************************************************************************
22	* Header Files *
23	*********************************************************************************************************************************/
24	#include <iprt/assert.h>
25	#include <iprt/ctype.h>
26	#include <iprt/dir.h>
27	#include <iprt/env.h>
28	#include <iprt/err.h>
29	#include <iprt/file.h>
30	#include <iprt/getopt.h>
31	#include <iprt/handle.h>
32	#include <iprt/initterm.h>
33	#include <iprt/ldr.h>
34	#include <iprt/mem.h>
35	#include <iprt/message.h>
36	#include <iprt/param.h>
37	#include <iprt/path.h>
38	#include <iprt/pipe.h>
39	#include <iprt/poll.h>
40	#include <iprt/process.h>
41	#include <iprt/stream.h>
42	#include <iprt/string.h>
43
44	#include "scm.h"
45
46	#if defined(SCM_WITH_DYNAMIC_LIB_SVN) && defined(SCM_WITH_SVN_HEADERS)
47	# include <svn_client.h>
48	#endif
49
50
51	/*********************************************************************************************************************************
52	* Defined Constants And Macros *
53	*********************************************************************************************************************************/
54	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
55	# if defined(RT_OS_WINDOWS) && defined(RT_ARCH_X86)
56	# define APR_CALL __stdcall
57	# define SVN_CALL /* __stdcall ?? */
58	# else
59	# define APR_CALL
60	# define SVN_CALL
61	# endif
62	#endif
63	#if defined(SCM_WITH_DYNAMIC_LIB_SVN) && !defined(SCM_WITH_SVN_HEADERS)
64	# define SVN_ERR_MISC_CATEGORY_START 200000
65	# define SVN_ERR_UNVERSIONED_RESOURCE (SVN_ERR_MISC_CATEGORY_START + 5)
66	#endif
67
68
69	/*********************************************************************************************************************************
70	* Structures and Typedefs *
71	*********************************************************************************************************************************/
72	#if defined(SCM_WITH_DYNAMIC_LIB_SVN) && !defined(SCM_WITH_SVN_HEADERS)
73	typedef int apr_status_t;
74	typedef int64_t apr_time_t;
75	typedef struct apr_pool_t apr_pool_t;
76	typedef struct apr_hash_t apr_hash_t;
77	typedef struct apr_hash_index_t apr_hash_index_t;
78	typedef struct apr_array_header_t apr_array_header_t;
79
80
81	typedef struct svn_error_t
82	{
83	apr_status_t apr_err;
84	const char *_dbgr_message;
85	struct svn_error_t *_dbgr_child;
86	apr_pool_t *_dbgr_pool;
87	const char *_dbgr_file;
88	long _dbgr_line;
89	} svn_error_t;
90	typedef int svn_boolean_t;
91	typedef long int svn_revnum_t;
92	typedef struct svn_client_ctx_t svn_client_ctx_t;
93	typedef enum svn_opt_revision_kind
94	{
95	svn_opt_revision_unspecified = 0,
96	svn_opt_revision_number,
97	svn_opt_revision_date,
98	svn_opt_revision_committed,
99	svn_opt_revision_previous,
100	svn_opt_revision_base,
101	svn_opt_revision_working,
102	svn_opt_revision_head
103	} svn_opt_revision_kind;
104	typedef union svn_opt_revision_value_t
105	{
106	svn_revnum_t number;
107	apr_time_t date;
108	} svn_opt_revision_value_t;
109	typedef struct svn_opt_revision_t
110	{
111	svn_opt_revision_kind kind;
112	svn_opt_revision_value_t value;
113	} svn_opt_revision_t;
114	typedef enum svn_depth_t
115	{
116	svn_depth_unknown = -2,
117	svn_depth_exclude,
118	svn_depth_empty,
119	svn_depth_files,
120	svn_depth_immediates,
121	svn_depth_infinity
122	} svn_depth_t;
123
124	#endif /* SCM_WITH_DYNAMIC_LIB_SVN && !SCM_WITH_SVN_HEADERS */
125
126
127	/*********************************************************************************************************************************
128	* Global Variables *
129	*********************************************************************************************************************************/
130	static char g_szSvnPath[RTPATH_MAX];
131	static enum
132	{
133	kScmSvnVersion_Ancient = 1,
134	kScmSvnVersion_1_6,
135	kScmSvnVersion_1_7,
136	kScmSvnVersion_1_8,
137	kScmSvnVersion_End
138	} g_enmSvnVersion = kScmSvnVersion_Ancient;
139
140
141	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
142	/** Set if all the function pointers are valid. */
143	static bool g_fSvnFunctionPointersValid;
144	/** @name SVN and APR imports.
145	* @{ */
146	static apr_status_t (APR_CALL *g_pfnAprInitialize)(void);
147	static apr_hash_index_t * (APR_CALL g_pfnAprHashFirst)(apr_pool_t pPool, apr_hash_t *pHashTab);
148	static apr_hash_index_t * (APR_CALL g_pfnAprHashNext)(apr_hash_index_t pCurIdx);
149	static void * (APR_CALL g_pfnAprHashThisVal)(apr_hash_index_t pHashIdx);
150	static apr_pool_t * (SVN_CALL g_pfnSvnPoolCreateEx)(apr_pool_t pParent, void *pvAllocator);
151	static void (APR_CALL g_pfnAprPoolClear)(apr_pool_t pPool);
152	static void (APR_CALL g_pfnAprPoolDestroy)(apr_pool_t pPool);
153
154	static svn_error_t * (SVN_CALL g_pfnSvnClientCreateContext)(svn_client_ctx_t ppCtx, apr_pool_t pPool);
155	static svn_error_t * (SVN_CALL g_pfnSvnClientPropGet4)(apr_hash_t ppHashProps, const char pszPropName,
156	const char pszTarget, const svn_opt_revision_t pPeggedRev,
157	const svn_opt_revision_t pRevision, svn_revnum_t pActualRev,
158	svn_depth_t enmDepth, const apr_array_header_t *pChangeList,
159	svn_client_ctx_t pCtx, apr_pool_t pResultPool,
160	apr_pool_t *pScratchPool);
161	/*@} /
162
163	/** Cached APR pool. */
164	static apr_pool_t *g_pSvnPool = NULL;
165	/** Cached SVN client context. */
166	static svn_client_ctx_t *g_pSvnClientCtx = NULL;
167	/** Number of times the current context has been used. */
168	static uint32_t g_cSvnClientCtxUsed = 0;
169
170	#endif
171
172
173	/*********************************************************************************************************************************
174	* Internal Functions *
175	*********************************************************************************************************************************/
176	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
177	static void scmSvnFlushClientContextAndPool(void);
178	#endif
179
180
181
182	/**
183	* Callback that is call for each path to search.
184	*/
185	static DECLCALLBACK(int) scmSvnFindSvnBinaryCallback(char const pchPath, size_t cchPath, void pvUser1, void *pvUser2)
186	{
187	char pszDst = (char )pvUser1;
188	size_t cchDst = (size_t)pvUser2;
189	if (cchDst > cchPath)
190	{
191	memcpy(pszDst, pchPath, cchPath);
192	pszDst[cchPath] = '\0';
193	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
194	int rc = RTPathAppend(pszDst, cchDst, "svn.exe");
195	#else
196	int rc = RTPathAppend(pszDst, cchDst, "svn");
197	#endif
198	if ( RT_SUCCESS(rc)
199	&& RTFileExists(pszDst))
200	return VINF_SUCCESS;
201	}
202	return VERR_TRY_AGAIN;
203	}
204
205
206	/**
207	* Reads from a pipe.
208	*
209	* @returns @a rc or other status code.
210	* @param rc The current status of the operation. Error status
211	* are preserved and returned.
212	* @param phPipeR Pointer to the pipe handle.
213	* @param pcbAllocated Pointer to the buffer size variable.
214	* @param poffCur Pointer to the buffer offset variable.
215	* @param ppszBuffer Pointer to the buffer pointer variable.
216	*/
217	static int rtProcProcessOutput(int rc, PRTPIPE phPipeR, size_t pcbAllocated, size_t poffCur, char **ppszBuffer,
218	RTPOLLSET hPollSet, uint32_t idPollSet)
219	{
220	size_t cbRead;
221	char szTmp[_4K - 1];
222	for (;;)
223	{
224	int rc2 = RTPipeRead(*phPipeR, szTmp, sizeof(szTmp), &cbRead);
225	if (RT_SUCCESS(rc2) && cbRead)
226	{
227	/* Resize the buffer. */
228	if (poffCur + cbRead >= pcbAllocated)
229	{
230	if (*pcbAllocated >= _1G)
231	{
232	RTPollSetRemove(hPollSet, idPollSet);
233	rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
234	*phPipeR = NIL_RTPIPE;
235	return RT_SUCCESS(rc) ? VERR_TOO_MUCH_DATA : rc;
236	}
237
238	size_t cbNew = pcbAllocated ? pcbAllocated * 2 : sizeof(szTmp) + 1;
239	Assert(*poffCur + cbRead < cbNew);
240	rc2 = RTStrRealloc(ppszBuffer, cbNew);
241	if (RT_FAILURE(rc2))
242	{
243	RTPollSetRemove(hPollSet, idPollSet);
244	rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
245	*phPipeR = NIL_RTPIPE;
246	return RT_SUCCESS(rc) ? rc2 : rc;
247	}
248	*pcbAllocated = cbNew;
249	}
250
251	/* Append the new data, terminating it. */
252	memcpy(ppszBuffer + poffCur, szTmp, cbRead);
253	*poffCur += cbRead;
254	(ppszBuffer)[poffCur] = '\0';
255
256	/* Check for null terminators in the string. */
257	if (RT_SUCCESS(rc) && memchr(szTmp, '\0', cbRead))
258	rc = VERR_NO_TRANSLATION;
259
260	/* If we read a full buffer, try read some more. */
261	if (RT_SUCCESS(rc) && cbRead == sizeof(szTmp))
262	continue;
263	}
264	else if (rc2 != VINF_TRY_AGAIN)
265	{
266	if (RT_FAILURE(rc) && rc2 != VERR_BROKEN_PIPE)
267	rc = rc2;
268	RTPollSetRemove(hPollSet, idPollSet);
269	rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
270	*phPipeR = NIL_RTPIPE;
271	}
272	return rc;
273	}
274	}
275
276	/** @name RTPROCEXEC_FLAGS_XXX - flags for RTProcExec and RTProcExecToString.
277	* @{ */
278	/** Redirect /dev/null to standard input. */
279	#define RTPROCEXEC_FLAGS_STDIN_NULL RT_BIT_32(0)
280	/** Redirect standard output to /dev/null. */
281	#define RTPROCEXEC_FLAGS_STDOUT_NULL RT_BIT_32(1)
282	/** Redirect standard error to /dev/null. */
283	#define RTPROCEXEC_FLAGS_STDERR_NULL RT_BIT_32(2)
284	/** Redirect all standard output to /dev/null as well as directing /dev/null
285	* to standard input. */
286	#define RTPROCEXEC_FLAGS_STD_NULL ( RTPROCEXEC_FLAGS_STDIN_NULL \
287	\| RTPROCEXEC_FLAGS_STDOUT_NULL \
288	\| RTPROCEXEC_FLAGS_STDERR_NULL)
289	/** Mask containing the valid flags. */
290	#define RTPROCEXEC_FLAGS_VALID_MASK UINT32_C(0x00000007)
291	/** @} */
292
293	/**
294	* Runs a process, collecting the standard output and/or standard error.
295	*
296	*
297	* @returns IPRT status code
298	* @retval VERR_NO_TRANSLATION if the output of the program isn't valid UTF-8
299	* or contains a nul character.
300	* @retval VERR_TOO_MUCH_DATA if the process produced too much data.
301	*
302	* @param pszExec Executable image to use to create the child process.
303	* @param papszArgs Pointer to an array of arguments to the child. The
304	* array terminated by an entry containing NULL.
305	* @param hEnv Handle to the environment block for the child.
306	* @param fFlags A combination of RTPROCEXEC_FLAGS_XXX. The @a
307	* ppszStdOut and @a ppszStdErr parameters takes precedence
308	* over redirection flags.
309	* @param pStatus Where to return the status on success.
310	* @param ppszStdOut Where to return the text written to standard output. If
311	* NULL then standard output will not be collected and go
312	* to the standard output handle of the process.
313	* Free with RTStrFree, regardless of return status.
314	* @param ppszStdErr Where to return the text written to standard error. If
315	* NULL then standard output will not be collected and go
316	* to the standard error handle of the process.
317	* Free with RTStrFree, regardless of return status.
318	*/
319	int RTProcExecToString(const char pszExec, const char const *papszArgs, RTENV hEnv, uint32_t fFlags,
320	PRTPROCSTATUS pStatus, char ppszStdOut, char ppszStdErr)
321	{
322	int rc2;
323
324	/*
325	* Clear output arguments (no returning failure here, simply crash!).
326	*/
327	AssertPtr(pStatus);
328	pStatus->enmReason = RTPROCEXITREASON_ABEND;
329	pStatus->iStatus = RTEXITCODE_FAILURE;
330	AssertPtrNull(ppszStdOut);
331	if (ppszStdOut)
332	*ppszStdOut = NULL;
333	AssertPtrNull(ppszStdOut);
334	if (ppszStdErr)
335	*ppszStdErr = NULL;
336
337	/*
338	* Check input arguments.
339	*/
340	AssertReturn(!(fFlags & ~RTPROCEXEC_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
341
342	/*
343	* Do we need a standard input bitbucket?
344	*/
345	int rc = VINF_SUCCESS;
346	PRTHANDLE phChildStdIn = NULL;
347	RTHANDLE hChildStdIn;
348	hChildStdIn.enmType = RTHANDLETYPE_FILE;
349	hChildStdIn.u.hFile = NIL_RTFILE;
350	if ((fFlags & RTPROCEXEC_FLAGS_STDIN_NULL) && RT_SUCCESS(rc))
351	{
352	phChildStdIn = &hChildStdIn;
353	rc = RTFileOpenBitBucket(&hChildStdIn.u.hFile, RTFILE_O_READ);
354	}
355
356	/*
357	* Create the output pipes / bitbuckets.
358	*/
359	RTPIPE hPipeStdOutR = NIL_RTPIPE;
360	PRTHANDLE phChildStdOut = NULL;
361	RTHANDLE hChildStdOut;
362	hChildStdOut.enmType = RTHANDLETYPE_PIPE;
363	hChildStdOut.u.hPipe = NIL_RTPIPE;
364	if (ppszStdOut && RT_SUCCESS(rc))
365	{
366	phChildStdOut = &hChildStdOut;
367	rc = RTPipeCreate(&hPipeStdOutR, &hChildStdOut.u.hPipe, 0 /fFlags/);
368	}
369	else if ((fFlags & RTPROCEXEC_FLAGS_STDOUT_NULL) && RT_SUCCESS(rc))
370	{
371	phChildStdOut = &hChildStdOut;
372	hChildStdOut.enmType = RTHANDLETYPE_FILE;
373	hChildStdOut.u.hFile = NIL_RTFILE;
374	rc = RTFileOpenBitBucket(&hChildStdOut.u.hFile, RTFILE_O_WRITE);
375	}
376
377	RTPIPE hPipeStdErrR = NIL_RTPIPE;
378	PRTHANDLE phChildStdErr = NULL;
379	RTHANDLE hChildStdErr;
380	hChildStdErr.enmType = RTHANDLETYPE_PIPE;
381	hChildStdErr.u.hPipe = NIL_RTPIPE;
382	if (ppszStdErr && RT_SUCCESS(rc))
383	{
384	phChildStdErr = &hChildStdErr;
385	rc = RTPipeCreate(&hPipeStdErrR, &hChildStdErr.u.hPipe, 0 /fFlags/);
386	}
387	else if ((fFlags & RTPROCEXEC_FLAGS_STDERR_NULL) && RT_SUCCESS(rc))
388	{
389	phChildStdErr = &hChildStdErr;
390	hChildStdErr.enmType = RTHANDLETYPE_FILE;
391	hChildStdErr.u.hFile = NIL_RTFILE;
392	rc = RTFileOpenBitBucket(&hChildStdErr.u.hFile, RTFILE_O_WRITE);
393	}
394
395	if (RT_SUCCESS(rc))
396	{
397	RTPOLLSET hPollSet;
398	rc = RTPollSetCreate(&hPollSet);
399	if (RT_SUCCESS(rc))
400	{
401	if (hPipeStdOutR != NIL_RTPIPE && RT_SUCCESS(rc))
402	rc = RTPollSetAddPipe(hPollSet, hPipeStdOutR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR, 1);
403	if (hPipeStdErrR != NIL_RTPIPE)
404	rc = RTPollSetAddPipe(hPollSet, hPipeStdErrR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR, 2);
405	}
406	if (RT_SUCCESS(rc))
407	{
408	/*
409	* Create the process.
410	*/
411	RTPROCESS hProc;
412	rc = RTProcCreateEx(pszExec,
413	papszArgs,
414	hEnv,
415	0 /fFlags/,
416	NULL /phStdIn/,
417	phChildStdOut,
418	phChildStdErr,
419	NULL /pszAsUser/,
420	NULL /pszPassword/,
421	NULL /pvExtraData/,
422	&hProc);
423	rc2 = RTHandleClose(&hChildStdErr); AssertRC(rc2);
424	rc2 = RTHandleClose(&hChildStdOut); AssertRC(rc2);
425
426	if (RT_SUCCESS(rc))
427	{
428	/*
429	* Process output and wait for the process to finish.
430	*/
431	size_t cbStdOut = 0;
432	size_t offStdOut = 0;
433	size_t cbStdErr = 0;
434	size_t offStdErr = 0;
435	for (;;)
436	{
437	if (hPipeStdOutR != NIL_RTPIPE)
438	rc = rtProcProcessOutput(rc, &hPipeStdOutR, &cbStdOut, &offStdOut, ppszStdOut, hPollSet, 1);
439	if (hPipeStdErrR != NIL_RTPIPE)
440	rc = rtProcProcessOutput(rc, &hPipeStdErrR, &cbStdErr, &offStdErr, ppszStdErr, hPollSet, 2);
441	if (hPipeStdOutR == NIL_RTPIPE && hPipeStdErrR == NIL_RTPIPE)
442	break;
443
444	if (hProc != NIL_RTPROCESS)
445	{
446	rc2 = RTProcWait(hProc, RTPROCWAIT_FLAGS_NOBLOCK, pStatus);
447	if (rc2 != VERR_PROCESS_RUNNING)
448	{
449	if (RT_FAILURE(rc2))
450	rc = rc2;
451	hProc = NIL_RTPROCESS;
452	}
453	}
454
455	rc2 = RTPoll(hPollSet, 10000, NULL, NULL);
456	Assert(RT_SUCCESS(rc2) \|\| rc2 == VERR_TIMEOUT);
457	}
458
459	if (RT_SUCCESS(rc))
460	{
461	if ( (ppszStdOut && ppszStdOut && !RTStrIsValidEncoding(ppszStdOut))
462	\|\| (ppszStdErr && ppszStdErr && !RTStrIsValidEncoding(ppszStdErr)) )
463	rc = VERR_NO_TRANSLATION;
464	}
465
466	/*
467	* No more output, just wait for it to finish.
468	*/
469	if (hProc != NIL_RTPROCESS)
470	{
471	rc2 = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, pStatus);
472	if (RT_FAILURE(rc2))
473	rc = rc2;
474	}
475	}
476	RTPollSetDestroy(hPollSet);
477	}
478	}
479
480	rc2 = RTHandleClose(&hChildStdErr); AssertRC(rc2);
481	rc2 = RTHandleClose(&hChildStdOut); AssertRC(rc2);
482	rc2 = RTHandleClose(&hChildStdIn); AssertRC(rc2);
483	rc2 = RTPipeClose(hPipeStdErrR); AssertRC(rc2);
484	rc2 = RTPipeClose(hPipeStdOutR); AssertRC(rc2);
485	return rc;
486	}
487
488
489	/**
490	* Runs a process, waiting for it to complete.
491	*
492	* @returns IPRT status code
493	*
494	* @param pszExec Executable image to use to create the child process.
495	* @param papszArgs Pointer to an array of arguments to the child. The
496	* array terminated by an entry containing NULL.
497	* @param hEnv Handle to the environment block for the child.
498	* @param fFlags A combination of RTPROCEXEC_FLAGS_XXX.
499	* @param pStatus Where to return the status on success.
500	*/
501	int RTProcExec(const char pszExec, const char const *papszArgs, RTENV hEnv, uint32_t fFlags,
502	PRTPROCSTATUS pStatus)
503	{
504	int rc;
505
506	/*
507	* Clear output argument (no returning failure here, simply crash!).
508	*/
509	AssertPtr(pStatus);
510	pStatus->enmReason = RTPROCEXITREASON_ABEND;
511	pStatus->iStatus = RTEXITCODE_FAILURE;
512
513	/*
514	* Check input arguments.
515	*/
516	AssertReturn(!(fFlags & ~RTPROCEXEC_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
517
518	/*
519	* Set up /dev/null redirections.
520	*/
521	PRTHANDLE aph[3] = { NULL, NULL, NULL };
522	RTHANDLE ah[3];
523	for (uint32_t i = 0; i < 3; i++)
524	{
525	ah[i].enmType = RTHANDLETYPE_FILE;
526	ah[i].u.hFile = NIL_RTFILE;
527	}
528	rc = VINF_SUCCESS;
529	if ((fFlags & RTPROCEXEC_FLAGS_STDIN_NULL) && RT_SUCCESS(rc))
530	{
531	aph[0] = &ah[0];
532	rc = RTFileOpenBitBucket(&ah[0].u.hFile, RTFILE_O_READ);
533	}
534	if ((fFlags & RTPROCEXEC_FLAGS_STDOUT_NULL) && RT_SUCCESS(rc))
535	{
536	aph[1] = &ah[1];
537	rc = RTFileOpenBitBucket(&ah[1].u.hFile, RTFILE_O_WRITE);
538	}
539	if ((fFlags & RTPROCEXEC_FLAGS_STDERR_NULL) && RT_SUCCESS(rc))
540	{
541	aph[2] = &ah[2];
542	rc = RTFileOpenBitBucket(&ah[2].u.hFile, RTFILE_O_WRITE);
543	}
544
545	/*
546	* Create the process.
547	*/
548	RTPROCESS hProc = NIL_RTPROCESS;
549	if (RT_SUCCESS(rc))
550	rc = RTProcCreateEx(pszExec,
551	papszArgs,
552	hEnv,
553	0 /fFlags/,
554	aph[0],
555	aph[1],
556	aph[2],
557	NULL /pszAsUser/,
558	NULL /pszPassword/,
559	NULL /pvExtraData/,
560	&hProc);
561
562	for (uint32_t i = 0; i < 3; i++)
563	RTFileClose(ah[i].u.hFile);
564
565	if (RT_SUCCESS(rc))
566	rc = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, pStatus);
567	return rc;
568	}
569
570
571
572	/**
573	* Executes SVN and gets the output.
574	*
575	* Standard error is suppressed.
576	*
577	* @returns VINF_SUCCESS if the command executed successfully.
578	* @param pState The rewrite state to work on. Can be NULL.
579	* @param papszArgs The SVN argument.
580	* @param fNormalFailureOk Whether normal failure is ok.
581	* @param ppszStdOut Where to return the output on success.
582	*/
583	static int scmSvnRunAndGetOutput(PSCMRWSTATE pState, const char papszArgs, bool fNormalFailureOk, char ppszStdOut)
584	{
585	*ppszStdOut = NULL;
586
587	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
588	scmSvnFlushClientContextAndPool();
589	#endif
590
591	char *pszCmdLine = NULL;
592	int rc = RTGetOptArgvToString(&pszCmdLine, papszArgs, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
593	if (RT_FAILURE(rc))
594	return rc;
595	ScmVerbose(pState, 2, "executing: %s\n", pszCmdLine);
596
597	RTPROCSTATUS Status;
598	rc = RTProcExecToString(g_szSvnPath, papszArgs, RTENV_DEFAULT,
599	RTPROCEXEC_FLAGS_STD_NULL, &Status, ppszStdOut, NULL);
600
601	if ( RT_SUCCESS(rc)
602	&& ( Status.enmReason != RTPROCEXITREASON_NORMAL
603	\|\| Status.iStatus != 0) )
604	{
605	if (fNormalFailureOk \|\| Status.enmReason != RTPROCEXITREASON_NORMAL)
606	RTMsgError("%s: %s -> %s %u\n",
607	pState ? pState->pszFilename : "<NONE>", pszCmdLine,
608	Status.enmReason == RTPROCEXITREASON_NORMAL ? "exit code"
609	: Status.enmReason == RTPROCEXITREASON_SIGNAL ? "signal"
610	: Status.enmReason == RTPROCEXITREASON_ABEND ? "abnormal end"
611	: "abducted by alien",
612	Status.iStatus);
613	rc = VERR_GENERAL_FAILURE;
614	}
615	else if (RT_FAILURE(rc))
616	{
617	if (pState)
618	RTMsgError("%s: executing: %s => %Rrc\n", pState->pszFilename, pszCmdLine, rc);
619	else
620	RTMsgError("executing: %s => %Rrc\n", pszCmdLine, rc);
621	}
622
623	if (RT_FAILURE(rc))
624	{
625	RTStrFree(*ppszStdOut);
626	*ppszStdOut = NULL;
627	}
628	RTStrFree(pszCmdLine);
629	return rc;
630	}
631
632
633	/**
634	* Executes SVN.
635	*
636	* Standard error and standard output is suppressed.
637	*
638	* @returns VINF_SUCCESS if the command executed successfully.
639	* @param pState The rewrite state to work on.
640	* @param papszArgs The SVN argument.
641	* @param fNormalFailureOk Whether normal failure is ok.
642	*/
643	static int scmSvnRun(PSCMRWSTATE pState, const char **papszArgs, bool fNormalFailureOk)
644	{
645	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
646	scmSvnFlushClientContextAndPool();
647	#endif
648
649	char *pszCmdLine = NULL;
650	int rc = RTGetOptArgvToString(&pszCmdLine, papszArgs, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
651	if (RT_FAILURE(rc))
652	return rc;
653	ScmVerbose(pState, 2, "executing: %s\n", pszCmdLine);
654
655	/* Lazy bird uses RTProcExec. */
656	RTPROCSTATUS Status;
657	rc = RTProcExec(g_szSvnPath, papszArgs, RTENV_DEFAULT, RTPROCEXEC_FLAGS_STD_NULL, &Status);
658
659	if ( RT_SUCCESS(rc)
660	&& ( Status.enmReason != RTPROCEXITREASON_NORMAL
661	\|\| Status.iStatus != 0) )
662	{
663	if (fNormalFailureOk \|\| Status.enmReason != RTPROCEXITREASON_NORMAL)
664	RTMsgError("%s: %s -> %s %u\n",
665	pState->pszFilename,
666	pszCmdLine,
667	Status.enmReason == RTPROCEXITREASON_NORMAL ? "exit code"
668	: Status.enmReason == RTPROCEXITREASON_SIGNAL ? "signal"
669	: Status.enmReason == RTPROCEXITREASON_ABEND ? "abnormal end"
670	: "abducted by alien",
671	Status.iStatus);
672	rc = VERR_GENERAL_FAILURE;
673	}
674	else if (RT_FAILURE(rc))
675	RTMsgError("%s: %s -> %Rrc\n", pState->pszFilename, pszCmdLine, rc);
676
677	RTStrFree(pszCmdLine);
678	return rc;
679	}
680
681
682	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
683	/**
684	* Attempts to resolve the necessary subversion and apache portable runtime APIs
685	* we require dynamically.
686	*
687	* Will set all global function pointers and g_fSvnFunctionPointersValid to true
688	* on success.
689	*/
690	static void scmSvnTryResolveFunctions(void)
691	{
692	char szPath[RTPATH_MAX];
693	int rc = RTStrCopy(szPath, sizeof(szPath), g_szSvnPath);
694	if (RT_SUCCESS(rc))
695	{
696	RTPathStripFilename(szPath);
697	char *pszEndPath = strchr(szPath, '\0');
698	# ifdef RT_OS_WINDOWS
699	RTPathChangeToDosSlashes(szPath, false);
700	# endif
701
702	/*
703	* Try various prefixes/suffxies/locations.
704	*/
705	static struct
706	{
707	const char *pszPrefix;
708	const char *pszSuffix;
709	} const s_aVariations[] =
710	{
711	# ifdef RT_OS_WINDOWS
712	{ "SlikSvn-lib", "-1.dll" }, /* SlikSVN */
713	{ "lib", "-1.dll" }, /* Win32Svn,CollabNet,++ */
714	# elif defined(RT_OS_DARWIN)
715	{ "../lib/lib", "-1.dylib" },
716	# else
717	{ "../lib/lib", ".so" },
718	{ "../lib/lib", "-1.so" },
719	# ifdef RT_ARCH_X86
720	{ "../lib/i386-linux-gnu/lib", ".so" },
721	{ "../lib/i386-linux-gnu/lib", "-1.so" },
722	# else
723	{ "../lib/x86_64-linux-gnu/lib", ".so" },
724	{ "../lib/x86_64-linux-gnu/lib", "-1.so" },
725	# endif
726	# endif
727	};
728	for (unsigned iVar = 0; iVar < RT_ELEMENTS(s_aVariations); iVar++)
729	{
730	/*
731	* Try load the svn_client library ...
732	*/
733	static const char * const s_apszLibraries[] = { "svn_client", "svn_subr", "apr" };
734	RTLDRMOD ahMods[RT_ELEMENTS(s_apszLibraries)] = { NIL_RTLDRMOD, NIL_RTLDRMOD, NIL_RTLDRMOD };
735
736	rc = VINF_SUCCESS;
737	unsigned iLib;
738	for (iLib = 0; iLib < RT_ELEMENTS(s_apszLibraries) && RT_SUCCESS(rc); iLib++)
739	{
740	static const char * const s_apszSuffixes[] = { "", ".0", ".1" };
741	for (unsigned iSuff = 0; iSuff < RT_ELEMENTS(s_apszSuffixes); iSuff++)
742	{
743	*pszEndPath = '\0';
744	rc = RTPathAppend(szPath, sizeof(szPath), s_aVariations[iVar].pszPrefix);
745	if (RT_SUCCESS(rc))
746	rc = RTStrCat(szPath, sizeof(szPath), s_apszLibraries[iLib]);
747	if (RT_SUCCESS(rc))
748	rc = RTStrCat(szPath, sizeof(szPath), s_aVariations[iVar].pszSuffix);
749	if (RT_SUCCESS(rc))
750	rc = RTStrCat(szPath, sizeof(szPath), s_apszSuffixes[iSuff]);
751	if (RT_SUCCESS(rc))
752	{
753	# ifdef RT_OS_WINDOWS
754	RTPathChangeToDosSlashes(pszEndPath, false);
755	# endif
756	rc = RTLdrLoadEx(szPath, &ahMods[iLib], RTLDRLOAD_FLAGS_NT_SEARCH_DLL_LOAD_DIR , NULL);
757	if (RT_SUCCESS(rc))
758	{
759	RTMEM_WILL_LEAK(ahMods[iLib]);
760	break;
761	}
762	}
763	}
764	}
765	if (iLib == RT_ELEMENTS(s_apszLibraries) && RT_SUCCESS(rc))
766	{
767	static const struct
768	{
769	unsigned iLib;
770	const char *pszSymbol;
771	PFNRT *ppfn;
772	} s_aSymbols[] =
773	{
774	{ 2, "apr_initialize", (PFNRT *)&g_pfnAprInitialize },
775	{ 2, "apr_hash_first", (PFNRT *)&g_pfnAprHashFirst },
776	{ 2, "apr_hash_next", (PFNRT *)&g_pfnAprHashNext },
777	{ 2, "apr_hash_this_val", (PFNRT *)&g_pfnAprHashThisVal },
778	{ 1, "svn_pool_create_ex", (PFNRT *)&g_pfnSvnPoolCreateEx },
779	{ 2, "apr_pool_clear", (PFNRT *)&g_pfnAprPoolClear },
780	{ 2, "apr_pool_destroy", (PFNRT *)&g_pfnAprPoolDestroy },
781	{ 0, "svn_client_create_context", (PFNRT *)&g_pfnSvnClientCreateContext },
782	{ 0, "svn_client_propget4", (PFNRT *)&g_pfnSvnClientPropGet4 },
783	};
784	for (unsigned i = 0; i < RT_ELEMENTS(s_aSymbols); i++)
785	{
786	rc = RTLdrGetSymbol(ahMods[s_aSymbols[i].iLib], s_aSymbols[i].pszSymbol,
787	(void **)(uintptr_t)s_aSymbols[i].ppfn);
788	if (RT_FAILURE(rc))
789	{
790	ScmVerbose(NULL, 0, "Failed to resolve '%s' in '%s'",
791	s_aSymbols[i].pszSymbol, s_apszLibraries[s_aSymbols[i].iLib]);
792	break;
793	}
794	}
795	if (RT_SUCCESS(rc))
796	{
797	apr_status_t rcApr = g_pfnAprInitialize();
798	if (rcApr == 0)
799	{
800	ScmVerbose(NULL, 1, "Found subversion APIs.\n");
801	g_fSvnFunctionPointersValid = true;
802	}
803	else
804	{
805	ScmVerbose(NULL, 0, "apr_initialize failed: %#x (%d)\n", rcApr, rcApr);
806	AssertMsgFailed(("%#x (%d)\n", rc, rc));
807	}
808	return;
809	}
810	}
811
812	while (iLib-- > 0)
813	RTLdrClose(ahMods[iLib]);
814	}
815	}
816	}
817	#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
818
819
820	/**
821	* Finds the svn binary, updating g_szSvnPath and g_enmSvnVersion.
822	*/
823	static void scmSvnFindSvnBinary(PSCMRWSTATE pState)
824	{
825	/* Already been called? */
826	if (g_szSvnPath[0] != '\0')
827	return;
828
829	/*
830	* Locate it.
831	*/
832	/** @todo code page fun... */
833	#ifdef RT_OS_WINDOWS
834	const char *pszEnvVar = RTEnvGet("Path");
835	#else
836	const char *pszEnvVar = RTEnvGet("PATH");
837	#endif
838	if (pszEnvVar)
839	{
840	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
841	int rc = RTPathTraverseList(pszEnvVar, ';', scmSvnFindSvnBinaryCallback, g_szSvnPath, (void *)sizeof(g_szSvnPath));
842	#else
843	int rc = RTPathTraverseList(pszEnvVar, ':', scmSvnFindSvnBinaryCallback, g_szSvnPath, (void *)sizeof(g_szSvnPath));
844	#endif
845	if (RT_FAILURE(rc))
846	strcpy(g_szSvnPath, "svn");
847	}
848	else
849	strcpy(g_szSvnPath, "svn");
850
851	/*
852	* Check the version.
853	*/
854	const char *apszArgs[] = { g_szSvnPath, "--version", "--quiet", NULL };
855	char *pszVersion;
856	int rc = scmSvnRunAndGetOutput(pState, apszArgs, false, &pszVersion);
857	if (RT_SUCCESS(rc))
858	{
859	char *pszStripped = RTStrStrip(pszVersion);
860	if (RTStrVersionCompare(pszStripped, "1.8") >= 0)
861	g_enmSvnVersion = kScmSvnVersion_1_8;
862	else if (RTStrVersionCompare(pszStripped, "1.7") >= 0)
863	g_enmSvnVersion = kScmSvnVersion_1_7;
864	else if (RTStrVersionCompare(pszStripped, "1.6") >= 0)
865	g_enmSvnVersion = kScmSvnVersion_1_6;
866	else
867	g_enmSvnVersion = kScmSvnVersion_Ancient;
868	RTStrFree(pszVersion);
869	}
870	else
871	g_enmSvnVersion = kScmSvnVersion_Ancient;
872
873	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
874	/*
875	* If we got version 1.8 or later, try see if we can locate a few of the
876	* simpler SVN APIs.
877	*/
878	g_fSvnFunctionPointersValid = false;
879	if (g_enmSvnVersion >= kScmSvnVersion_1_8)
880	scmSvnTryResolveFunctions();
881	#endif
882	}
883
884
885	/**
886	* Construct a dot svn filename for the file being rewritten.
887	*
888	* @returns IPRT status code.
889	* @param pState The rewrite state (for the name).
890	* @param pszDir The directory, including ".svn/".
891	* @param pszSuff The filename suffix.
892	* @param pszDst The output buffer. RTPATH_MAX in size.
893	*/
894	static int scmSvnConstructName(PSCMRWSTATE pState, const char pszDir, const char pszSuff, char *pszDst)
895	{
896	strcpy(pszDst, pState->pszFilename); /* ASSUMES sizeof(szBuf) <= sizeof(szPath) */
897	RTPathStripFilename(pszDst);
898
899	int rc = RTPathAppend(pszDst, RTPATH_MAX, pszDir);
900	if (RT_SUCCESS(rc))
901	{
902	rc = RTPathAppend(pszDst, RTPATH_MAX, RTPathFilename(pState->pszFilename));
903	if (RT_SUCCESS(rc))
904	{
905	size_t cchDst = strlen(pszDst);
906	size_t cchSuff = strlen(pszSuff);
907	if (cchDst + cchSuff < RTPATH_MAX)
908	{
909	memcpy(&pszDst[cchDst], pszSuff, cchSuff + 1);
910	return VINF_SUCCESS;
911	}
912	else
913	rc = VERR_BUFFER_OVERFLOW;
914	}
915	}
916	return rc;
917	}
918
919	/**
920	* Interprets the specified string as decimal numbers.
921	*
922	* @returns true if parsed successfully, false if not.
923	* @param pch The string (not terminated).
924	* @param cch The string length.
925	* @param pu Where to return the value.
926	*/
927	static bool scmSvnReadNumber(const char pch, size_t cch, size_t pu)
928	{
929	size_t u = 0;
930	while (cch-- > 0)
931	{
932	char ch = *pch++;
933	if (ch < '0' \|\| ch > '9')
934	return false;
935	u *= 10;
936	u += ch - '0';
937	}
938	*pu = u;
939	return true;
940	}
941
942
943	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
944
945	/**
946	* Wrapper around RTPathAbs.
947	* @returns Same as RTPathAbs.
948	* @param pszPath The relative path.
949	* @param pszAbsPath Where to return the absolute path.
950	* @param cbAbsPath Size of the @a pszAbsPath buffer.
951	*/
952	static int scmSvnAbsPath(const char pszPath, char pszAbsPath, size_t cbAbsPath)
953	{
954	int rc = RTPathAbs(pszPath, pszAbsPath, cbAbsPath);
955	# if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS
956	if (RT_SUCCESS(rc))
957	{
958	RTPathChangeToUnixSlashes(pszAbsPath, true /fForce/);
959	/* To avoid: svn: E235000: In file '..\..\..\subversion\libsvn_client\prop_commands.c' line 796: assertion failed (svn_dirent_is_absolute(target)) */
960	if (pszAbsPath[1] == ':')
961	pszAbsPath[0] = RT_C_TO_UPPER(pszAbsPath[0]);
962	}
963	# endif
964	return rc;
965	}
966
967
968	/**
969	* Gets a client context and pool.
970	*
971	* This implements caching.
972	*
973	* @returns IPRT status code.
974	* @param ppCtx Where to return the context
975	* @param ppPool Where to return the pool.
976	*/
977	static int scmSvnGetClientContextAndPool(svn_client_ctx_t ppCtx, apr_pool_t ppPool)
978	{
979	/*
980	* Use cached if present.
981	*/
982	if (g_pSvnClientCtx && g_pSvnPool)
983	{
984	g_cSvnClientCtxUsed++;
985	*ppCtx = g_pSvnClientCtx;
986	*ppPool = g_pSvnPool;
987	return VINF_SUCCESS;
988	}
989	Assert(!g_pSvnClientCtx);
990	Assert(!g_pSvnPool);
991
992	/*
993	* Create new pool and context.
994	*/
995	apr_pool_t *pPool = g_pfnSvnPoolCreateEx(NULL, NULL);
996	if (pPool)
997	{
998	svn_client_ctx_t *pCtx = NULL;
999	svn_error_t *pErr = g_pfnSvnClientCreateContext(&pCtx, pPool);
1000	if (!pErr)
1001	{
1002	g_cSvnClientCtxUsed = 1;
1003	g_pSvnClientCtx = *ppCtx = pCtx;
1004	g_pSvnPool = *ppPool = pPool;
1005	return VINF_SUCCESS;
1006	}
1007	g_pfnAprPoolDestroy(pPool);
1008	}
1009
1010	*ppCtx = NULL;
1011	*ppPool = NULL;
1012	return VERR_GENERAL_FAILURE;
1013	}
1014
1015
1016	/**
1017	* Puts back a client context and pool after use.
1018	*
1019	* @param pCtx The context.
1020	* @param pPool The pool.
1021	* @param fFlush Whether to flush it.
1022	*/
1023	static void scmSvnPutClientContextAndPool(svn_client_ctx_t pCtx, apr_pool_t pPool, bool fFlush)
1024	{
1025	if (fFlush \|\| g_cSvnClientCtxUsed > 4096) /* Disable this to force new context every time. */
1026	{
1027	g_pfnAprPoolDestroy(pPool);
1028	g_pSvnPool = NULL;
1029	g_pSvnClientCtx = NULL;
1030	}
1031	RT_NOREF(pCtx, fFlush);
1032	}
1033
1034
1035	/**
1036	* Flushes the cached client context and pool
1037	*/
1038	static void scmSvnFlushClientContextAndPool(void)
1039	{
1040	if (g_pSvnPool)
1041	scmSvnPutClientContextAndPool(g_pSvnClientCtx, g_pSvnPool, true /fFlush/);
1042	Assert(!g_pSvnPool);
1043	}
1044
1045
1046	/**
1047	* Checks if @a pszPath exists in the current WC.
1048	*
1049	* @returns true, false or -1. In the latter case, please use the fallback.
1050	* @param pszPath Path to the object that should be investigated.
1051	*/
1052	static int scmSvnIsObjectInWorkingCopy(const char *pszPath)
1053	{
1054	/* svn_client_propget4 and later requires absolute target path. */
1055	char szAbsPath[RTPATH_MAX];
1056	int rc = scmSvnAbsPath(pszPath, szAbsPath, sizeof(szAbsPath));
1057	if (RT_SUCCESS(rc))
1058	{
1059	apr_pool_t *pPool;
1060	svn_client_ctx_t *pCtx = NULL;
1061	rc = scmSvnGetClientContextAndPool(&pCtx, &pPool);
1062	if (RT_SUCCESS(rc))
1063	{
1064	/* Make the call. */
1065	apr_hash_t *pHash = NULL;
1066	svn_opt_revision_t Rev;
1067	RT_ZERO(Rev);
1068	Rev.kind = svn_opt_revision_working;
1069	Rev.value.number = -1L;
1070	svn_error_t *pErr = g_pfnSvnClientPropGet4(&pHash, "svn:no-such-property", szAbsPath, &Rev, &Rev,
1071	NULL /pActualRev/, svn_depth_empty, NULL /pChangeList/,
1072	pCtx, pPool, pPool);
1073	if (!pErr)
1074	rc = true;
1075	else if (pErr->apr_err == SVN_ERR_UNVERSIONED_RESOURCE)
1076	rc = false;
1077
1078	scmSvnPutClientContextAndPool(pCtx, pPool, false);
1079	}
1080	}
1081	return rc;
1082	}
1083
1084	#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
1085
1086
1087	/**
1088	* Checks if the file we're operating on is part of a SVN working copy.
1089	*
1090	* @returns true if it is, false if it isn't or we cannot tell.
1091	* @param pState The rewrite state to work on. Will use the
1092	* fIsInSvnWorkingCopy member for caching the result.
1093	*/
1094	bool ScmSvnIsInWorkingCopy(PSCMRWSTATE pState)
1095	{
1096	/*
1097	* We don't ask SVN twice as that's expensive.
1098	*/
1099	if (pState->fIsInSvnWorkingCopy != 0)
1100	return pState->fIsInSvnWorkingCopy > 0;
1101
1102	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1103	if (g_fSvnFunctionPointersValid)
1104	{
1105	int rc = scmSvnIsObjectInWorkingCopy(pState->pszFilename);
1106	if (rc == (int)true \|\| rc == (int)false)
1107	{
1108	pState->fIsInSvnWorkingCopy = rc == (int)true ? 1 : -1;
1109	return rc == (int)true;
1110	}
1111	}
1112
1113	/* Fallback: */
1114	#endif
1115	if (g_enmSvnVersion < kScmSvnVersion_1_7)
1116	{
1117	/*
1118	* Hack: check if the .svn/text-base/<file>.svn-base file exists.
1119	*/
1120	char szPath[RTPATH_MAX];
1121	int rc = scmSvnConstructName(pState, ".svn/text-base/", ".svn-base", szPath);
1122	if (RT_SUCCESS(rc))
1123	{
1124	if (RTFileExists(szPath))
1125	{
1126	pState->fIsInSvnWorkingCopy = 1;
1127	return true;
1128	}
1129	}
1130	}
1131	else
1132	{
1133	const char *apszArgs[] = { g_szSvnPath, "propget", "svn:no-such-property", pState->pszFilename, NULL };
1134	char *pszValue;
1135	int rc = scmSvnRunAndGetOutput(pState, apszArgs, true, &pszValue);
1136	if (RT_SUCCESS(rc))
1137	{
1138	RTStrFree(pszValue);
1139	pState->fIsInSvnWorkingCopy = 1;
1140	return true;
1141	}
1142	}
1143	pState->fIsInSvnWorkingCopy = -1;
1144	return false;
1145	}
1146
1147
1148	/**
1149	* Checks if the specified directory is part of a SVN working copy.
1150	*
1151	* @returns true if it is, false if it isn't or we cannot tell.
1152	* @param pszDir The directory in question.
1153	*/
1154	bool ScmSvnIsDirInWorkingCopy(const char *pszDir)
1155	{
1156	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1157	if (g_fSvnFunctionPointersValid)
1158	{
1159	int rc = scmSvnIsObjectInWorkingCopy(pszDir);
1160	if (rc == (int)true \|\| rc == (int)false)
1161	return rc == (int)true;
1162	}
1163
1164	/* Fallback: */
1165	#endif
1166	if (g_enmSvnVersion < kScmSvnVersion_1_7)
1167	{
1168	/*
1169	* Hack: check if the .svn/ dir exists.
1170	*/
1171	char szPath[RTPATH_MAX];
1172	int rc = RTPathJoin(szPath, sizeof(szPath), pszDir, ".svn");
1173	if (RT_SUCCESS(rc))
1174	return RTDirExists(szPath);
1175	}
1176	else
1177	{
1178	const char *apszArgs[] = { g_szSvnPath, "propget", "svn:no-such-property", pszDir, NULL };
1179	char *pszValue;
1180	int rc = scmSvnRunAndGetOutput(NULL, apszArgs, true, &pszValue);
1181	if (RT_SUCCESS(rc))
1182	{
1183	RTStrFree(pszValue);
1184	return true;
1185	}
1186	}
1187	return false;
1188	}
1189
1190
1191	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1192	/**
1193	* Checks if @a pszPath exists in the current WC.
1194	*
1195	* @returns IPRT status code - VERR_NOT_SUPPORT if fallback should be attempted.
1196	* @param pszPath Path to the object that should be investigated.
1197	* @param pszProperty The property name.
1198	* @param ppszValue Where to return the property value. Optional.
1199	*/
1200	static int scmSvnQueryPropertyUsingApi(const char pszPath, const char pszProperty, char **ppszValue)
1201	{
1202	/* svn_client_propget4 and later requires absolute target path. */
1203	char szAbsPath[RTPATH_MAX];
1204	int rc = scmSvnAbsPath(pszPath, szAbsPath, sizeof(szAbsPath));
1205	if (RT_SUCCESS(rc))
1206	{
1207	apr_pool_t *pPool;
1208	svn_client_ctx_t *pCtx = NULL;
1209	rc = scmSvnGetClientContextAndPool(&pCtx, &pPool);
1210	if (RT_SUCCESS(rc))
1211	{
1212	/* Make the call. */
1213	apr_hash_t *pHash = NULL;
1214	svn_opt_revision_t Rev;
1215	RT_ZERO(Rev);
1216	Rev.kind = svn_opt_revision_working;
1217	Rev.value.number = -1L;
1218	svn_error_t *pErr = g_pfnSvnClientPropGet4(&pHash, pszProperty, szAbsPath, &Rev, &Rev,
1219	NULL /pActualRev/, svn_depth_empty, NULL /pChangeList/,
1220	pCtx, pPool, pPool);
1221	if (!pErr)
1222	{
1223	/* Get the first value, if any. */
1224	rc = VERR_NOT_FOUND;
1225	apr_hash_index_t *pHashIdx = g_pfnAprHashFirst(pPool, pHash);
1226	if (pHashIdx)
1227	{
1228	const char ppszFirst = (const char )g_pfnAprHashThisVal(pHashIdx);
1229	if (ppszFirst && *ppszFirst)
1230	{
1231	if (ppszValue)
1232	rc = RTStrDupEx(ppszValue, *ppszFirst);
1233	else
1234	rc = VINF_SUCCESS;
1235	}
1236	}
1237	}
1238	else if (pErr->apr_err == SVN_ERR_UNVERSIONED_RESOURCE)
1239	rc = VERR_INVALID_STATE;
1240	else
1241	rc = VERR_GENERAL_FAILURE;
1242
1243	scmSvnPutClientContextAndPool(pCtx, pPool, false);
1244	}
1245	}
1246	return rc;
1247	}
1248	#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
1249
1250
1251	/**
1252	* Queries the value of an SVN property.
1253	*
1254	* This will automatically adjust for scheduled changes.
1255	*
1256	* @returns IPRT status code.
1257	* @retval VERR_INVALID_STATE if not a SVN WC file.
1258	* @retval VERR_NOT_FOUND if the property wasn't found.
1259	* @param pState The rewrite state to work on.
1260	* @param pszName The property name.
1261	* @param ppszValue Where to return the property value. Free this
1262	* using RTStrFree. Optional.
1263	*/
1264	int ScmSvnQueryProperty(PSCMRWSTATE pState, const char pszName, char *ppszValue)
1265	{
1266	int rc;
1267
1268	/*
1269	* Look it up in the scheduled changes.
1270	*/
1271	size_t i = pState->cSvnPropChanges;
1272	while (i-- > 0)
1273	if (!strcmp(pState->paSvnPropChanges[i].pszName, pszName))
1274	{
1275	const char *pszValue = pState->paSvnPropChanges[i].pszValue;
1276	if (!pszValue)
1277	return VERR_NOT_FOUND;
1278	if (ppszValue)
1279	return RTStrDupEx(ppszValue, pszValue);
1280	return VINF_SUCCESS;
1281	}
1282
1283	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1284	if (g_fSvnFunctionPointersValid)
1285	{
1286	rc = scmSvnQueryPropertyUsingApi(pState->pszFilename, pszName, ppszValue);
1287	if (rc != VERR_NOT_SUPPORTED)
1288	return rc;
1289	/* Fallback: */
1290	}
1291	#endif
1292
1293	if (g_enmSvnVersion < kScmSvnVersion_1_7)
1294	{
1295	/*
1296	* Hack: Read the .svn/props/<file>.svn-work file exists.
1297	*/
1298	char szPath[RTPATH_MAX];
1299	rc = scmSvnConstructName(pState, ".svn/props/", ".svn-work", szPath);
1300	if (RT_SUCCESS(rc) && !RTFileExists(szPath))
1301	rc = scmSvnConstructName(pState, ".svn/prop-base/", ".svn-base", szPath);
1302	if (RT_SUCCESS(rc))
1303	{
1304	SCMSTREAM Stream;
1305	rc = ScmStreamInitForReading(&Stream, szPath);
1306	if (RT_SUCCESS(rc))
1307	{
1308	/*
1309	* The current format is K len\n<name>\nV len\n<value>\n" ... END.
1310	*/
1311	rc = VERR_NOT_FOUND;
1312	size_t const cchName = strlen(pszName);
1313	SCMEOL enmEol;
1314	size_t cchLine;
1315	const char *pchLine;
1316	while ((pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol)) != NULL)
1317	{
1318	/*
1319	* Parse the 'K num' / 'END' line.
1320	*/
1321	if ( cchLine == 3
1322	&& !memcmp(pchLine, "END", 3))
1323	break;
1324	size_t cchKey;
1325	if ( cchLine < 3
1326	\|\| pchLine[0] != 'K'
1327	\|\| pchLine[1] != ' '
1328	\|\| !scmSvnReadNumber(&pchLine[2], cchLine - 2, &cchKey)
1329	\|\| cchKey == 0
1330	\|\| cchKey > 4096)
1331	{
1332	RTMsgError("%s:%u: Unexpected data '%.*s'\n", szPath, ScmStreamTellLine(&Stream), cchLine, pchLine);
1333	rc = VERR_PARSE_ERROR;
1334	break;
1335	}
1336
1337	/*
1338	* Match the key and skip to the value line. Don't bother with
1339	* names containing EOL markers.
1340	*/
1341	size_t const offKey = ScmStreamTell(&Stream);
1342	bool fMatch = cchName == cchKey;
1343	if (fMatch)
1344	{
1345	pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol);
1346	if (!pchLine)
1347	break;
1348	fMatch = cchLine == cchName
1349	&& !memcmp(pchLine, pszName, cchName);
1350	}
1351
1352	if (RT_FAILURE(ScmStreamSeekAbsolute(&Stream, offKey + cchKey)))
1353	break;
1354	if (RT_FAILURE(ScmStreamSeekByLine(&Stream, ScmStreamTellLine(&Stream) + 1)))
1355	break;
1356
1357	/*
1358	* Read and Parse the 'V num' line.
1359	*/
1360	pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol);
1361	if (!pchLine)
1362	break;
1363	size_t cchValue;
1364	if ( cchLine < 3
1365	\|\| pchLine[0] != 'V'
1366	\|\| pchLine[1] != ' '
1367	\|\| !scmSvnReadNumber(&pchLine[2], cchLine - 2, &cchValue)
1368	\|\| cchValue > _1M)
1369	{
1370	RTMsgError("%s:%u: Unexpected data '%.*s'\n", szPath, ScmStreamTellLine(&Stream), cchLine, pchLine);
1371	rc = VERR_PARSE_ERROR;
1372	break;
1373	}
1374
1375	/*
1376	* If we have a match, allocate a return buffer and read the
1377	* value into it. Otherwise skip this value and continue
1378	* searching.
1379	*/
1380	if (fMatch)
1381	{
1382	if (!ppszValue)
1383	rc = VINF_SUCCESS;
1384	else
1385	{
1386	char *pszValue;
1387	rc = RTStrAllocEx(&pszValue, cchValue + 1);
1388	if (RT_SUCCESS(rc))
1389	{
1390	rc = ScmStreamRead(&Stream, pszValue, cchValue);
1391	if (RT_SUCCESS(rc))
1392	*ppszValue = pszValue;
1393	else
1394	RTStrFree(pszValue);
1395	}
1396	}
1397	break;
1398	}
1399
1400	if (RT_FAILURE(ScmStreamSeekRelative(&Stream, cchValue)))
1401	break;
1402	if (RT_FAILURE(ScmStreamSeekByLine(&Stream, ScmStreamTellLine(&Stream) + 1)))
1403	break;
1404	}
1405
1406	if (RT_FAILURE(ScmStreamGetStatus(&Stream)))
1407	{
1408	rc = ScmStreamGetStatus(&Stream);
1409	RTMsgError("%s: stream error %Rrc\n", szPath, rc);
1410	}
1411	ScmStreamDelete(&Stream);
1412	}
1413	}
1414
1415	if (rc == VERR_FILE_NOT_FOUND)
1416	rc = VERR_NOT_FOUND;
1417	}
1418	else
1419	{
1420	const char *apszArgs[] = { g_szSvnPath, "propget", "--strict", pszName, pState->pszFilename, NULL };
1421	char *pszValue;
1422	rc = scmSvnRunAndGetOutput(pState, apszArgs, false, &pszValue);
1423	if (RT_SUCCESS(rc))
1424	{
1425	if (pszValue && *pszValue)
1426	{
1427	if (ppszValue)
1428	{
1429	*ppszValue = pszValue;
1430	pszValue = NULL;
1431	}
1432	}
1433	else
1434	rc = VERR_NOT_FOUND;
1435	RTStrFree(pszValue);
1436	}
1437	}
1438	return rc;
1439	}
1440
1441
1442	/**
1443	* Queries the value of an SVN property on the parent dir/whatever.
1444	*
1445	* This will not adjust for scheduled changes to the parent!
1446	*
1447	* @returns IPRT status code.
1448	* @retval VERR_INVALID_STATE if not a SVN WC file.
1449	* @retval VERR_NOT_FOUND if the property wasn't found.
1450	* @param pState The rewrite state to work on.
1451	* @param pszName The property name.
1452	* @param ppszValue Where to return the property value. Free this
1453	* using RTStrFree. Optional.
1454	*/
1455	int ScmSvnQueryParentProperty(PSCMRWSTATE pState, const char pszName, char *ppszValue)
1456	{
1457	/*
1458	* Strip the filename and use ScmSvnQueryProperty.
1459	*/
1460	char szPath[RTPATH_MAX];
1461	int rc = RTStrCopy(szPath, sizeof(szPath), pState->pszFilename);
1462	if (RT_SUCCESS(rc))
1463	{
1464	RTPathStripFilename(szPath);
1465	SCMRWSTATE ParentState;
1466	ParentState.pszFilename = szPath;
1467	ParentState.fFirst = false;
1468	ParentState.fIsInSvnWorkingCopy = true;
1469	ParentState.cSvnPropChanges = 0;
1470	ParentState.paSvnPropChanges = NULL;
1471	ParentState.rc = VINF_SUCCESS;
1472	rc = ScmSvnQueryProperty(&ParentState, pszName, ppszValue);
1473	if (RT_SUCCESS(rc))
1474	rc = ParentState.rc;
1475	}
1476	return rc;
1477	}
1478
1479
1480	/**
1481	* Schedules the setting of a property.
1482	*
1483	* @returns IPRT status code.
1484	* @retval VERR_INVALID_STATE if not a SVN WC file.
1485	* @param pState The rewrite state to work on.
1486	* @param pszName The name of the property to set.
1487	* @param pszValue The value. NULL means deleting it.
1488	*/
1489	int ScmSvnSetProperty(PSCMRWSTATE pState, const char pszName, const char pszValue)
1490	{
1491	/*
1492	* Update any existing entry first.
1493	*/
1494	size_t i = pState->cSvnPropChanges;
1495	while (i-- > 0)
1496	if (!strcmp(pState->paSvnPropChanges[i].pszName, pszName))
1497	{
1498	if (!pszValue)
1499	{
1500	RTStrFree(pState->paSvnPropChanges[i].pszValue);
1501	pState->paSvnPropChanges[i].pszValue = NULL;
1502	}
1503	else
1504	{
1505	char *pszCopy;
1506	int rc = RTStrDupEx(&pszCopy, pszValue);
1507	if (RT_FAILURE(rc))
1508	return rc;
1509	pState->paSvnPropChanges[i].pszValue = pszCopy;
1510	}
1511	return VINF_SUCCESS;
1512	}
1513
1514	/*
1515	* Insert a new entry.
1516	*/
1517	i = pState->cSvnPropChanges;
1518	if ((i % 32) == 0)
1519	{
1520	void pvNew = RTMemRealloc(pState->paSvnPropChanges, (i + 32) sizeof(SCMSVNPROP));
1521	if (!pvNew)
1522	return VERR_NO_MEMORY;
1523	pState->paSvnPropChanges = (PSCMSVNPROP)pvNew;
1524	}
1525
1526	pState->paSvnPropChanges[i].pszName = RTStrDup(pszName);
1527	pState->paSvnPropChanges[i].pszValue = pszValue ? RTStrDup(pszValue) : NULL;
1528	if ( pState->paSvnPropChanges[i].pszName
1529	&& (pState->paSvnPropChanges[i].pszValue \|\| !pszValue) )
1530	pState->cSvnPropChanges = i + 1;
1531	else
1532	{
1533	RTStrFree(pState->paSvnPropChanges[i].pszName);
1534	pState->paSvnPropChanges[i].pszName = NULL;
1535	RTStrFree(pState->paSvnPropChanges[i].pszValue);
1536	pState->paSvnPropChanges[i].pszValue = NULL;
1537	return VERR_NO_MEMORY;
1538	}
1539	return VINF_SUCCESS;
1540	}
1541
1542
1543	/**
1544	* Schedules a property deletion.
1545	*
1546	* @returns IPRT status code.
1547	* @param pState The rewrite state to work on.
1548	* @param pszName The name of the property to delete.
1549	*/
1550	int ScmSvnDelProperty(PSCMRWSTATE pState, const char *pszName)
1551	{
1552	return ScmSvnSetProperty(pState, pszName, NULL);
1553	}
1554
1555
1556	/**
1557	* Applies any SVN property changes to the work copy of the file.
1558	*
1559	* @returns IPRT status code.
1560	* @param pState The rewrite state which SVN property changes
1561	* should be applied.
1562	*/
1563	int ScmSvnDisplayChanges(PSCMRWSTATE pState)
1564	{
1565	size_t i = pState->cSvnPropChanges;
1566	while (i-- > 0)
1567	{
1568	const char *pszName = pState->paSvnPropChanges[i].pszName;
1569	const char *pszValue = pState->paSvnPropChanges[i].pszValue;
1570	if (pszValue)
1571	ScmVerbose(pState, 0, "svn propset '%s' '%s' %s\n", pszName, pszValue, pState->pszFilename);
1572	else
1573	ScmVerbose(pState, 0, "svn propdel '%s' %s\n", pszName, pState->pszFilename);
1574	}
1575
1576	return VINF_SUCCESS;
1577	}
1578
1579	/**
1580	* Applies any SVN property changes to the work copy of the file.
1581	*
1582	* @returns IPRT status code.
1583	* @param pState The rewrite state which SVN property changes
1584	* should be applied.
1585	*/
1586	int ScmSvnApplyChanges(PSCMRWSTATE pState)
1587	{
1588	#ifdef SCM_WITH_LATER
1589	if (0)
1590	{
1591	return ...;
1592	}
1593
1594	/* Fallback: */
1595	#endif
1596
1597	/*
1598	* Iterate thru the changes and apply them by starting the svn client.
1599	*/
1600	for (size_t i = 0; i < pState->cSvnPropChanges; i++)
1601	{
1602	const char *apszArgv[6];
1603	apszArgv[0] = g_szSvnPath;
1604	apszArgv[1] = pState->paSvnPropChanges[i].pszValue ? "propset" : "propdel";
1605	apszArgv[2] = pState->paSvnPropChanges[i].pszName;
1606	int iArg = 3;
1607	if (pState->paSvnPropChanges[i].pszValue)
1608	apszArgv[iArg++] = pState->paSvnPropChanges[i].pszValue;
1609	apszArgv[iArg++] = pState->pszFilename;
1610	apszArgv[iArg++] = NULL;
1611
1612	int rc = scmSvnRun(pState, apszArgv, false);
1613	if (RT_FAILURE(rc))
1614	return rc;
1615	}
1616
1617	return VINF_SUCCESS;
1618	}
1619
1620
1621	/**
1622	* Initializes the subversion interface.
1623	*/
1624	void ScmSvnInit(void)
1625	{
1626	scmSvnFindSvnBinary(NULL);
1627	}
1628
1629
1630	void ScmSvnTerm(void)
1631	{
1632	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1633	scmSvnFlushClientContextAndPool();
1634	#endif
1635	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/bldprogs/scmsubversion.cpp@ 80569

Download in other formats: