scmsubversion.cpp@ 76565

Last change on this file since 76565 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 55.8 KB

Line
1	/* $Id: scmsubversion.cpp 76553 2019-01-01 01:45:53Z 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	&hProc);
422	rc2 = RTHandleClose(&hChildStdErr); AssertRC(rc2);
423	rc2 = RTHandleClose(&hChildStdOut); AssertRC(rc2);
424
425	if (RT_SUCCESS(rc))
426	{
427	/*
428	* Process output and wait for the process to finish.
429	*/
430	size_t cbStdOut = 0;
431	size_t offStdOut = 0;
432	size_t cbStdErr = 0;
433	size_t offStdErr = 0;
434	for (;;)
435	{
436	if (hPipeStdOutR != NIL_RTPIPE)
437	rc = rtProcProcessOutput(rc, &hPipeStdOutR, &cbStdOut, &offStdOut, ppszStdOut, hPollSet, 1);
438	if (hPipeStdErrR != NIL_RTPIPE)
439	rc = rtProcProcessOutput(rc, &hPipeStdErrR, &cbStdErr, &offStdErr, ppszStdErr, hPollSet, 2);
440	if (hPipeStdOutR == NIL_RTPIPE && hPipeStdErrR == NIL_RTPIPE)
441	break;
442
443	if (hProc != NIL_RTPROCESS)
444	{
445	rc2 = RTProcWait(hProc, RTPROCWAIT_FLAGS_NOBLOCK, pStatus);
446	if (rc2 != VERR_PROCESS_RUNNING)
447	{
448	if (RT_FAILURE(rc2))
449	rc = rc2;
450	hProc = NIL_RTPROCESS;
451	}
452	}
453
454	rc2 = RTPoll(hPollSet, 10000, NULL, NULL);
455	Assert(RT_SUCCESS(rc2) \|\| rc2 == VERR_TIMEOUT);
456	}
457
458	if (RT_SUCCESS(rc))
459	{
460	if ( (ppszStdOut && ppszStdOut && !RTStrIsValidEncoding(ppszStdOut))
461	\|\| (ppszStdErr && ppszStdErr && !RTStrIsValidEncoding(ppszStdErr)) )
462	rc = VERR_NO_TRANSLATION;
463	}
464
465	/*
466	* No more output, just wait for it to finish.
467	*/
468	if (hProc != NIL_RTPROCESS)
469	{
470	rc2 = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, pStatus);
471	if (RT_FAILURE(rc2))
472	rc = rc2;
473	}
474	}
475	RTPollSetDestroy(hPollSet);
476	}
477	}
478
479	rc2 = RTHandleClose(&hChildStdErr); AssertRC(rc2);
480	rc2 = RTHandleClose(&hChildStdOut); AssertRC(rc2);
481	rc2 = RTHandleClose(&hChildStdIn); AssertRC(rc2);
482	rc2 = RTPipeClose(hPipeStdErrR); AssertRC(rc2);
483	rc2 = RTPipeClose(hPipeStdOutR); AssertRC(rc2);
484	return rc;
485	}
486
487
488	/**
489	* Runs a process, waiting for it to complete.
490	*
491	* @returns IPRT status code
492	*
493	* @param pszExec Executable image to use to create the child process.
494	* @param papszArgs Pointer to an array of arguments to the child. The
495	* array terminated by an entry containing NULL.
496	* @param hEnv Handle to the environment block for the child.
497	* @param fFlags A combination of RTPROCEXEC_FLAGS_XXX.
498	* @param pStatus Where to return the status on success.
499	*/
500	int RTProcExec(const char pszExec, const char const *papszArgs, RTENV hEnv, uint32_t fFlags,
501	PRTPROCSTATUS pStatus)
502	{
503	int rc;
504
505	/*
506	* Clear output argument (no returning failure here, simply crash!).
507	*/
508	AssertPtr(pStatus);
509	pStatus->enmReason = RTPROCEXITREASON_ABEND;
510	pStatus->iStatus = RTEXITCODE_FAILURE;
511
512	/*
513	* Check input arguments.
514	*/
515	AssertReturn(!(fFlags & ~RTPROCEXEC_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
516
517	/*
518	* Set up /dev/null redirections.
519	*/
520	PRTHANDLE aph[3] = { NULL, NULL, NULL };
521	RTHANDLE ah[3];
522	for (uint32_t i = 0; i < 3; i++)
523	{
524	ah[i].enmType = RTHANDLETYPE_FILE;
525	ah[i].u.hFile = NIL_RTFILE;
526	}
527	rc = VINF_SUCCESS;
528	if ((fFlags & RTPROCEXEC_FLAGS_STDIN_NULL) && RT_SUCCESS(rc))
529	{
530	aph[0] = &ah[0];
531	rc = RTFileOpenBitBucket(&ah[0].u.hFile, RTFILE_O_READ);
532	}
533	if ((fFlags & RTPROCEXEC_FLAGS_STDOUT_NULL) && RT_SUCCESS(rc))
534	{
535	aph[1] = &ah[1];
536	rc = RTFileOpenBitBucket(&ah[1].u.hFile, RTFILE_O_WRITE);
537	}
538	if ((fFlags & RTPROCEXEC_FLAGS_STDERR_NULL) && RT_SUCCESS(rc))
539	{
540	aph[2] = &ah[2];
541	rc = RTFileOpenBitBucket(&ah[2].u.hFile, RTFILE_O_WRITE);
542	}
543
544	/*
545	* Create the process.
546	*/
547	RTPROCESS hProc = NIL_RTPROCESS;
548	if (RT_SUCCESS(rc))
549	rc = RTProcCreateEx(pszExec,
550	papszArgs,
551	hEnv,
552	0 /fFlags/,
553	aph[0],
554	aph[1],
555	aph[2],
556	NULL /pszAsUser/,
557	NULL /pszPassword/,
558	&hProc);
559
560	for (uint32_t i = 0; i < 3; i++)
561	RTFileClose(ah[i].u.hFile);
562
563	if (RT_SUCCESS(rc))
564	rc = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, pStatus);
565	return rc;
566	}
567
568
569
570	/**
571	* Executes SVN and gets the output.
572	*
573	* Standard error is suppressed.
574	*
575	* @returns VINF_SUCCESS if the command executed successfully.
576	* @param pState The rewrite state to work on. Can be NULL.
577	* @param papszArgs The SVN argument.
578	* @param fNormalFailureOk Whether normal failure is ok.
579	* @param ppszStdOut Where to return the output on success.
580	*/
581	static int scmSvnRunAndGetOutput(PSCMRWSTATE pState, const char papszArgs, bool fNormalFailureOk, char ppszStdOut)
582	{
583	*ppszStdOut = NULL;
584
585	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
586	scmSvnFlushClientContextAndPool();
587	#endif
588
589	char *pszCmdLine = NULL;
590	int rc = RTGetOptArgvToString(&pszCmdLine, papszArgs, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
591	if (RT_FAILURE(rc))
592	return rc;
593	ScmVerbose(pState, 2, "executing: %s\n", pszCmdLine);
594
595	RTPROCSTATUS Status;
596	rc = RTProcExecToString(g_szSvnPath, papszArgs, RTENV_DEFAULT,
597	RTPROCEXEC_FLAGS_STD_NULL, &Status, ppszStdOut, NULL);
598
599	if ( RT_SUCCESS(rc)
600	&& ( Status.enmReason != RTPROCEXITREASON_NORMAL
601	\|\| Status.iStatus != 0) )
602	{
603	if (fNormalFailureOk \|\| Status.enmReason != RTPROCEXITREASON_NORMAL)
604	RTMsgError("%s: %s -> %s %u\n",
605	pState ? pState->pszFilename : "<NONE>", pszCmdLine,
606	Status.enmReason == RTPROCEXITREASON_NORMAL ? "exit code"
607	: Status.enmReason == RTPROCEXITREASON_SIGNAL ? "signal"
608	: Status.enmReason == RTPROCEXITREASON_ABEND ? "abnormal end"
609	: "abducted by alien",
610	Status.iStatus);
611	rc = VERR_GENERAL_FAILURE;
612	}
613	else if (RT_FAILURE(rc))
614	{
615	if (pState)
616	RTMsgError("%s: executing: %s => %Rrc\n", pState->pszFilename, pszCmdLine, rc);
617	else
618	RTMsgError("executing: %s => %Rrc\n", pszCmdLine, rc);
619	}
620
621	if (RT_FAILURE(rc))
622	{
623	RTStrFree(*ppszStdOut);
624	*ppszStdOut = NULL;
625	}
626	RTStrFree(pszCmdLine);
627	return rc;
628	}
629
630
631	/**
632	* Executes SVN.
633	*
634	* Standard error and standard output is suppressed.
635	*
636	* @returns VINF_SUCCESS if the command executed successfully.
637	* @param pState The rewrite state to work on.
638	* @param papszArgs The SVN argument.
639	* @param fNormalFailureOk Whether normal failure is ok.
640	*/
641	static int scmSvnRun(PSCMRWSTATE pState, const char **papszArgs, bool fNormalFailureOk)
642	{
643	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
644	scmSvnFlushClientContextAndPool();
645	#endif
646
647	char *pszCmdLine = NULL;
648	int rc = RTGetOptArgvToString(&pszCmdLine, papszArgs, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
649	if (RT_FAILURE(rc))
650	return rc;
651	ScmVerbose(pState, 2, "executing: %s\n", pszCmdLine);
652
653	/* Lazy bird uses RTProcExec. */
654	RTPROCSTATUS Status;
655	rc = RTProcExec(g_szSvnPath, papszArgs, RTENV_DEFAULT, RTPROCEXEC_FLAGS_STD_NULL, &Status);
656
657	if ( RT_SUCCESS(rc)
658	&& ( Status.enmReason != RTPROCEXITREASON_NORMAL
659	\|\| Status.iStatus != 0) )
660	{
661	if (fNormalFailureOk \|\| Status.enmReason != RTPROCEXITREASON_NORMAL)
662	RTMsgError("%s: %s -> %s %u\n",
663	pState->pszFilename,
664	pszCmdLine,
665	Status.enmReason == RTPROCEXITREASON_NORMAL ? "exit code"
666	: Status.enmReason == RTPROCEXITREASON_SIGNAL ? "signal"
667	: Status.enmReason == RTPROCEXITREASON_ABEND ? "abnormal end"
668	: "abducted by alien",
669	Status.iStatus);
670	rc = VERR_GENERAL_FAILURE;
671	}
672	else if (RT_FAILURE(rc))
673	RTMsgError("%s: %s -> %Rrc\n", pState->pszFilename, pszCmdLine, rc);
674
675	RTStrFree(pszCmdLine);
676	return rc;
677	}
678
679
680	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
681	/**
682	* Attempts to resolve the necessary subversion and apache portable runtime APIs
683	* we require dynamically.
684	*
685	* Will set all global function pointers and g_fSvnFunctionPointersValid to true
686	* on success.
687	*/
688	static void scmSvnTryResolveFunctions(void)
689	{
690	char szPath[RTPATH_MAX];
691	int rc = RTStrCopy(szPath, sizeof(szPath), g_szSvnPath);
692	if (RT_SUCCESS(rc))
693	{
694	RTPathStripFilename(szPath);
695	char *pszEndPath = strchr(szPath, '\0');
696	# ifdef RT_OS_WINDOWS
697	RTPathChangeToDosSlashes(szPath, false);
698	# endif
699
700	/*
701	* Try various prefixes/suffxies/locations.
702	*/
703	static struct
704	{
705	const char *pszPrefix;
706	const char *pszSuffix;
707	} const s_aVariations[] =
708	{
709	# ifdef RT_OS_WINDOWS
710	{ "SlikSvn-lib", "-1.dll" }, /* SlikSVN */
711	{ "lib", "-1.dll" }, /* Win32Svn,CollabNet,++ */
712	# elif defined(RT_OS_DARWIN)
713	{ "../lib/lib", "-1.dylib" },
714	# else
715	{ "../lib/lib", ".so" },
716	{ "../lib/lib", "-1.so" },
717	# ifdef RT_ARCH_X86
718	{ "../lib/i386-linux-gnu/lib", ".so" },
719	{ "../lib/i386-linux-gnu/lib", "-1.so" },
720	# else
721	{ "../lib/x86_64-linux-gnu/lib", ".so" },
722	{ "../lib/x86_64-linux-gnu/lib", "-1.so" },
723	# endif
724	# endif
725	};
726	for (unsigned iVar = 0; iVar < RT_ELEMENTS(s_aVariations); iVar++)
727	{
728	/*
729	* Try load the svn_client library ...
730	*/
731	static const char * const s_apszLibraries[] = { "svn_client", "svn_subr", "apr" };
732	RTLDRMOD ahMods[RT_ELEMENTS(s_apszLibraries)] = { NIL_RTLDRMOD, NIL_RTLDRMOD, NIL_RTLDRMOD };
733
734	rc = VINF_SUCCESS;
735	unsigned iLib;
736	for (iLib = 0; iLib < RT_ELEMENTS(s_apszLibraries) && RT_SUCCESS(rc); iLib++)
737	{
738	static const char * const s_apszSuffixes[] = { "", ".0", ".1" };
739	for (unsigned iSuff = 0; iSuff < RT_ELEMENTS(s_apszSuffixes); iSuff++)
740	{
741	*pszEndPath = '\0';
742	rc = RTPathAppend(szPath, sizeof(szPath), s_aVariations[iVar].pszPrefix);
743	if (RT_SUCCESS(rc))
744	rc = RTStrCat(szPath, sizeof(szPath), s_apszLibraries[iLib]);
745	if (RT_SUCCESS(rc))
746	rc = RTStrCat(szPath, sizeof(szPath), s_aVariations[iVar].pszSuffix);
747	if (RT_SUCCESS(rc))
748	rc = RTStrCat(szPath, sizeof(szPath), s_apszSuffixes[iSuff]);
749	if (RT_SUCCESS(rc))
750	{
751	# ifdef RT_OS_WINDOWS
752	RTPathChangeToDosSlashes(pszEndPath, false);
753	# endif
754	rc = RTLdrLoadEx(szPath, &ahMods[iLib], RTLDRLOAD_FLAGS_NT_SEARCH_DLL_LOAD_DIR , NULL);
755	if (RT_SUCCESS(rc))
756	{
757	RTMEM_WILL_LEAK(ahMods[iLib]);
758	break;
759	}
760	}
761	}
762	}
763	if (iLib == RT_ELEMENTS(s_apszLibraries) && RT_SUCCESS(rc))
764	{
765	static const struct
766	{
767	unsigned iLib;
768	const char *pszSymbol;
769	PFNRT *ppfn;
770	} s_aSymbols[] =
771	{
772	{ 2, "apr_initialize", (PFNRT *)&g_pfnAprInitialize },
773	{ 2, "apr_hash_first", (PFNRT *)&g_pfnAprHashFirst },
774	{ 2, "apr_hash_next", (PFNRT *)&g_pfnAprHashNext },
775	{ 2, "apr_hash_this_val", (PFNRT *)&g_pfnAprHashThisVal },
776	{ 1, "svn_pool_create_ex", (PFNRT *)&g_pfnSvnPoolCreateEx },
777	{ 2, "apr_pool_clear", (PFNRT *)&g_pfnAprPoolClear },
778	{ 2, "apr_pool_destroy", (PFNRT *)&g_pfnAprPoolDestroy },
779	{ 0, "svn_client_create_context", (PFNRT *)&g_pfnSvnClientCreateContext },
780	{ 0, "svn_client_propget4", (PFNRT *)&g_pfnSvnClientPropGet4 },
781	};
782	for (unsigned i = 0; i < RT_ELEMENTS(s_aSymbols); i++)
783	{
784	rc = RTLdrGetSymbol(ahMods[s_aSymbols[i].iLib], s_aSymbols[i].pszSymbol,
785	(void **)(uintptr_t)s_aSymbols[i].ppfn);
786	if (RT_FAILURE(rc))
787	{
788	ScmVerbose(NULL, 0, "Failed to resolve '%s' in '%s'",
789	s_aSymbols[i].pszSymbol, s_apszLibraries[s_aSymbols[i].iLib]);
790	break;
791	}
792	}
793	if (RT_SUCCESS(rc))
794	{
795	apr_status_t rcApr = g_pfnAprInitialize();
796	if (rcApr == 0)
797	{
798	ScmVerbose(NULL, 1, "Found subversion APIs.\n");
799	g_fSvnFunctionPointersValid = true;
800	}
801	else
802	{
803	ScmVerbose(NULL, 0, "apr_initialize failed: %#x (%d)\n", rcApr, rcApr);
804	AssertMsgFailed(("%#x (%d)\n", rc, rc));
805	}
806	return;
807	}
808	}
809
810	while (iLib-- > 0)
811	RTLdrClose(ahMods[iLib]);
812	}
813	}
814	}
815	#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
816
817
818	/**
819	* Finds the svn binary, updating g_szSvnPath and g_enmSvnVersion.
820	*/
821	static void scmSvnFindSvnBinary(PSCMRWSTATE pState)
822	{
823	/* Already been called? */
824	if (g_szSvnPath[0] != '\0')
825	return;
826
827	/*
828	* Locate it.
829	*/
830	/** @todo code page fun... */
831	#ifdef RT_OS_WINDOWS
832	const char *pszEnvVar = RTEnvGet("Path");
833	#else
834	const char *pszEnvVar = RTEnvGet("PATH");
835	#endif
836	if (pszEnvVar)
837	{
838	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
839	int rc = RTPathTraverseList(pszEnvVar, ';', scmSvnFindSvnBinaryCallback, g_szSvnPath, (void *)sizeof(g_szSvnPath));
840	#else
841	int rc = RTPathTraverseList(pszEnvVar, ':', scmSvnFindSvnBinaryCallback, g_szSvnPath, (void *)sizeof(g_szSvnPath));
842	#endif
843	if (RT_FAILURE(rc))
844	strcpy(g_szSvnPath, "svn");
845	}
846	else
847	strcpy(g_szSvnPath, "svn");
848
849	/*
850	* Check the version.
851	*/
852	const char *apszArgs[] = { g_szSvnPath, "--version", "--quiet", NULL };
853	char *pszVersion;
854	int rc = scmSvnRunAndGetOutput(pState, apszArgs, false, &pszVersion);
855	if (RT_SUCCESS(rc))
856	{
857	char *pszStripped = RTStrStrip(pszVersion);
858	if (RTStrVersionCompare(pszStripped, "1.8") >= 0)
859	g_enmSvnVersion = kScmSvnVersion_1_8;
860	else if (RTStrVersionCompare(pszStripped, "1.7") >= 0)
861	g_enmSvnVersion = kScmSvnVersion_1_7;
862	else if (RTStrVersionCompare(pszStripped, "1.6") >= 0)
863	g_enmSvnVersion = kScmSvnVersion_1_6;
864	else
865	g_enmSvnVersion = kScmSvnVersion_Ancient;
866	RTStrFree(pszVersion);
867	}
868	else
869	g_enmSvnVersion = kScmSvnVersion_Ancient;
870
871	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
872	/*
873	* If we got version 1.8 or later, try see if we can locate a few of the
874	* simpler SVN APIs.
875	*/
876	g_fSvnFunctionPointersValid = false;
877	if (g_enmSvnVersion >= kScmSvnVersion_1_8)
878	scmSvnTryResolveFunctions();
879	#endif
880	}
881
882
883	/**
884	* Construct a dot svn filename for the file being rewritten.
885	*
886	* @returns IPRT status code.
887	* @param pState The rewrite state (for the name).
888	* @param pszDir The directory, including ".svn/".
889	* @param pszSuff The filename suffix.
890	* @param pszDst The output buffer. RTPATH_MAX in size.
891	*/
892	static int scmSvnConstructName(PSCMRWSTATE pState, const char pszDir, const char pszSuff, char *pszDst)
893	{
894	strcpy(pszDst, pState->pszFilename); /* ASSUMES sizeof(szBuf) <= sizeof(szPath) */
895	RTPathStripFilename(pszDst);
896
897	int rc = RTPathAppend(pszDst, RTPATH_MAX, pszDir);
898	if (RT_SUCCESS(rc))
899	{
900	rc = RTPathAppend(pszDst, RTPATH_MAX, RTPathFilename(pState->pszFilename));
901	if (RT_SUCCESS(rc))
902	{
903	size_t cchDst = strlen(pszDst);
904	size_t cchSuff = strlen(pszSuff);
905	if (cchDst + cchSuff < RTPATH_MAX)
906	{
907	memcpy(&pszDst[cchDst], pszSuff, cchSuff + 1);
908	return VINF_SUCCESS;
909	}
910	else
911	rc = VERR_BUFFER_OVERFLOW;
912	}
913	}
914	return rc;
915	}
916
917	/**
918	* Interprets the specified string as decimal numbers.
919	*
920	* @returns true if parsed successfully, false if not.
921	* @param pch The string (not terminated).
922	* @param cch The string length.
923	* @param pu Where to return the value.
924	*/
925	static bool scmSvnReadNumber(const char pch, size_t cch, size_t pu)
926	{
927	size_t u = 0;
928	while (cch-- > 0)
929	{
930	char ch = *pch++;
931	if (ch < '0' \|\| ch > '9')
932	return false;
933	u *= 10;
934	u += ch - '0';
935	}
936	*pu = u;
937	return true;
938	}
939
940
941	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
942
943	/**
944	* Wrapper around RTPathAbs.
945	* @returns Same as RTPathAbs.
946	* @param pszPath The relative path.
947	* @param pszAbsPath Where to return the absolute path.
948	* @param cbAbsPath Size of the @a pszAbsPath buffer.
949	*/
950	static int scmSvnAbsPath(const char pszPath, char pszAbsPath, size_t cbAbsPath)
951	{
952	int rc = RTPathAbs(pszPath, pszAbsPath, cbAbsPath);
953	# if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS
954	if (RT_SUCCESS(rc))
955	{
956	RTPathChangeToUnixSlashes(pszAbsPath, true /fForce/);
957	/* To avoid: svn: E235000: In file '..\..\..\subversion\libsvn_client\prop_commands.c' line 796: assertion failed (svn_dirent_is_absolute(target)) */
958	if (pszAbsPath[1] == ':')
959	pszAbsPath[0] = RT_C_TO_UPPER(pszAbsPath[0]);
960	}
961	# endif
962	return rc;
963	}
964
965
966	/**
967	* Gets a client context and pool.
968	*
969	* This implements caching.
970	*
971	* @returns IPRT status code.
972	* @param ppCtx Where to return the context
973	* @param ppPool Where to return the pool.
974	*/
975	static int scmSvnGetClientContextAndPool(svn_client_ctx_t ppCtx, apr_pool_t ppPool)
976	{
977	/*
978	* Use cached if present.
979	*/
980	if (g_pSvnClientCtx && g_pSvnPool)
981	{
982	g_cSvnClientCtxUsed++;
983	*ppCtx = g_pSvnClientCtx;
984	*ppPool = g_pSvnPool;
985	return VINF_SUCCESS;
986	}
987	Assert(!g_pSvnClientCtx);
988	Assert(!g_pSvnPool);
989
990	/*
991	* Create new pool and context.
992	*/
993	apr_pool_t *pPool = g_pfnSvnPoolCreateEx(NULL, NULL);
994	if (pPool)
995	{
996	svn_client_ctx_t *pCtx = NULL;
997	svn_error_t *pErr = g_pfnSvnClientCreateContext(&pCtx, pPool);
998	if (!pErr)
999	{
1000	g_cSvnClientCtxUsed = 1;
1001	g_pSvnClientCtx = *ppCtx = pCtx;
1002	g_pSvnPool = *ppPool = pPool;
1003	return VINF_SUCCESS;
1004	}
1005	g_pfnAprPoolDestroy(pPool);
1006	}
1007
1008	*ppCtx = NULL;
1009	*ppPool = NULL;
1010	return VERR_GENERAL_FAILURE;
1011	}
1012
1013
1014	/**
1015	* Puts back a client context and pool after use.
1016	*
1017	* @param pCtx The context.
1018	* @param pPool The pool.
1019	* @param fFlush Whether to flush it.
1020	*/
1021	static void scmSvnPutClientContextAndPool(svn_client_ctx_t pCtx, apr_pool_t pPool, bool fFlush)
1022	{
1023	if (fFlush \|\| g_cSvnClientCtxUsed > 4096) /* Disable this to force new context every time. */
1024	{
1025	g_pfnAprPoolDestroy(pPool);
1026	g_pSvnPool = NULL;
1027	g_pSvnClientCtx = NULL;
1028	}
1029	RT_NOREF(pCtx, fFlush);
1030	}
1031
1032
1033	/**
1034	* Flushes the cached client context and pool
1035	*/
1036	static void scmSvnFlushClientContextAndPool(void)
1037	{
1038	if (g_pSvnPool)
1039	scmSvnPutClientContextAndPool(g_pSvnClientCtx, g_pSvnPool, true /fFlush/);
1040	Assert(!g_pSvnPool);
1041	}
1042
1043
1044	/**
1045	* Checks if @a pszPath exists in the current WC.
1046	*
1047	* @returns true, false or -1. In the latter case, please use the fallback.
1048	* @param pszPath Path to the object that should be investigated.
1049	*/
1050	static int scmSvnIsObjectInWorkingCopy(const char *pszPath)
1051	{
1052	/* svn_client_propget4 and later requires absolute target path. */
1053	char szAbsPath[RTPATH_MAX];
1054	int rc = scmSvnAbsPath(pszPath, szAbsPath, sizeof(szAbsPath));
1055	if (RT_SUCCESS(rc))
1056	{
1057	apr_pool_t *pPool;
1058	svn_client_ctx_t *pCtx = NULL;
1059	rc = scmSvnGetClientContextAndPool(&pCtx, &pPool);
1060	if (RT_SUCCESS(rc))
1061	{
1062	/* Make the call. */
1063	apr_hash_t *pHash = NULL;
1064	svn_opt_revision_t Rev;
1065	RT_ZERO(Rev);
1066	Rev.kind = svn_opt_revision_working;
1067	Rev.value.number = -1L;
1068	svn_error_t *pErr = g_pfnSvnClientPropGet4(&pHash, "svn:no-such-property", szAbsPath, &Rev, &Rev,
1069	NULL /pActualRev/, svn_depth_empty, NULL /pChangeList/,
1070	pCtx, pPool, pPool);
1071	if (!pErr)
1072	rc = true;
1073	else if (pErr->apr_err == SVN_ERR_UNVERSIONED_RESOURCE)
1074	rc = false;
1075
1076	scmSvnPutClientContextAndPool(pCtx, pPool, false);
1077	}
1078	}
1079	return rc;
1080	}
1081
1082	#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
1083
1084
1085	/**
1086	* Checks if the file we're operating on is part of a SVN working copy.
1087	*
1088	* @returns true if it is, false if it isn't or we cannot tell.
1089	* @param pState The rewrite state to work on. Will use the
1090	* fIsInSvnWorkingCopy member for caching the result.
1091	*/
1092	bool ScmSvnIsInWorkingCopy(PSCMRWSTATE pState)
1093	{
1094	/*
1095	* We don't ask SVN twice as that's expensive.
1096	*/
1097	if (pState->fIsInSvnWorkingCopy != 0)
1098	return pState->fIsInSvnWorkingCopy > 0;
1099
1100	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1101	if (g_fSvnFunctionPointersValid)
1102	{
1103	int rc = scmSvnIsObjectInWorkingCopy(pState->pszFilename);
1104	if (rc == (int)true \|\| rc == (int)false)
1105	{
1106	pState->fIsInSvnWorkingCopy = rc == (int)true ? 1 : -1;
1107	return rc == (int)true;
1108	}
1109	}
1110
1111	/* Fallback: */
1112	#endif
1113	if (g_enmSvnVersion < kScmSvnVersion_1_7)
1114	{
1115	/*
1116	* Hack: check if the .svn/text-base/<file>.svn-base file exists.
1117	*/
1118	char szPath[RTPATH_MAX];
1119	int rc = scmSvnConstructName(pState, ".svn/text-base/", ".svn-base", szPath);
1120	if (RT_SUCCESS(rc))
1121	{
1122	if (RTFileExists(szPath))
1123	{
1124	pState->fIsInSvnWorkingCopy = 1;
1125	return true;
1126	}
1127	}
1128	}
1129	else
1130	{
1131	const char *apszArgs[] = { g_szSvnPath, "propget", "svn:no-such-property", pState->pszFilename, NULL };
1132	char *pszValue;
1133	int rc = scmSvnRunAndGetOutput(pState, apszArgs, true, &pszValue);
1134	if (RT_SUCCESS(rc))
1135	{
1136	RTStrFree(pszValue);
1137	pState->fIsInSvnWorkingCopy = 1;
1138	return true;
1139	}
1140	}
1141	pState->fIsInSvnWorkingCopy = -1;
1142	return false;
1143	}
1144
1145
1146	/**
1147	* Checks if the specified directory is part of a SVN working copy.
1148	*
1149	* @returns true if it is, false if it isn't or we cannot tell.
1150	* @param pszDir The directory in question.
1151	*/
1152	bool ScmSvnIsDirInWorkingCopy(const char *pszDir)
1153	{
1154	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1155	if (g_fSvnFunctionPointersValid)
1156	{
1157	int rc = scmSvnIsObjectInWorkingCopy(pszDir);
1158	if (rc == (int)true \|\| rc == (int)false)
1159	return rc == (int)true;
1160	}
1161
1162	/* Fallback: */
1163	#endif
1164	if (g_enmSvnVersion < kScmSvnVersion_1_7)
1165	{
1166	/*
1167	* Hack: check if the .svn/ dir exists.
1168	*/
1169	char szPath[RTPATH_MAX];
1170	int rc = RTPathJoin(szPath, sizeof(szPath), pszDir, ".svn");
1171	if (RT_SUCCESS(rc))
1172	return RTDirExists(szPath);
1173	}
1174	else
1175	{
1176	const char *apszArgs[] = { g_szSvnPath, "propget", "svn:no-such-property", pszDir, NULL };
1177	char *pszValue;
1178	int rc = scmSvnRunAndGetOutput(NULL, apszArgs, true, &pszValue);
1179	if (RT_SUCCESS(rc))
1180	{
1181	RTStrFree(pszValue);
1182	return true;
1183	}
1184	}
1185	return false;
1186	}
1187
1188
1189	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1190	/**
1191	* Checks if @a pszPath exists in the current WC.
1192	*
1193	* @returns IPRT status code - VERR_NOT_SUPPORT if fallback should be attempted.
1194	* @param pszPath Path to the object that should be investigated.
1195	* @param pszProperty The property name.
1196	* @param ppszValue Where to return the property value. Optional.
1197	*/
1198	static int scmSvnQueryPropertyUsingApi(const char pszPath, const char pszProperty, char **ppszValue)
1199	{
1200	/* svn_client_propget4 and later requires absolute target path. */
1201	char szAbsPath[RTPATH_MAX];
1202	int rc = scmSvnAbsPath(pszPath, szAbsPath, sizeof(szAbsPath));
1203	if (RT_SUCCESS(rc))
1204	{
1205	apr_pool_t *pPool;
1206	svn_client_ctx_t *pCtx = NULL;
1207	rc = scmSvnGetClientContextAndPool(&pCtx, &pPool);
1208	if (RT_SUCCESS(rc))
1209	{
1210	/* Make the call. */
1211	apr_hash_t *pHash = NULL;
1212	svn_opt_revision_t Rev;
1213	RT_ZERO(Rev);
1214	Rev.kind = svn_opt_revision_working;
1215	Rev.value.number = -1L;
1216	svn_error_t *pErr = g_pfnSvnClientPropGet4(&pHash, pszProperty, szAbsPath, &Rev, &Rev,
1217	NULL /pActualRev/, svn_depth_empty, NULL /pChangeList/,
1218	pCtx, pPool, pPool);
1219	if (!pErr)
1220	{
1221	/* Get the first value, if any. */
1222	rc = VERR_NOT_FOUND;
1223	apr_hash_index_t *pHashIdx = g_pfnAprHashFirst(pPool, pHash);
1224	if (pHashIdx)
1225	{
1226	const char ppszFirst = (const char )g_pfnAprHashThisVal(pHashIdx);
1227	if (ppszFirst && *ppszFirst)
1228	{
1229	if (ppszValue)
1230	rc = RTStrDupEx(ppszValue, *ppszFirst);
1231	else
1232	rc = VINF_SUCCESS;
1233	}
1234	}
1235	}
1236	else if (pErr->apr_err == SVN_ERR_UNVERSIONED_RESOURCE)
1237	rc = VERR_INVALID_STATE;
1238	else
1239	rc = VERR_GENERAL_FAILURE;
1240
1241	scmSvnPutClientContextAndPool(pCtx, pPool, false);
1242	}
1243	}
1244	return rc;
1245	}
1246	#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
1247
1248
1249	/**
1250	* Queries the value of an SVN property.
1251	*
1252	* This will automatically adjust for scheduled changes.
1253	*
1254	* @returns IPRT status code.
1255	* @retval VERR_INVALID_STATE if not a SVN WC file.
1256	* @retval VERR_NOT_FOUND if the property wasn't found.
1257	* @param pState The rewrite state to work on.
1258	* @param pszName The property name.
1259	* @param ppszValue Where to return the property value. Free this
1260	* using RTStrFree. Optional.
1261	*/
1262	int ScmSvnQueryProperty(PSCMRWSTATE pState, const char pszName, char *ppszValue)
1263	{
1264	int rc;
1265
1266	/*
1267	* Look it up in the scheduled changes.
1268	*/
1269	size_t i = pState->cSvnPropChanges;
1270	while (i-- > 0)
1271	if (!strcmp(pState->paSvnPropChanges[i].pszName, pszName))
1272	{
1273	const char *pszValue = pState->paSvnPropChanges[i].pszValue;
1274	if (!pszValue)
1275	return VERR_NOT_FOUND;
1276	if (ppszValue)
1277	return RTStrDupEx(ppszValue, pszValue);
1278	return VINF_SUCCESS;
1279	}
1280
1281	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1282	if (g_fSvnFunctionPointersValid)
1283	{
1284	rc = scmSvnQueryPropertyUsingApi(pState->pszFilename, pszName, ppszValue);
1285	if (rc != VERR_NOT_SUPPORTED)
1286	return rc;
1287	/* Fallback: */
1288	}
1289	#endif
1290
1291	if (g_enmSvnVersion < kScmSvnVersion_1_7)
1292	{
1293	/*
1294	* Hack: Read the .svn/props/<file>.svn-work file exists.
1295	*/
1296	char szPath[RTPATH_MAX];
1297	rc = scmSvnConstructName(pState, ".svn/props/", ".svn-work", szPath);
1298	if (RT_SUCCESS(rc) && !RTFileExists(szPath))
1299	rc = scmSvnConstructName(pState, ".svn/prop-base/", ".svn-base", szPath);
1300	if (RT_SUCCESS(rc))
1301	{
1302	SCMSTREAM Stream;
1303	rc = ScmStreamInitForReading(&Stream, szPath);
1304	if (RT_SUCCESS(rc))
1305	{
1306	/*
1307	* The current format is K len\n<name>\nV len\n<value>\n" ... END.
1308	*/
1309	rc = VERR_NOT_FOUND;
1310	size_t const cchName = strlen(pszName);
1311	SCMEOL enmEol;
1312	size_t cchLine;
1313	const char *pchLine;
1314	while ((pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol)) != NULL)
1315	{
1316	/*
1317	* Parse the 'K num' / 'END' line.
1318	*/
1319	if ( cchLine == 3
1320	&& !memcmp(pchLine, "END", 3))
1321	break;
1322	size_t cchKey;
1323	if ( cchLine < 3
1324	\|\| pchLine[0] != 'K'
1325	\|\| pchLine[1] != ' '
1326	\|\| !scmSvnReadNumber(&pchLine[2], cchLine - 2, &cchKey)
1327	\|\| cchKey == 0
1328	\|\| cchKey > 4096)
1329	{
1330	RTMsgError("%s:%u: Unexpected data '%.*s'\n", szPath, ScmStreamTellLine(&Stream), cchLine, pchLine);
1331	rc = VERR_PARSE_ERROR;
1332	break;
1333	}
1334
1335	/*
1336	* Match the key and skip to the value line. Don't bother with
1337	* names containing EOL markers.
1338	*/
1339	size_t const offKey = ScmStreamTell(&Stream);
1340	bool fMatch = cchName == cchKey;
1341	if (fMatch)
1342	{
1343	pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol);
1344	if (!pchLine)
1345	break;
1346	fMatch = cchLine == cchName
1347	&& !memcmp(pchLine, pszName, cchName);
1348	}
1349
1350	if (RT_FAILURE(ScmStreamSeekAbsolute(&Stream, offKey + cchKey)))
1351	break;
1352	if (RT_FAILURE(ScmStreamSeekByLine(&Stream, ScmStreamTellLine(&Stream) + 1)))
1353	break;
1354
1355	/*
1356	* Read and Parse the 'V num' line.
1357	*/
1358	pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol);
1359	if (!pchLine)
1360	break;
1361	size_t cchValue;
1362	if ( cchLine < 3
1363	\|\| pchLine[0] != 'V'
1364	\|\| pchLine[1] != ' '
1365	\|\| !scmSvnReadNumber(&pchLine[2], cchLine - 2, &cchValue)
1366	\|\| cchValue > _1M)
1367	{
1368	RTMsgError("%s:%u: Unexpected data '%.*s'\n", szPath, ScmStreamTellLine(&Stream), cchLine, pchLine);
1369	rc = VERR_PARSE_ERROR;
1370	break;
1371	}
1372
1373	/*
1374	* If we have a match, allocate a return buffer and read the
1375	* value into it. Otherwise skip this value and continue
1376	* searching.
1377	*/
1378	if (fMatch)
1379	{
1380	if (!ppszValue)
1381	rc = VINF_SUCCESS;
1382	else
1383	{
1384	char *pszValue;
1385	rc = RTStrAllocEx(&pszValue, cchValue + 1);
1386	if (RT_SUCCESS(rc))
1387	{
1388	rc = ScmStreamRead(&Stream, pszValue, cchValue);
1389	if (RT_SUCCESS(rc))
1390	*ppszValue = pszValue;
1391	else
1392	RTStrFree(pszValue);
1393	}
1394	}
1395	break;
1396	}
1397
1398	if (RT_FAILURE(ScmStreamSeekRelative(&Stream, cchValue)))
1399	break;
1400	if (RT_FAILURE(ScmStreamSeekByLine(&Stream, ScmStreamTellLine(&Stream) + 1)))
1401	break;
1402	}
1403
1404	if (RT_FAILURE(ScmStreamGetStatus(&Stream)))
1405	{
1406	rc = ScmStreamGetStatus(&Stream);
1407	RTMsgError("%s: stream error %Rrc\n", szPath, rc);
1408	}
1409	ScmStreamDelete(&Stream);
1410	}
1411	}
1412
1413	if (rc == VERR_FILE_NOT_FOUND)
1414	rc = VERR_NOT_FOUND;
1415	}
1416	else
1417	{
1418	const char *apszArgs[] = { g_szSvnPath, "propget", "--strict", pszName, pState->pszFilename, NULL };
1419	char *pszValue;
1420	rc = scmSvnRunAndGetOutput(pState, apszArgs, false, &pszValue);
1421	if (RT_SUCCESS(rc))
1422	{
1423	if (pszValue && *pszValue)
1424	{
1425	if (ppszValue)
1426	{
1427	*ppszValue = pszValue;
1428	pszValue = NULL;
1429	}
1430	}
1431	else
1432	rc = VERR_NOT_FOUND;
1433	RTStrFree(pszValue);
1434	}
1435	}
1436	return rc;
1437	}
1438
1439
1440	/**
1441	* Queries the value of an SVN property on the parent dir/whatever.
1442	*
1443	* This will not adjust for scheduled changes to the parent!
1444	*
1445	* @returns IPRT status code.
1446	* @retval VERR_INVALID_STATE if not a SVN WC file.
1447	* @retval VERR_NOT_FOUND if the property wasn't found.
1448	* @param pState The rewrite state to work on.
1449	* @param pszName The property name.
1450	* @param ppszValue Where to return the property value. Free this
1451	* using RTStrFree. Optional.
1452	*/
1453	int ScmSvnQueryParentProperty(PSCMRWSTATE pState, const char pszName, char *ppszValue)
1454	{
1455	/*
1456	* Strip the filename and use ScmSvnQueryProperty.
1457	*/
1458	char szPath[RTPATH_MAX];
1459	int rc = RTStrCopy(szPath, sizeof(szPath), pState->pszFilename);
1460	if (RT_SUCCESS(rc))
1461	{
1462	RTPathStripFilename(szPath);
1463	SCMRWSTATE ParentState;
1464	ParentState.pszFilename = szPath;
1465	ParentState.fFirst = false;
1466	ParentState.fIsInSvnWorkingCopy = true;
1467	ParentState.cSvnPropChanges = 0;
1468	ParentState.paSvnPropChanges = NULL;
1469	ParentState.rc = VINF_SUCCESS;
1470	rc = ScmSvnQueryProperty(&ParentState, pszName, ppszValue);
1471	if (RT_SUCCESS(rc))
1472	rc = ParentState.rc;
1473	}
1474	return rc;
1475	}
1476
1477
1478	/**
1479	* Schedules the setting of a property.
1480	*
1481	* @returns IPRT status code.
1482	* @retval VERR_INVALID_STATE if not a SVN WC file.
1483	* @param pState The rewrite state to work on.
1484	* @param pszName The name of the property to set.
1485	* @param pszValue The value. NULL means deleting it.
1486	*/
1487	int ScmSvnSetProperty(PSCMRWSTATE pState, const char pszName, const char pszValue)
1488	{
1489	/*
1490	* Update any existing entry first.
1491	*/
1492	size_t i = pState->cSvnPropChanges;
1493	while (i-- > 0)
1494	if (!strcmp(pState->paSvnPropChanges[i].pszName, pszName))
1495	{
1496	if (!pszValue)
1497	{
1498	RTStrFree(pState->paSvnPropChanges[i].pszValue);
1499	pState->paSvnPropChanges[i].pszValue = NULL;
1500	}
1501	else
1502	{
1503	char *pszCopy;
1504	int rc = RTStrDupEx(&pszCopy, pszValue);
1505	if (RT_FAILURE(rc))
1506	return rc;
1507	pState->paSvnPropChanges[i].pszValue = pszCopy;
1508	}
1509	return VINF_SUCCESS;
1510	}
1511
1512	/*
1513	* Insert a new entry.
1514	*/
1515	i = pState->cSvnPropChanges;
1516	if ((i % 32) == 0)
1517	{
1518	void pvNew = RTMemRealloc(pState->paSvnPropChanges, (i + 32) sizeof(SCMSVNPROP));
1519	if (!pvNew)
1520	return VERR_NO_MEMORY;
1521	pState->paSvnPropChanges = (PSCMSVNPROP)pvNew;
1522	}
1523
1524	pState->paSvnPropChanges[i].pszName = RTStrDup(pszName);
1525	pState->paSvnPropChanges[i].pszValue = pszValue ? RTStrDup(pszValue) : NULL;
1526	if ( pState->paSvnPropChanges[i].pszName
1527	&& (pState->paSvnPropChanges[i].pszValue \|\| !pszValue) )
1528	pState->cSvnPropChanges = i + 1;
1529	else
1530	{
1531	RTStrFree(pState->paSvnPropChanges[i].pszName);
1532	pState->paSvnPropChanges[i].pszName = NULL;
1533	RTStrFree(pState->paSvnPropChanges[i].pszValue);
1534	pState->paSvnPropChanges[i].pszValue = NULL;
1535	return VERR_NO_MEMORY;
1536	}
1537	return VINF_SUCCESS;
1538	}
1539
1540
1541	/**
1542	* Schedules a property deletion.
1543	*
1544	* @returns IPRT status code.
1545	* @param pState The rewrite state to work on.
1546	* @param pszName The name of the property to delete.
1547	*/
1548	int ScmSvnDelProperty(PSCMRWSTATE pState, const char *pszName)
1549	{
1550	return ScmSvnSetProperty(pState, pszName, NULL);
1551	}
1552
1553
1554	/**
1555	* Applies any SVN property changes to the work copy of the file.
1556	*
1557	* @returns IPRT status code.
1558	* @param pState The rewrite state which SVN property changes
1559	* should be applied.
1560	*/
1561	int ScmSvnDisplayChanges(PSCMRWSTATE pState)
1562	{
1563	size_t i = pState->cSvnPropChanges;
1564	while (i-- > 0)
1565	{
1566	const char *pszName = pState->paSvnPropChanges[i].pszName;
1567	const char *pszValue = pState->paSvnPropChanges[i].pszValue;
1568	if (pszValue)
1569	ScmVerbose(pState, 0, "svn propset '%s' '%s' %s\n", pszName, pszValue, pState->pszFilename);
1570	else
1571	ScmVerbose(pState, 0, "svn propdel '%s' %s\n", pszName, pState->pszFilename);
1572	}
1573
1574	return VINF_SUCCESS;
1575	}
1576
1577	/**
1578	* Applies any SVN property changes to the work copy of the file.
1579	*
1580	* @returns IPRT status code.
1581	* @param pState The rewrite state which SVN property changes
1582	* should be applied.
1583	*/
1584	int ScmSvnApplyChanges(PSCMRWSTATE pState)
1585	{
1586	#ifdef SCM_WITH_LATER
1587	if (0)
1588	{
1589	return ...;
1590	}
1591
1592	/* Fallback: */
1593	#endif
1594
1595	/*
1596	* Iterate thru the changes and apply them by starting the svn client.
1597	*/
1598	for (size_t i = 0; i < pState->cSvnPropChanges; i++)
1599	{
1600	const char *apszArgv[6];
1601	apszArgv[0] = g_szSvnPath;
1602	apszArgv[1] = pState->paSvnPropChanges[i].pszValue ? "propset" : "propdel";
1603	apszArgv[2] = pState->paSvnPropChanges[i].pszName;
1604	int iArg = 3;
1605	if (pState->paSvnPropChanges[i].pszValue)
1606	apszArgv[iArg++] = pState->paSvnPropChanges[i].pszValue;
1607	apszArgv[iArg++] = pState->pszFilename;
1608	apszArgv[iArg++] = NULL;
1609
1610	int rc = scmSvnRun(pState, apszArgv, false);
1611	if (RT_FAILURE(rc))
1612	return rc;
1613	}
1614
1615	return VINF_SUCCESS;
1616	}
1617
1618
1619	/**
1620	* Initializes the subversion interface.
1621	*/
1622	void ScmSvnInit(void)
1623	{
1624	scmSvnFindSvnBinary(NULL);
1625	}
1626
1627
1628	void ScmSvnTerm(void)
1629	{
1630	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1631	scmSvnFlushClientContextAndPool();
1632	#endif
1633	}

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

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

Download in other formats: