VirtualBox

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

Last change on this file was 106061, checked in by vboxsync, 4 weeks ago

Copyright year updates by scm.

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette