/* fonction callback pour l'appel a svn_client_list2 */
svn_error_t *list_callback(void *baton,
const char *path,
const svn_dirent_t *dirent,
const svn_lock_t *lock,
const char *abs_path,
apr_pool_t *subpool)
{
if (strcmp(path,"") == 0) {
svn_error_t *err = svn_error_create(1,NULL,"Wrong node kind");
if (dirent->kind != svn_node_dir)
return err;
return SVN_NO_ERROR;
}
svn_stringbuf_t *temp = NULL;
if (dirent->kind == svn_node_dir){
const svn_stringbuf_t *slash = svn_stringbuf_create("/",subpool);
svn_stringbuf_t *dir_format = svn_stringbuf_create(path,subpool);
svn_stringbuf_appendstr(dir_format,slash);
temp = stringbuf_endline_utf8(dir_format->data,subpool);
}
else
temp = stringbuf_endline_utf8(path,subpool);
svn_stringbuf_t *author = stringbuf_endline_utf8(dirent->last_author,subpool);
char *rev = apr_psprintf(subpool,"%d\n",(int)dirent->created_rev);
svn_stringbuf_t *revbuf = stringbuf_endline_utf8(rev,subpool);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton, (const svn_stringbuf_t *)temp);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)author);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)revbuf);
return SVN_NO_ERROR;
}
/* Set *HANDLE to an open filehandle for a temporary file (i.e.,
automatically deleted when closed), into which the LOCK_TOKENS have
been written out in the format described in the pre-commit hook
template.
LOCK_TOKENS is as returned by svn_fs__access_get_lock_tokens().
Allocate *HANDLE in POOL, and use POOL for temporary allocations. */
static svn_error_t *
lock_token_content(apr_file_t **handle, apr_hash_t *lock_tokens,
apr_pool_t *pool)
{
svn_stringbuf_t *lock_str = svn_stringbuf_create("LOCK-TOKENS:\n", pool);
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, lock_tokens); hi;
hi = apr_hash_next(hi))
{
void *val;
const char *path, *token;
apr_hash_this(hi, (void *)&token, NULL, &val);
path = val;
svn_stringbuf_appendstr(lock_str,
svn_stringbuf_createf(pool, "%s|%s\n",
svn_path_uri_autoescape(path, pool),
token));
}
svn_stringbuf_appendcstr(lock_str, "\n");
return create_temp_file(handle,
svn_stringbuf__morph_into_string(lock_str), pool);
}
static svn_error_t *
test3(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
char *tmp;
size_t old_len;
*msg = "append svn_stringbuf_t to svn_stringbuf_t";
if (msg_only)
return SVN_NO_ERROR;
a = svn_stringbuf_create(phrase_1, pool);
b = svn_stringbuf_ncreate(phrase_2, 16, pool);
tmp = apr_palloc(pool, (a->len + b->len + 1));
strcpy(tmp, a->data);
strcat(tmp, b->data);
old_len = a->len;
svn_stringbuf_appendstr(a, b);
/* Test that length, data, and null-termination are correct. */
if ((a->len == (old_len + b->len)) && ((strcmp(a->data, tmp)) == 0))
return SVN_NO_ERROR;
else
return fail(pool, "test failed");
}
/* fonction faite pour récuperer un unique objet info et le stocker dans baton */
svn_error_t* svn_info_callback(void *baton, const char *path,
const svn_info_t *info, apr_pool_t *pool)
{
char *rev = apr_psprintf(pool,"%d\n",(int)info->last_changed_rev);
svn_stringbuf_t *res = svn_stringbuf_create(rev,pool);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)res);
return SVN_NO_ERROR;
}
/* création d'un stringbuf dont la chaine se termine par un "\n" */
svn_stringbuf_t *stringbuf_endline_utf8(const char *string,apr_pool_t *subpool)
{
const svn_stringbuf_t *endline = svn_stringbuf_create("\n",subpool);
svn_stringbuf_t *res_utf8,*res = svn_stringbuf_create(string,subpool);
svn_stringbuf_appendstr(res,endline);
svn_utf_stringbuf_to_utf8(&res_utf8,res,subpool);
return res_utf8;
}
svn_error_t* blame_callback(void *baton, apr_int64_t line_no,
svn_revnum_t revision, const char *author,
const char *date, svn_revnum_t merged_revision,
const char *merged_author, const char *merged_date,
const char *merged_path, const char *line,
apr_pool_t *pool){
svn_stringbuf_t *aut = stringbuf_endline_utf8(author,pool);
svn_stringbuf_t *contents;
if (strcmp(line,"") == 0) {
contents = stringbuf_endline_utf8(" ",pool);
}
else
contents = stringbuf_endline_utf8(line,pool);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)aut);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)contents);
return SVN_NO_ERROR;
}
static svn_error_t *
test10(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
svn_stringbuf_t *s, *t;
size_t len_1 = 0;
size_t len_2 = 0;
size_t block_len_1 = 0;
size_t block_len_2 = 0;
*msg = "block initialization and growth";
if (msg_only)
return SVN_NO_ERROR;
s = svn_stringbuf_create("a small string", pool);
len_1 = (s->len);
block_len_1 = (s->blocksize);
t = svn_stringbuf_create(", plus a string more than twice as long", pool);
svn_stringbuf_appendstr(s, t);
len_2 = (s->len);
block_len_2 = (s->blocksize);
/* Test that:
* - The initial block was just the right fit.
* - The block more than doubled (because second string so long).
* - The block grew by a power of 2.
*/
if ((len_1 == (block_len_1 - 1))
&& ((block_len_2 / block_len_1) > 2)
&& (((block_len_2 / block_len_1) % 2) == 0))
return SVN_NO_ERROR;
else
return fail(pool, "test failed");
}
/* Implements svn_ra_neon__endelm_cb_t . */
static svn_error_t *
end_207_element(void *baton, int state,
const char *nspace, const char *name)
{
multistatus_baton_t *b = baton;
switch (state)
{
case ELEM_multistatus:
if (b->contains_error)
{
if (svn_stringbuf_isempty(b->description))
return svn_error_create(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
_("The request response contained at least "
"one error"));
else if (b->contains_precondition_error)
return svn_error_create(SVN_ERR_FS_PROP_BASEVALUE_MISMATCH, NULL,
b->description->data);
else
return svn_error_create(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
b->description->data);
}
break;
case ELEM_responsedescription:
if (b->in_propstat)
svn_stringbuf_set(b->propstat_description, b->cdata->data);
else
{
if (! svn_stringbuf_isempty(b->description))
svn_stringbuf_appendcstr(b->description, "\n");
svn_stringbuf_appendstr(b->description, b->cdata);
}
break;
case ELEM_status:
{
ne_status status;
if (ne_parse_statusline(b->cdata->data, &status) == 0)
{
/*### I wanted ||=, but I guess the end result is the same */
if (! b->in_propstat)
b->contains_error |= (status.klass != 2);
else
b->propstat_has_error = (status.klass != 2);
/* Handle "412 Precondition Failed" specially */
if (status.code == 412)
b->contains_precondition_error = TRUE;
free(status.reason_phrase);
}
else
return svn_error_create(SVN_ERR_RA_DAV_REQUEST_FAILED, NULL,
_("The response contains a non-conforming "
"HTTP status line"));
}
break;
case ELEM_propstat:
b->in_propstat = FALSE;
b->contains_error |= b->propstat_has_error;
svn_stringbuf_appendcstr(b->description,
apr_psprintf(b->req->pool,
_("Error setting property '%s': "),
b->propname->data));
svn_stringbuf_appendstr(b->description,
b->propstat_description);
default:
/* do nothing */
break;
}
/* When we have an element which wants cdata,
we'll set it all up in start_207_element() again */
b->want_cdata = NULL;
return SVN_NO_ERROR;
}
/* fonction simulant la commande svn diff */
apr_array_header_t *svn_support_diff_call(char *rep_path,
char *filename,
int revision1,
int revision2,
apr_pool_t* subpool)
{
svn_error_t *err;
apr_file_t *outfile;
apr_file_t *errfile;
apr_status_t rv;
svn_opt_revision_t rev1;
svn_opt_revision_t rev2;
// -- Initialisation du tableau et du buffer de résultats --
apr_array_header_t *list_result = apr_array_make(subpool, 1, sizeof (const char *));
svn_stringbuf_t *res = svn_stringbuf_create("",subpool);
// -- Initialisation des chemins des fichiers --
const svn_stringbuf_t *slash = svn_stringbuf_create("/",subpool);
const svn_stringbuf_t *filepath = svn_stringbuf_create(filename,subpool);
svn_stringbuf_t *path = svn_stringbuf_create(rep_path,subpool);
if (strcmp(filename,"") != 0) {
svn_stringbuf_appendstr(path,slash);
svn_stringbuf_appendstr(path,filepath);
}
// -- Initialisation des revisions --
rev1.kind = rev2.kind = svn_opt_revision_number;
rev1.value.number=revision1;
rev2.value.number=revision2;
// -- Initialisation des fichiers d'output --
if ((rv = apr_file_open_stdout(&outfile,subpool)) != APR_SUCCESS) {
svn_pool_destroy(subpool);
return NULL;
}
if ((rv = apr_file_open_stdout(&errfile,subpool)) != APR_SUCCESS) {
svn_pool_destroy(subpool);
return NULL;
}
const apr_array_header_t *diff_options = apr_array_make(subpool, 1, sizeof (const char *));
//apr_file_t *write_end;
//apr_file_t *read_end;
//apr_file_pipe_create(&write_end,&read_end,subpool);
int tube[2];
pipe(tube);
switch(fork()){
case -1:
perror("fork");
svn_pool_destroy(subpool);
return NULL;
case 0:
//apr_file_close(read_end);
//apr_file_dup2(outfile,write_end,subpool);
close(tube[0]);
dup2(tube[1],STDOUT_FILENO);
err = svn_client_diff4(diff_options,
path->data,
&rev1,
path->data,
&rev2,
NULL,
svn_depth_infinity,
TRUE,// ignore_ancestry
TRUE,// no_diff_deleted
FALSE, // ignore_content_type
SVN_APR_LOCALE_CHARSET,
outfile,
errfile,
NULL,
ctx,
subpool);
if (err) {
svn_handle_error2 (err, stderr, FALSE, "svn_support_diff: ");
svn_pool_destroy(subpool);
return NULL;
}
exit(0);
}
//apr_file_close(write_end);
close(tube[1]);
int buf_size = 4096;
char buf[buf_size];
int rc;
const svn_stringbuf_t *tmp;
while((rc=read(tube[0],buf,buf_size))>0){//(rv=apr_file_gets(buf,buf_size,read_end))){
//if(APR_STATUS_IS_EOF(rv))
//break;
buf[rc]='\0';
tmp = svn_stringbuf_create(buf,subpool);
svn_stringbuf_appendstr(res,tmp);
//*(char **)apr_array_push(list_result) = buf;
}
wait(NULL);
svn_cstring_split_endline_append(list_result,res->data,subpool);
svn_pool_destroy(subpool);
return list_result;
}
/* fonction callback pour l'appel a svn_client_log4 */
svn_error_t* log_callback(void *baton, svn_log_entry_t *log_entry, apr_pool_t *pool)
{
apr_hash_t *revprops = log_entry->revprops;
int rev = (int)log_entry->revision;
svn_string_t *author_s, *date_s, *message_s;
svn_stringbuf_t *revnum, *author, *day, *parsed_time, *parsed_message;
const char *date, *day_tmp, *time, *parsed_time_tmp, *message, *parsed_message_tmp;
apr_array_header_t *date_array, *time_array, *message_array;
// -- Recuperation du champ "revision" --
char *n = apr_psprintf(pool,"%d\n",rev);
revnum = svn_stringbuf_create(n,pool);
// -- Recuperation du champ "auteur" --
if ((author_s = apr_hash_get(revprops,
SVN_PROP_REVISION_AUTHOR,
APR_HASH_KEY_STRING))) {
author = stringbuf_endline_utf8(author_s->data,pool);
}
else
author = svn_stringbuf_create("Unknown author\n",pool);
// -- Recuperation & traitement du champ "date" --
if ((date_s = apr_hash_get(revprops,
SVN_PROP_REVISION_DATE,
APR_HASH_KEY_STRING))){
date = date_s->data;
date_array = svn_cstring_split(date,"T",TRUE,pool);
day_tmp = ((const char**)date_array->elts)[0];
day = stringbuf_endline_utf8(day_tmp,pool);
time = ((const char**)date_array->elts)[1];
time_array = svn_cstring_split(time,".",TRUE,pool);
parsed_time_tmp = ((const char**)time_array->elts)[0];
parsed_time = stringbuf_endline_utf8(parsed_time_tmp,pool);
}
else {
day = svn_stringbuf_create("???\n",pool);
parsed_time = svn_stringbuf_create("???\n",pool);
}
// -- Recuperation & traitement du champ "message" --
if ((message_s = apr_hash_get(revprops,
SVN_PROP_REVISION_LOG,
APR_HASH_KEY_STRING))){
message = message_s->data;
if (strcmp(message,"") == 0) {
parsed_message = svn_stringbuf_create(" \n",pool);
}
else {
message_array = svn_cstring_split(message,"\n",TRUE,pool);
parsed_message_tmp = svn_cstring_join(message_array,"<br/>",pool);
parsed_message = stringbuf_endline_utf8(parsed_message_tmp,pool);
}
}
else{
parsed_message = svn_stringbuf_create(" \n",pool);
}
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)revnum);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)author);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)day);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)parsed_time);
svn_stringbuf_appendstr((svn_stringbuf_t *)baton,(const svn_stringbuf_t *)parsed_message);
return SVN_NO_ERROR;
}
