scmsubversion.cpp@ 62485

Last change on this file since 62485 was 57353, checked in by vboxsync, 9 years ago
scm: Added fixing of flower boxes marking sections in C/C++ source file, like 'Header Files' and 'Defined Constants And Macros'. Applied it to the bldprogs.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.3 KB

Line
1	/* $Id: scmsubversion.cpp 57353 2015-08-14 14:31:09Z vboxsync $ */
2	/** @file
3	* IPRT Testcase / Tool - Source Code Massager, Subversion Access.
4	*/
5
6	/*
7	* Copyright (C) 2010-2015 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	#endif
163
164
165
166	/**
167	* Callback that is call for each path to search.
168	*/
169	static DECLCALLBACK(int) scmSvnFindSvnBinaryCallback(char const pchPath, size_t cchPath, void pvUser1, void *pvUser2)
170	{
171	char pszDst = (char )pvUser1;
172	size_t cchDst = (size_t)pvUser2;
173	if (cchDst > cchPath)
174	{
175	memcpy(pszDst, pchPath, cchPath);
176	pszDst[cchPath] = '\0';
177	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
178	int rc = RTPathAppend(pszDst, cchDst, "svn.exe");
179	#else
180	int rc = RTPathAppend(pszDst, cchDst, "svn");
181	#endif
182	if ( RT_SUCCESS(rc)
183	&& RTFileExists(pszDst))
184	return VINF_SUCCESS;
185	}
186	return VERR_TRY_AGAIN;
187	}
188
189
190	/**
191	* Reads from a pipe.
192	*
193	* @returns @a rc or other status code.
194	* @param rc The current status of the operation. Error status
195	* are preserved and returned.
196	* @param phPipeR Pointer to the pipe handle.
197	* @param pcbAllocated Pointer to the buffer size variable.
198	* @param poffCur Pointer to the buffer offset variable.
199	* @param ppszBuffer Pointer to the buffer pointer variable.
200	*/
201	static int rtProcProcessOutput(int rc, PRTPIPE phPipeR, size_t pcbAllocated, size_t poffCur, char **ppszBuffer,
202	RTPOLLSET hPollSet, uint32_t idPollSet)
203	{
204	size_t cbRead;
205	char szTmp[_4K - 1];
206	for (;;)
207	{
208	int rc2 = RTPipeRead(*phPipeR, szTmp, sizeof(szTmp), &cbRead);
209	if (RT_SUCCESS(rc2) && cbRead)
210	{
211	/* Resize the buffer. */
212	if (poffCur + cbRead >= pcbAllocated)
213	{
214	if (*pcbAllocated >= _1G)
215	{
216	RTPollSetRemove(hPollSet, idPollSet);
217	rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
218	*phPipeR = NIL_RTPIPE;
219	return RT_SUCCESS(rc) ? VERR_TOO_MUCH_DATA : rc;
220	}
221
222	size_t cbNew = pcbAllocated ? pcbAllocated * 2 : sizeof(szTmp) + 1;
223	Assert(*poffCur + cbRead < cbNew);
224	rc2 = RTStrRealloc(ppszBuffer, cbNew);
225	if (RT_FAILURE(rc2))
226	{
227	RTPollSetRemove(hPollSet, idPollSet);
228	rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
229	*phPipeR = NIL_RTPIPE;
230	return RT_SUCCESS(rc) ? rc2 : rc;
231	}
232	*pcbAllocated = cbNew;
233	}
234
235	/* Append the new data, terminating it. */
236	memcpy(ppszBuffer + poffCur, szTmp, cbRead);
237	*poffCur += cbRead;
238	(ppszBuffer)[poffCur] = '\0';
239
240	/* Check for null terminators in the string. */
241	if (RT_SUCCESS(rc) && memchr(szTmp, '\0', cbRead))
242	rc = VERR_NO_TRANSLATION;
243
244	/* If we read a full buffer, try read some more. */
245	if (RT_SUCCESS(rc) && cbRead == sizeof(szTmp))
246	continue;
247	}
248	else if (rc2 != VINF_TRY_AGAIN)
249	{
250	if (RT_FAILURE(rc) && rc2 != VERR_BROKEN_PIPE)
251	rc = rc2;
252	RTPollSetRemove(hPollSet, idPollSet);
253	rc2 = RTPipeClose(*phPipeR); AssertRC(rc2);
254	*phPipeR = NIL_RTPIPE;
255	}
256	return rc;
257	}
258	}
259
260	/** @name RTPROCEXEC_FLAGS_XXX - flags for RTProcExec and RTProcExecToString.
261	* @{ */
262	/** Redirect /dev/null to standard input. */
263	#define RTPROCEXEC_FLAGS_STDIN_NULL RT_BIT_32(0)
264	/** Redirect standard output to /dev/null. */
265	#define RTPROCEXEC_FLAGS_STDOUT_NULL RT_BIT_32(1)
266	/** Redirect standard error to /dev/null. */
267	#define RTPROCEXEC_FLAGS_STDERR_NULL RT_BIT_32(2)
268	/** Redirect all standard output to /dev/null as well as directing /dev/null
269	* to standard input. */
270	#define RTPROCEXEC_FLAGS_STD_NULL ( RTPROCEXEC_FLAGS_STDIN_NULL \
271	\| RTPROCEXEC_FLAGS_STDOUT_NULL \
272	\| RTPROCEXEC_FLAGS_STDERR_NULL)
273	/** Mask containing the valid flags. */
274	#define RTPROCEXEC_FLAGS_VALID_MASK UINT32_C(0x00000007)
275	/** @} */
276
277	/**
278	* Runs a process, collecting the standard output and/or standard error.
279	*
280	*
281	* @returns IPRT status code
282	* @retval VERR_NO_TRANSLATION if the output of the program isn't valid UTF-8
283	* or contains a nul character.
284	* @retval VERR_TOO_MUCH_DATA if the process produced too much data.
285	*
286	* @param pszExec Executable image to use to create the child process.
287	* @param papszArgs Pointer to an array of arguments to the child. The
288	* array terminated by an entry containing NULL.
289	* @param hEnv Handle to the environment block for the child.
290	* @param fFlags A combination of RTPROCEXEC_FLAGS_XXX. The @a
291	* ppszStdOut and @a ppszStdErr parameters takes precedence
292	* over redirection flags.
293	* @param pStatus Where to return the status on success.
294	* @param ppszStdOut Where to return the text written to standard output. If
295	* NULL then standard output will not be collected and go
296	* to the standard output handle of the process.
297	* Free with RTStrFree, regardless of return status.
298	* @param ppszStdErr Where to return the text written to standard error. If
299	* NULL then standard output will not be collected and go
300	* to the standard error handle of the process.
301	* Free with RTStrFree, regardless of return status.
302	*/
303	int RTProcExecToString(const char pszExec, const char const *papszArgs, RTENV hEnv, uint32_t fFlags,
304	PRTPROCSTATUS pStatus, char ppszStdOut, char ppszStdErr)
305	{
306	int rc2;
307
308	/*
309	* Clear output arguments (no returning failure here, simply crash!).
310	*/
311	AssertPtr(pStatus);
312	pStatus->enmReason = RTPROCEXITREASON_ABEND;
313	pStatus->iStatus = RTEXITCODE_FAILURE;
314	AssertPtrNull(ppszStdOut);
315	if (ppszStdOut)
316	*ppszStdOut = NULL;
317	AssertPtrNull(ppszStdOut);
318	if (ppszStdErr)
319	*ppszStdErr = NULL;
320
321	/*
322	* Check input arguments.
323	*/
324	AssertReturn(!(fFlags & ~RTPROCEXEC_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
325
326	/*
327	* Do we need a standard input bitbucket?
328	*/
329	int rc = VINF_SUCCESS;
330	PRTHANDLE phChildStdIn = NULL;
331	RTHANDLE hChildStdIn;
332	hChildStdIn.enmType = RTHANDLETYPE_FILE;
333	hChildStdIn.u.hFile = NIL_RTFILE;
334	if ((fFlags & RTPROCEXEC_FLAGS_STDIN_NULL) && RT_SUCCESS(rc))
335	{
336	phChildStdIn = &hChildStdIn;
337	rc = RTFileOpenBitBucket(&hChildStdIn.u.hFile, RTFILE_O_READ);
338	}
339
340	/*
341	* Create the output pipes / bitbuckets.
342	*/
343	RTPIPE hPipeStdOutR = NIL_RTPIPE;
344	PRTHANDLE phChildStdOut = NULL;
345	RTHANDLE hChildStdOut;
346	hChildStdOut.enmType = RTHANDLETYPE_PIPE;
347	hChildStdOut.u.hPipe = NIL_RTPIPE;
348	if (ppszStdOut && RT_SUCCESS(rc))
349	{
350	phChildStdOut = &hChildStdOut;
351	rc = RTPipeCreate(&hPipeStdOutR, &hChildStdOut.u.hPipe, 0 /fFlags/);
352	}
353	else if ((fFlags & RTPROCEXEC_FLAGS_STDOUT_NULL) && RT_SUCCESS(rc))
354	{
355	phChildStdOut = &hChildStdOut;
356	hChildStdOut.enmType = RTHANDLETYPE_FILE;
357	hChildStdOut.u.hFile = NIL_RTFILE;
358	rc = RTFileOpenBitBucket(&hChildStdOut.u.hFile, RTFILE_O_WRITE);
359	}
360
361	RTPIPE hPipeStdErrR = NIL_RTPIPE;
362	PRTHANDLE phChildStdErr = NULL;
363	RTHANDLE hChildStdErr;
364	hChildStdErr.enmType = RTHANDLETYPE_PIPE;
365	hChildStdErr.u.hPipe = NIL_RTPIPE;
366	if (ppszStdErr && RT_SUCCESS(rc))
367	{
368	phChildStdErr = &hChildStdErr;
369	rc = RTPipeCreate(&hPipeStdErrR, &hChildStdErr.u.hPipe, 0 /fFlags/);
370	}
371	else if ((fFlags & RTPROCEXEC_FLAGS_STDERR_NULL) && RT_SUCCESS(rc))
372	{
373	phChildStdErr = &hChildStdErr;
374	hChildStdErr.enmType = RTHANDLETYPE_FILE;
375	hChildStdErr.u.hFile = NIL_RTFILE;
376	rc = RTFileOpenBitBucket(&hChildStdErr.u.hFile, RTFILE_O_WRITE);
377	}
378
379	if (RT_SUCCESS(rc))
380	{
381	RTPOLLSET hPollSet;
382	rc = RTPollSetCreate(&hPollSet);
383	if (RT_SUCCESS(rc))
384	{
385	if (hPipeStdOutR != NIL_RTPIPE && RT_SUCCESS(rc))
386	rc = RTPollSetAddPipe(hPollSet, hPipeStdOutR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR, 1);
387	if (hPipeStdErrR != NIL_RTPIPE)
388	rc = RTPollSetAddPipe(hPollSet, hPipeStdErrR, RTPOLL_EVT_READ \| RTPOLL_EVT_ERROR, 2);
389	}
390	if (RT_SUCCESS(rc))
391	{
392	/*
393	* Create the process.
394	*/
395	RTPROCESS hProc;
396	rc = RTProcCreateEx(g_szSvnPath,
397	papszArgs,
398	RTENV_DEFAULT,
399	0 /fFlags/,
400	NULL /phStdIn/,
401	phChildStdOut,
402	phChildStdErr,
403	NULL /pszAsUser/,
404	NULL /pszPassword/,
405	&hProc);
406	rc2 = RTHandleClose(&hChildStdErr); AssertRC(rc2);
407	rc2 = RTHandleClose(&hChildStdOut); AssertRC(rc2);
408
409	if (RT_SUCCESS(rc))
410	{
411	/*
412	* Process output and wait for the process to finish.
413	*/
414	size_t cbStdOut = 0;
415	size_t offStdOut = 0;
416	size_t cbStdErr = 0;
417	size_t offStdErr = 0;
418	for (;;)
419	{
420	if (hPipeStdOutR != NIL_RTPIPE)
421	rc = rtProcProcessOutput(rc, &hPipeStdOutR, &cbStdOut, &offStdOut, ppszStdOut, hPollSet, 1);
422	if (hPipeStdErrR != NIL_RTPIPE)
423	rc = rtProcProcessOutput(rc, &hPipeStdErrR, &cbStdErr, &offStdErr, ppszStdErr, hPollSet, 2);
424	if (hPipeStdOutR == NIL_RTPIPE && hPipeStdErrR == NIL_RTPIPE)
425	break;
426
427	if (hProc != NIL_RTPROCESS)
428	{
429	rc2 = RTProcWait(hProc, RTPROCWAIT_FLAGS_NOBLOCK, pStatus);
430	if (rc2 != VERR_PROCESS_RUNNING)
431	{
432	if (RT_FAILURE(rc2))
433	rc = rc2;
434	hProc = NIL_RTPROCESS;
435	}
436	}
437
438	rc2 = RTPoll(hPollSet, 10000, NULL, NULL);
439	Assert(RT_SUCCESS(rc2) \|\| rc2 == VERR_TIMEOUT);
440	}
441
442	if (RT_SUCCESS(rc))
443	{
444	if ( (ppszStdOut && ppszStdOut && !RTStrIsValidEncoding(ppszStdOut))
445	\|\| (ppszStdErr && ppszStdErr && !RTStrIsValidEncoding(ppszStdErr)) )
446	rc = VERR_NO_TRANSLATION;
447	}
448
449	/*
450	* No more output, just wait for it to finish.
451	*/
452	if (hProc != NIL_RTPROCESS)
453	{
454	rc2 = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, pStatus);
455	if (RT_FAILURE(rc2))
456	rc = rc2;
457	}
458	}
459	RTPollSetDestroy(hPollSet);
460	}
461	}
462
463	rc2 = RTHandleClose(&hChildStdErr); AssertRC(rc2);
464	rc2 = RTHandleClose(&hChildStdOut); AssertRC(rc2);
465	rc2 = RTHandleClose(&hChildStdIn); AssertRC(rc2);
466	rc2 = RTPipeClose(hPipeStdErrR); AssertRC(rc2);
467	rc2 = RTPipeClose(hPipeStdOutR); AssertRC(rc2);
468	return rc;
469	}
470
471
472	/**
473	* Runs a process, waiting for it to complete.
474	*
475	* @returns IPRT status code
476	*
477	* @param pszExec Executable image to use to create the child process.
478	* @param papszArgs Pointer to an array of arguments to the child. The
479	* array terminated by an entry containing NULL.
480	* @param hEnv Handle to the environment block for the child.
481	* @param fFlags A combination of RTPROCEXEC_FLAGS_XXX.
482	* @param pStatus Where to return the status on success.
483	*/
484	int RTProcExec(const char pszExec, const char const *papszArgs, RTENV hEnv, uint32_t fFlags,
485	PRTPROCSTATUS pStatus)
486	{
487	int rc;
488
489	/*
490	* Clear output argument (no returning failure here, simply crash!).
491	*/
492	AssertPtr(pStatus);
493	pStatus->enmReason = RTPROCEXITREASON_ABEND;
494	pStatus->iStatus = RTEXITCODE_FAILURE;
495
496	/*
497	* Check input arguments.
498	*/
499	AssertReturn(!(fFlags & ~RTPROCEXEC_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);
500
501	/*
502	* Set up /dev/null redirections.
503	*/
504	PRTHANDLE aph[3] = { NULL, NULL, NULL };
505	RTHANDLE ah[3];
506	for (uint32_t i = 0; i < 3; i++)
507	{
508	ah[i].enmType = RTHANDLETYPE_FILE;
509	ah[i].u.hFile = NIL_RTFILE;
510	}
511	rc = VINF_SUCCESS;
512	if ((fFlags & RTPROCEXEC_FLAGS_STDIN_NULL) && RT_SUCCESS(rc))
513	{
514	aph[0] = &ah[0];
515	rc = RTFileOpenBitBucket(&ah[0].u.hFile, RTFILE_O_READ);
516	}
517	if ((fFlags & RTPROCEXEC_FLAGS_STDOUT_NULL) && RT_SUCCESS(rc))
518	{
519	aph[1] = &ah[1];
520	rc = RTFileOpenBitBucket(&ah[1].u.hFile, RTFILE_O_WRITE);
521	}
522	if ((fFlags & RTPROCEXEC_FLAGS_STDERR_NULL) && RT_SUCCESS(rc))
523	{
524	aph[2] = &ah[2];
525	rc = RTFileOpenBitBucket(&ah[2].u.hFile, RTFILE_O_WRITE);
526	}
527
528	/*
529	* Create the process.
530	*/
531	RTPROCESS hProc;
532	if (RT_SUCCESS(rc))
533	rc = RTProcCreateEx(g_szSvnPath,
534	papszArgs,
535	RTENV_DEFAULT,
536	0 /fFlags/,
537	aph[0],
538	aph[1],
539	aph[2],
540	NULL /pszAsUser/,
541	NULL /pszPassword/,
542	&hProc);
543
544	for (uint32_t i = 0; i < 3; i++)
545	RTFileClose(ah[i].u.hFile);
546
547	if (RT_SUCCESS(rc))
548	rc = RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, pStatus);
549	return rc;
550	}
551
552
553
554	/**
555	* Executes SVN and gets the output.
556	*
557	* Standard error is suppressed.
558	*
559	* @returns VINF_SUCCESS if the command executed successfully.
560	* @param pState The rewrite state to work on. Can be NULL.
561	* @param papszArgs The SVN argument.
562	* @param fNormalFailureOk Whether normal failure is ok.
563	* @param ppszStdOut Where to return the output on success.
564	*/
565	static int scmSvnRunAndGetOutput(PSCMRWSTATE pState, const char papszArgs, bool fNormalFailureOk, char ppszStdOut)
566	{
567	*ppszStdOut = NULL;
568
569	char *pszCmdLine = NULL;
570	int rc = RTGetOptArgvToString(&pszCmdLine, papszArgs, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
571	if (RT_FAILURE(rc))
572	return rc;
573	ScmVerbose(pState, 2, "executing: %s\n", pszCmdLine);
574
575	RTPROCSTATUS Status;
576	rc = RTProcExecToString(g_szSvnPath, papszArgs, RTENV_DEFAULT,
577	RTPROCEXEC_FLAGS_STD_NULL, &Status, ppszStdOut, NULL);
578
579	if ( RT_SUCCESS(rc)
580	&& ( Status.enmReason != RTPROCEXITREASON_NORMAL
581	\|\| Status.iStatus != 0) )
582	{
583	if (fNormalFailureOk \|\| Status.enmReason != RTPROCEXITREASON_NORMAL)
584	RTMsgError("%s: %s -> %s %u\n",
585	pState->pszFilename, pszCmdLine,
586	Status.enmReason == RTPROCEXITREASON_NORMAL ? "exit code"
587	: Status.enmReason == RTPROCEXITREASON_SIGNAL ? "signal"
588	: Status.enmReason == RTPROCEXITREASON_ABEND ? "abnormal end"
589	: "abducted by alien",
590	Status.iStatus);
591	rc = VERR_GENERAL_FAILURE;
592	}
593	else if (RT_FAILURE(rc))
594	{
595	if (pState)
596	RTMsgError("%s: executing: %s => %Rrc\n", pState->pszFilename, pszCmdLine, rc);
597	else
598	RTMsgError("executing: %s => %Rrc\n", pszCmdLine, rc);
599	}
600
601	if (RT_FAILURE(rc))
602	{
603	RTStrFree(*ppszStdOut);
604	*ppszStdOut = NULL;
605	}
606	RTStrFree(pszCmdLine);
607	return rc;
608	}
609
610
611	/**
612	* Executes SVN.
613	*
614	* Standard error and standard output is suppressed.
615	*
616	* @returns VINF_SUCCESS if the command executed successfully.
617	* @param pState The rewrite state to work on.
618	* @param papszArgs The SVN argument.
619	* @param fNormalFailureOk Whether normal failure is ok.
620	*/
621	static int scmSvnRun(PSCMRWSTATE pState, const char **papszArgs, bool fNormalFailureOk)
622	{
623	char *pszCmdLine = NULL;
624	int rc = RTGetOptArgvToString(&pszCmdLine, papszArgs, RTGETOPTARGV_CNV_QUOTE_BOURNE_SH);
625	if (RT_FAILURE(rc))
626	return rc;
627	ScmVerbose(pState, 2, "executing: %s\n", pszCmdLine);
628
629	/* Lazy bird uses RTProcExecToString. */
630	RTPROCSTATUS Status;
631	rc = RTProcExec(g_szSvnPath, papszArgs, RTENV_DEFAULT, RTPROCEXEC_FLAGS_STD_NULL, &Status);
632
633	if ( RT_SUCCESS(rc)
634	&& ( Status.enmReason != RTPROCEXITREASON_NORMAL
635	\|\| Status.iStatus != 0) )
636	{
637	if (fNormalFailureOk \|\| Status.enmReason != RTPROCEXITREASON_NORMAL)
638	RTMsgError("%s: %s -> %s %u\n",
639	pState->pszFilename,
640	pszCmdLine,
641	Status.enmReason == RTPROCEXITREASON_NORMAL ? "exit code"
642	: Status.enmReason == RTPROCEXITREASON_SIGNAL ? "signal"
643	: Status.enmReason == RTPROCEXITREASON_ABEND ? "abnormal end"
644	: "abducted by alien",
645	Status.iStatus);
646	rc = VERR_GENERAL_FAILURE;
647	}
648	else if (RT_FAILURE(rc))
649	RTMsgError("%s: %s -> %Rrc\n", pState->pszFilename, pszCmdLine, rc);
650
651	RTStrFree(pszCmdLine);
652	return rc;
653	}
654
655
656	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
657	/**
658	* Attempts to resolve the necessary subversion and apache portable runtime APIs
659	* we require dynamically.
660	*
661	* Will set all global function pointers and g_fSvnFunctionPointersValid to true
662	* on success.
663	*/
664	static void scmSvnTryResolveFunctions(void)
665	{
666	char szPath[RTPATH_MAX];
667	int rc = RTStrCopy(szPath, sizeof(szPath), g_szSvnPath);
668	if (RT_SUCCESS(rc))
669	{
670	RTPathStripFilename(szPath);
671	char *pszEndPath = strchr(szPath, '\0');
672	# ifdef RT_OS_WINDOWS
673	RTPathChangeToDosSlashes(szPath, false);
674	# endif
675
676	/*
677	* Try various prefixes/suffxies/locations.
678	*/
679	static struct
680	{
681	const char *pszPrefix;
682	const char *pszSuffix;
683	} const s_aVariations[] =
684	{
685	# ifdef RT_OS_WINDOWS
686	{ "SlikSvn-lib", "-1.dll" }, /* SlikSVN */
687	{ "lib", "-1.dll" }, /* Win32Svn,CollabNet,++ */
688	# elif defined(RT_OS_DARWIN)
689	{ "../lib/lib", "-1.dylib" },
690	# else
691	{ "../lib/lib", ".so" },
692	{ "../lib/lib", "-1.so" },
693	# endif
694	};
695	for (unsigned iVar = 0; RT_ELEMENTS(s_aVariations); iVar++)
696	{
697	/*
698	* Try load the svn_client library ...
699	*/
700	static const char * const s_apszLibraries[] = { "svn_client", "svn_subr", "apr" };
701	RTLDRMOD ahMods[RT_ELEMENTS(s_apszLibraries)] = { NIL_RTLDRMOD, NIL_RTLDRMOD, NIL_RTLDRMOD };
702
703	rc = VINF_SUCCESS;
704	unsigned iLib;
705	for (iLib = 0; iLib < RT_ELEMENTS(s_apszLibraries) && RT_SUCCESS(rc); iLib++)
706	{
707	*pszEndPath = '\0';
708	rc = RTPathAppend(szPath, sizeof(szPath), s_aVariations[iVar].pszPrefix);
709	if (RT_SUCCESS(rc))
710	rc = RTStrCat(szPath, sizeof(szPath), s_apszLibraries[iLib]);
711	if (RT_SUCCESS(rc))
712	rc = RTStrCat(szPath, sizeof(szPath), s_aVariations[iVar].pszSuffix);
713	if (RT_SUCCESS(rc))
714	{
715	# ifdef RT_OS_WINDOWS
716	RTPathChangeToDosSlashes(pszEndPath, false);
717	# endif
718	rc = RTLdrLoadEx(szPath, &ahMods[iLib], RTLDRLOAD_FLAGS_NT_SEARCH_DLL_LOAD_DIR , NULL);
719	}
720	}
721	if (iLib == RT_ELEMENTS(s_apszLibraries) && RT_SUCCESS(rc))
722	{
723	static const struct
724	{
725	unsigned iLib;
726	const char *pszSymbol;
727	PFNRT *ppfn;
728	} s_aSymbols[] =
729	{
730	{ 2, "apr_initialize", (PFNRT *)&g_pfnAprInitialize },
731	{ 2, "apr_hash_first", (PFNRT *)&g_pfnAprHashFirst },
732	{ 2, "apr_hash_next", (PFNRT *)&g_pfnAprHashNext },
733	{ 2, "apr_hash_this_val", (PFNRT *)&g_pfnAprHashThisVal },
734	{ 1, "svn_pool_create_ex", (PFNRT *)&g_pfnSvnPoolCreateEx },
735	{ 2, "apr_pool_clear", (PFNRT *)&g_pfnAprPoolClear },
736	{ 2, "apr_pool_destroy", (PFNRT *)&g_pfnAprPoolDestroy },
737	{ 0, "svn_client_create_context", (PFNRT *)&g_pfnSvnClientCreateContext },
738	{ 0, "svn_client_propget4", (PFNRT *)&g_pfnSvnClientPropGet4 },
739	};
740	for (unsigned i = 0; i < RT_ELEMENTS(s_aSymbols); i++)
741	{
742	rc = RTLdrGetSymbol(ahMods[s_aSymbols[i].iLib], s_aSymbols[i].pszSymbol,
743	(void **)(uintptr_t)s_aSymbols[i].ppfn);
744	if (RT_FAILURE(rc))
745	{
746	ScmVerbose(NULL, 0, "Failed to resolve '%s' in '%s'",
747	s_aSymbols[i].pszSymbol, s_apszLibraries[s_aSymbols[i].iLib]);
748	break;
749	}
750	}
751	if (RT_SUCCESS(rc))
752	{
753	apr_status_t rcApr = g_pfnAprInitialize();
754	if (rcApr == 0)
755	{
756	ScmVerbose(NULL, 1, "Found subversion APIs.\n");
757	g_fSvnFunctionPointersValid = true;
758	}
759	else
760	{
761	ScmVerbose(NULL, 0, "apr_initialize failed: %#x (%d)\n", rcApr, rcApr);
762	AssertMsgFailed(("%#x (%d)\n", rc, rc));
763	}
764	return;
765	}
766	}
767
768	while (iLib-- > 0)
769	RTLdrClose(ahMods[iLib]);
770	}
771	}
772	}
773	#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
774
775
776	/**
777	* Finds the svn binary, updating g_szSvnPath and g_enmSvnVersion.
778	*/
779	static void scmSvnFindSvnBinary(PSCMRWSTATE pState)
780	{
781	/* Already been called? */
782	if (g_szSvnPath[0] != '\0')
783	return;
784
785	/*
786	* Locate it.
787	*/
788	/** @todo code page fun... */
789	#ifdef RT_OS_WINDOWS
790	const char *pszEnvVar = RTEnvGet("Path");
791	#else
792	const char *pszEnvVar = RTEnvGet("PATH");
793	#endif
794	if (pszEnvVar)
795	{
796	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
797	int rc = RTPathTraverseList(pszEnvVar, ';', scmSvnFindSvnBinaryCallback, g_szSvnPath, (void *)sizeof(g_szSvnPath));
798	#else
799	int rc = RTPathTraverseList(pszEnvVar, ':', scmSvnFindSvnBinaryCallback, g_szSvnPath, (void *)sizeof(g_szSvnPath));
800	#endif
801	if (RT_FAILURE(rc))
802	strcpy(g_szSvnPath, "svn");
803	}
804	else
805	strcpy(g_szSvnPath, "svn");
806
807	/*
808	* Check the version.
809	*/
810	const char *apszArgs[] = { g_szSvnPath, "--version", "--quiet", NULL };
811	char *pszVersion;
812	int rc = scmSvnRunAndGetOutput(pState, apszArgs, false, &pszVersion);
813	if (RT_SUCCESS(rc))
814	{
815	char *pszStripped = RTStrStrip(pszVersion);
816	if (RTStrVersionCompare(pszVersion, "1.8") >= 0)
817	g_enmSvnVersion = kScmSvnVersion_1_8;
818	else if (RTStrVersionCompare(pszVersion, "1.7") >= 0)
819	g_enmSvnVersion = kScmSvnVersion_1_7;
820	else if (RTStrVersionCompare(pszVersion, "1.6") >= 0)
821	g_enmSvnVersion = kScmSvnVersion_1_6;
822	else
823	g_enmSvnVersion = kScmSvnVersion_Ancient;
824	RTStrFree(pszVersion);
825	}
826	else
827	g_enmSvnVersion = kScmSvnVersion_Ancient;
828
829	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
830	/*
831	* If we got version 1.8 or later, try see if we can locate a few of the
832	* simpler SVN APIs.
833	*/
834	g_fSvnFunctionPointersValid = false;
835	if (g_enmSvnVersion >= kScmSvnVersion_1_8)
836	scmSvnTryResolveFunctions();
837	#endif
838	}
839
840
841	/**
842	* Construct a dot svn filename for the file being rewritten.
843	*
844	* @returns IPRT status code.
845	* @param pState The rewrite state (for the name).
846	* @param pszDir The directory, including ".svn/".
847	* @param pszSuff The filename suffix.
848	* @param pszDst The output buffer. RTPATH_MAX in size.
849	*/
850	static int scmSvnConstructName(PSCMRWSTATE pState, const char pszDir, const char pszSuff, char *pszDst)
851	{
852	strcpy(pszDst, pState->pszFilename); /* ASSUMES sizeof(szBuf) <= sizeof(szPath) */
853	RTPathStripFilename(pszDst);
854
855	int rc = RTPathAppend(pszDst, RTPATH_MAX, pszDir);
856	if (RT_SUCCESS(rc))
857	{
858	rc = RTPathAppend(pszDst, RTPATH_MAX, RTPathFilename(pState->pszFilename));
859	if (RT_SUCCESS(rc))
860	{
861	size_t cchDst = strlen(pszDst);
862	size_t cchSuff = strlen(pszSuff);
863	if (cchDst + cchSuff < RTPATH_MAX)
864	{
865	memcpy(&pszDst[cchDst], pszSuff, cchSuff + 1);
866	return VINF_SUCCESS;
867	}
868	else
869	rc = VERR_BUFFER_OVERFLOW;
870	}
871	}
872	return rc;
873	}
874
875	/**
876	* Interprets the specified string as decimal numbers.
877	*
878	* @returns true if parsed successfully, false if not.
879	* @param pch The string (not terminated).
880	* @param cch The string length.
881	* @param pu Where to return the value.
882	*/
883	static bool scmSvnReadNumber(const char pch, size_t cch, size_t pu)
884	{
885	size_t u = 0;
886	while (cch-- > 0)
887	{
888	char ch = *pch++;
889	if (ch < '0' \|\| ch > '9')
890	return false;
891	u *= 10;
892	u += ch - '0';
893	}
894	*pu = u;
895	return true;
896	}
897
898
899	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
900
901	/**
902	* Wrapper around RTPathAbs.
903	* @returns Same as RTPathAbs.
904	* @param pszPath The relative path.
905	* @param pszAbsPath Where to return the absolute path.
906	* @param cbAbsPath Size of the @a pszAbsPath buffer.
907	*/
908	static int scmSvnAbsPath(const char pszPath, char pszAbsPath, size_t cbAbsPath)
909	{
910	int rc = RTPathAbs(pszPath, pszAbsPath, cbAbsPath);
911	# if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
912	if (RT_SUCCESS(rc))
913	RTPathChangeToUnixSlashes(pszAbsPath, true /fForce/);
914	# endif
915	return rc;
916	}
917
918
919	/**
920	* Checks if @a pszPath exists in the current WC.
921	*
922	* @returns true, false or -1. In the latter case, please use the fallback.
923	* @param pszPath Path to the object that should be investigated.
924	*/
925	static int scmSvnIsObjectInWorkingCopy(const char *pszPath)
926	{
927	int rc = -1;
928
929	/* svn_client_propget4 and later requires absolute target path. */
930	char szAbsPath[RTPATH_MAX];
931	int rc2 = scmSvnAbsPath(pszPath, szAbsPath, sizeof(szAbsPath));
932	if (RT_SUCCESS(rc2))
933	{
934	/* Create calling context. */
935	apr_pool_t *pPool = g_pfnSvnPoolCreateEx(NULL, NULL);
936	if (pPool)
937	{
938	svn_client_ctx_t *pCtx = NULL;
939	svn_error_t *pErr = g_pfnSvnClientCreateContext(&pCtx, pPool);
940	if (!pErr)
941	{
942	/* Make the call. */
943	apr_hash_t *pHash = NULL;
944	svn_opt_revision_t Rev;
945	RT_ZERO(Rev);
946	Rev.kind = svn_opt_revision_base;
947	Rev.value.number = -1L;
948	pErr = g_pfnSvnClientPropGet4(&pHash, "svn:no-such-property", szAbsPath, &Rev, &Rev,
949	NULL /pActualRev/, svn_depth_empty, NULL /pChangeList/, pCtx, pPool, pPool);
950	if (!pErr)
951	rc = true;
952	else if (pErr->apr_err == SVN_ERR_UNVERSIONED_RESOURCE)
953	rc = false;
954	}
955	g_pfnAprPoolDestroy(pPool);
956	}
957	}
958	return rc;
959	}
960
961	#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
962
963
964	/**
965	* Checks if the file we're operating on is part of a SVN working copy.
966	*
967	* @returns true if it is, false if it isn't or we cannot tell.
968	* @param pState The rewrite state to work on.
969	*/
970	bool ScmSvnIsInWorkingCopy(PSCMRWSTATE pState)
971	{
972	scmSvnFindSvnBinary(pState);
973
974	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
975	if (g_fSvnFunctionPointersValid)
976	{
977	int rc = scmSvnIsObjectInWorkingCopy(pState->pszFilename);
978	if (rc == (int)true \|\| rc == (int)false)
979	return rc == (int)true;
980	}
981
982	/* Fallback: */
983	#endif
984	if (g_enmSvnVersion < kScmSvnVersion_1_7)
985	{
986	/*
987	* Hack: check if the .svn/text-base/<file>.svn-base file exists.
988	*/
989	char szPath[RTPATH_MAX];
990	int rc = scmSvnConstructName(pState, ".svn/text-base/", ".svn-base", szPath);
991	if (RT_SUCCESS(rc))
992	return RTFileExists(szPath);
993	}
994	else
995	{
996	const char *apszArgs[] = { g_szSvnPath, "propget", "svn:no-such-property", pState->pszFilename, NULL };
997	char *pszValue;
998	int rc = scmSvnRunAndGetOutput(pState, apszArgs, true, &pszValue);
999	if (RT_SUCCESS(rc))
1000	{
1001	RTStrFree(pszValue);
1002	return true;
1003	}
1004	}
1005	return false;
1006	}
1007
1008
1009	/**
1010	* Checks if the specified directory is part of a SVN working copy.
1011	*
1012	* @returns true if it is, false if it isn't or we cannot tell.
1013	* @param pszDir The directory in question.
1014	*/
1015	bool ScmSvnIsDirInWorkingCopy(const char *pszDir)
1016	{
1017	scmSvnFindSvnBinary(NULL);
1018
1019	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1020	if (g_fSvnFunctionPointersValid)
1021	{
1022	int rc = scmSvnIsObjectInWorkingCopy(pszDir);
1023	if (rc == (int)true \|\| rc == (int)false)
1024	return rc == (int)true;
1025	}
1026
1027	/* Fallback: */
1028	#endif
1029	if (g_enmSvnVersion < kScmSvnVersion_1_7)
1030	{
1031	/*
1032	* Hack: check if the .svn/ dir exists.
1033	*/
1034	char szPath[RTPATH_MAX];
1035	int rc = RTPathJoin(szPath, sizeof(szPath), pszDir, ".svn");
1036	if (RT_SUCCESS(rc))
1037	return RTDirExists(szPath);
1038	}
1039	else
1040	{
1041	const char *apszArgs[] = { g_szSvnPath, "propget", "svn:no-such-property", pszDir, NULL };
1042	char *pszValue;
1043	int rc = scmSvnRunAndGetOutput(NULL, apszArgs, true, &pszValue);
1044	if (RT_SUCCESS(rc))
1045	{
1046	RTStrFree(pszValue);
1047	return true;
1048	}
1049	}
1050	return false;
1051	}
1052
1053
1054	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1055	/**
1056	* Checks if @a pszPath exists in the current WC.
1057	*
1058	* @returns IPRT status code - VERR_NOT_SUPPORT if fallback should be attempted.
1059	* @param pszPath Path to the object that should be investigated.
1060	* @param pszProperty The property name.
1061	* @param ppszValue Where to return the property value. Optional.
1062	*/
1063	static int scmSvnQueryPropertyUsingApi(const char pszPath, const char pszProperty, char **ppszValue)
1064	{
1065	int rc = VERR_NOT_SUPPORTED;
1066
1067	/* svn_client_propget4 and later requires absolute target path. */
1068	char szAbsPath[RTPATH_MAX];
1069	int rc2 = scmSvnAbsPath(pszPath, szAbsPath, sizeof(szAbsPath));
1070	if (RT_SUCCESS(rc2))
1071	{
1072	/* Create calling context. */
1073	apr_pool_t *pPool = g_pfnSvnPoolCreateEx(NULL, NULL);
1074	if (pPool)
1075	{
1076	svn_client_ctx_t *pCtx = NULL;
1077	svn_error_t *pErr = g_pfnSvnClientCreateContext(&pCtx, pPool);
1078	if (!pErr)
1079	{
1080	/* Make the call. */
1081	apr_hash_t *pHash = NULL;
1082	svn_opt_revision_t Rev;
1083	RT_ZERO(Rev);
1084	Rev.kind = svn_opt_revision_base;
1085	Rev.value.number = -1L;
1086	pErr = g_pfnSvnClientPropGet4(&pHash, pszProperty, szAbsPath, &Rev, &Rev,
1087	NULL /pActualRev/, svn_depth_empty, NULL /pChangeList/, pCtx, pPool, pPool);
1088	if (!pErr)
1089	{
1090	/* Get the first value, if any. */
1091	rc = VERR_NOT_FOUND;
1092	apr_hash_index_t *pHashIdx = g_pfnAprHashFirst(pPool, pHash);
1093	if (pHashIdx)
1094	{
1095	const char ppszFirst = (const char )g_pfnAprHashThisVal(pHashIdx);
1096	if (ppszFirst && *ppszFirst)
1097	{
1098	if (ppszValue)
1099	rc = RTStrDupEx(ppszValue, *ppszFirst);
1100	else
1101	rc = VINF_SUCCESS;
1102	}
1103	}
1104	}
1105	else if (pErr->apr_err == SVN_ERR_UNVERSIONED_RESOURCE)
1106	rc = VERR_INVALID_STATE;
1107	else
1108	rc = VERR_GENERAL_FAILURE;
1109	}
1110	g_pfnAprPoolDestroy(pPool);
1111	}
1112	}
1113	return rc;
1114	}
1115	#endif /* SCM_WITH_DYNAMIC_LIB_SVN */
1116
1117
1118	/**
1119	* Queries the value of an SVN property.
1120	*
1121	* This will automatically adjust for scheduled changes.
1122	*
1123	* @returns IPRT status code.
1124	* @retval VERR_INVALID_STATE if not a SVN WC file.
1125	* @retval VERR_NOT_FOUND if the property wasn't found.
1126	* @param pState The rewrite state to work on.
1127	* @param pszName The property name.
1128	* @param ppszValue Where to return the property value. Free this
1129	* using RTStrFree. Optional.
1130	*/
1131	int ScmSvnQueryProperty(PSCMRWSTATE pState, const char pszName, char *ppszValue)
1132	{
1133	int rc;
1134
1135	/*
1136	* Look it up in the scheduled changes.
1137	*/
1138	size_t i = pState->cSvnPropChanges;
1139	while (i-- > 0)
1140	if (!strcmp(pState->paSvnPropChanges[i].pszName, pszName))
1141	{
1142	const char *pszValue = pState->paSvnPropChanges[i].pszValue;
1143	if (!pszValue)
1144	return VERR_NOT_FOUND;
1145	if (ppszValue)
1146	return RTStrDupEx(ppszValue, pszValue);
1147	return VINF_SUCCESS;
1148	}
1149
1150	scmSvnFindSvnBinary(pState);
1151
1152	#ifdef SCM_WITH_DYNAMIC_LIB_SVN
1153	if (g_fSvnFunctionPointersValid)
1154	{
1155	rc = scmSvnQueryPropertyUsingApi(pState->pszFilename, pszName, ppszValue);
1156	if (rc != VERR_NOT_SUPPORTED)
1157	return rc;
1158	/* Fallback: */
1159	}
1160	#endif
1161
1162	if (g_enmSvnVersion < kScmSvnVersion_1_7)
1163	{
1164	/*
1165	* Hack: Read the .svn/props/<file>.svn-work file exists.
1166	*/
1167	char szPath[RTPATH_MAX];
1168	rc = scmSvnConstructName(pState, ".svn/props/", ".svn-work", szPath);
1169	if (RT_SUCCESS(rc) && !RTFileExists(szPath))
1170	rc = scmSvnConstructName(pState, ".svn/prop-base/", ".svn-base", szPath);
1171	if (RT_SUCCESS(rc))
1172	{
1173	SCMSTREAM Stream;
1174	rc = ScmStreamInitForReading(&Stream, szPath);
1175	if (RT_SUCCESS(rc))
1176	{
1177	/*
1178	* The current format is K len\n<name>\nV len\n<value>\n" ... END.
1179	*/
1180	rc = VERR_NOT_FOUND;
1181	size_t const cchName = strlen(pszName);
1182	SCMEOL enmEol;
1183	size_t cchLine;
1184	const char *pchLine;
1185	while ((pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol)) != NULL)
1186	{
1187	/*
1188	* Parse the 'K num' / 'END' line.
1189	*/
1190	if ( cchLine == 3
1191	&& !memcmp(pchLine, "END", 3))
1192	break;
1193	size_t cchKey;
1194	if ( cchLine < 3
1195	\|\| pchLine[0] != 'K'
1196	\|\| pchLine[1] != ' '
1197	\|\| !scmSvnReadNumber(&pchLine[2], cchLine - 2, &cchKey)
1198	\|\| cchKey == 0
1199	\|\| cchKey > 4096)
1200	{
1201	RTMsgError("%s:%u: Unexpected data '%.*s'\n", szPath, ScmStreamTellLine(&Stream), cchLine, pchLine);
1202	rc = VERR_PARSE_ERROR;
1203	break;
1204	}
1205
1206	/*
1207	* Match the key and skip to the value line. Don't bother with
1208	* names containing EOL markers.
1209	*/
1210	size_t const offKey = ScmStreamTell(&Stream);
1211	bool fMatch = cchName == cchKey;
1212	if (fMatch)
1213	{
1214	pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol);
1215	if (!pchLine)
1216	break;
1217	fMatch = cchLine == cchName
1218	&& !memcmp(pchLine, pszName, cchName);
1219	}
1220
1221	if (RT_FAILURE(ScmStreamSeekAbsolute(&Stream, offKey + cchKey)))
1222	break;
1223	if (RT_FAILURE(ScmStreamSeekByLine(&Stream, ScmStreamTellLine(&Stream) + 1)))
1224	break;
1225
1226	/*
1227	* Read and Parse the 'V num' line.
1228	*/
1229	pchLine = ScmStreamGetLine(&Stream, &cchLine, &enmEol);
1230	if (!pchLine)
1231	break;
1232	size_t cchValue;
1233	if ( cchLine < 3
1234	\|\| pchLine[0] != 'V'
1235	\|\| pchLine[1] != ' '
1236	\|\| !scmSvnReadNumber(&pchLine[2], cchLine - 2, &cchValue)
1237	\|\| cchValue > _1M)
1238	{
1239	RTMsgError("%s:%u: Unexpected data '%.*s'\n", szPath, ScmStreamTellLine(&Stream), cchLine, pchLine);
1240	rc = VERR_PARSE_ERROR;
1241	break;
1242	}
1243
1244	/*
1245	* If we have a match, allocate a return buffer and read the
1246	* value into it. Otherwise skip this value and continue
1247	* searching.
1248	*/
1249	if (fMatch)
1250	{
1251	if (!ppszValue)
1252	rc = VINF_SUCCESS;
1253	else
1254	{
1255	char *pszValue;
1256	rc = RTStrAllocEx(&pszValue, cchValue + 1);
1257	if (RT_SUCCESS(rc))
1258	{
1259	rc = ScmStreamRead(&Stream, pszValue, cchValue);
1260	if (RT_SUCCESS(rc))
1261	*ppszValue = pszValue;
1262	else
1263	RTStrFree(pszValue);
1264	}
1265	}
1266	break;
1267	}
1268
1269	if (RT_FAILURE(ScmStreamSeekRelative(&Stream, cchValue)))
1270	break;
1271	if (RT_FAILURE(ScmStreamSeekByLine(&Stream, ScmStreamTellLine(&Stream) + 1)))
1272	break;
1273	}
1274
1275	if (RT_FAILURE(ScmStreamGetStatus(&Stream)))
1276	{
1277	rc = ScmStreamGetStatus(&Stream);
1278	RTMsgError("%s: stream error %Rrc\n", szPath, rc);
1279	}
1280	ScmStreamDelete(&Stream);
1281	}
1282	}
1283
1284	if (rc == VERR_FILE_NOT_FOUND)
1285	rc = VERR_NOT_FOUND;
1286	}
1287	else
1288	{
1289	const char *apszArgs[] = { g_szSvnPath, "propget", "--strict", pszName, pState->pszFilename, NULL };
1290	char *pszValue;
1291	rc = scmSvnRunAndGetOutput(pState, apszArgs, false, &pszValue);
1292	if (RT_SUCCESS(rc))
1293	{
1294	if (pszValue && *pszValue)
1295	{
1296	if (ppszValue)
1297	{
1298	*ppszValue = pszValue;
1299	pszValue = NULL;
1300	}
1301	}
1302	else
1303	rc = VERR_NOT_FOUND;
1304	RTStrFree(pszValue);
1305	}
1306	}
1307	return rc;
1308	}
1309
1310
1311	/**
1312	* Schedules the setting of a property.
1313	*
1314	* @returns IPRT status code.
1315	* @retval VERR_INVALID_STATE if not a SVN WC file.
1316	* @param pState The rewrite state to work on.
1317	* @param pszName The name of the property to set.
1318	* @param pszValue The value. NULL means deleting it.
1319	*/
1320	int ScmSvnSetProperty(PSCMRWSTATE pState, const char pszName, const char pszValue)
1321	{
1322	/*
1323	* Update any existing entry first.
1324	*/
1325	size_t i = pState->cSvnPropChanges;
1326	while (i-- > 0)
1327	if (!strcmp(pState->paSvnPropChanges[i].pszName, pszName))
1328	{
1329	if (!pszValue)
1330	{
1331	RTStrFree(pState->paSvnPropChanges[i].pszValue);
1332	pState->paSvnPropChanges[i].pszValue = NULL;
1333	}
1334	else
1335	{
1336	char *pszCopy;
1337	int rc = RTStrDupEx(&pszCopy, pszValue);
1338	if (RT_FAILURE(rc))
1339	return rc;
1340	pState->paSvnPropChanges[i].pszValue = pszCopy;
1341	}
1342	return VINF_SUCCESS;
1343	}
1344
1345	/*
1346	* Insert a new entry.
1347	*/
1348	i = pState->cSvnPropChanges;
1349	if ((i % 32) == 0)
1350	{
1351	void pvNew = RTMemRealloc(pState->paSvnPropChanges, (i + 32) sizeof(SCMSVNPROP));
1352	if (!pvNew)
1353	return VERR_NO_MEMORY;
1354	pState->paSvnPropChanges = (PSCMSVNPROP)pvNew;
1355	}
1356
1357	pState->paSvnPropChanges[i].pszName = RTStrDup(pszName);
1358	pState->paSvnPropChanges[i].pszValue = pszValue ? RTStrDup(pszValue) : NULL;
1359	if ( pState->paSvnPropChanges[i].pszName
1360	&& (pState->paSvnPropChanges[i].pszValue \|\| !pszValue) )
1361	pState->cSvnPropChanges = i + 1;
1362	else
1363	{
1364	RTStrFree(pState->paSvnPropChanges[i].pszName);
1365	pState->paSvnPropChanges[i].pszName = NULL;
1366	RTStrFree(pState->paSvnPropChanges[i].pszValue);
1367	pState->paSvnPropChanges[i].pszValue = NULL;
1368	return VERR_NO_MEMORY;
1369	}
1370	return VINF_SUCCESS;
1371	}
1372
1373
1374	/**
1375	* Schedules a property deletion.
1376	*
1377	* @returns IPRT status code.
1378	* @param pState The rewrite state to work on.
1379	* @param pszName The name of the property to delete.
1380	*/
1381	int ScmSvnDelProperty(PSCMRWSTATE pState, const char *pszName)
1382	{
1383	return ScmSvnSetProperty(pState, pszName, NULL);
1384	}
1385
1386
1387	/**
1388	* Applies any SVN property changes to the work copy of the file.
1389	*
1390	* @returns IPRT status code.
1391	* @param pState The rewrite state which SVN property changes
1392	* should be applied.
1393	*/
1394	int ScmSvnDisplayChanges(PSCMRWSTATE pState)
1395	{
1396	size_t i = pState->cSvnPropChanges;
1397	while (i-- > 0)
1398	{
1399	const char *pszName = pState->paSvnPropChanges[i].pszName;
1400	const char *pszValue = pState->paSvnPropChanges[i].pszValue;
1401	if (pszValue)
1402	ScmVerbose(pState, 0, "svn propset '%s' '%s' %s\n", pszName, pszValue, pState->pszFilename);
1403	else
1404	ScmVerbose(pState, 0, "svn propdel '%s' %s\n", pszName, pState->pszFilename);
1405	}
1406
1407	return VINF_SUCCESS;
1408	}
1409
1410	/**
1411	* Applies any SVN property changes to the work copy of the file.
1412	*
1413	* @returns IPRT status code.
1414	* @param pState The rewrite state which SVN property changes
1415	* should be applied.
1416	*/
1417	int ScmSvnApplyChanges(PSCMRWSTATE pState)
1418	{
1419	scmSvnFindSvnBinary(pState);
1420
1421	#ifdef SCM_WITH_LATER
1422	if (0)
1423	{
1424	return ...;
1425	}
1426
1427	/* Fallback: */
1428	#endif
1429
1430	/*
1431	* Iterate thru the changes and apply them by starting the svn client.
1432	*/
1433	for (size_t i = 0; i < pState->cSvnPropChanges; i++)
1434	{
1435	const char *apszArgv[6];
1436	apszArgv[0] = g_szSvnPath;
1437	apszArgv[1] = pState->paSvnPropChanges[i].pszValue ? "propset" : "propdel";
1438	apszArgv[2] = pState->paSvnPropChanges[i].pszName;
1439	int iArg = 3;
1440	if (pState->paSvnPropChanges[i].pszValue)
1441	apszArgv[iArg++] = pState->paSvnPropChanges[i].pszValue;
1442	apszArgv[iArg++] = pState->pszFilename;
1443	apszArgv[iArg++] = NULL;
1444
1445	int rc = scmSvnRun(pState, apszArgv, false);
1446	if (RT_FAILURE(rc))
1447	return rc;
1448	}
1449
1450	return VINF_SUCCESS;
1451	}
1452

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

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

Download in other formats: