c_pvector c_vector_assign(c_pvector thiz, const c_pvector V)
{
if(V != thiz)
{
_c_vector_impl * pl = (_c_vector_impl *)thiz->_l;
const size_type vlen = c_vector_size(V);
if(vlen > c_vector_capacity(thiz))
{
c_iterator tmp = _A_allocate_and_copy(thiz,
vlen,
c_vector_begin(V),
c_vector_end(V));
_A_deallocate(thiz,
pl->_start,
abs(pl->_end_of_storage - pl->_start));
pl->_start = (pnode_t)tmp._i;
pl->_end_of_storage = pl->_start + vlen;
}
else if(c_vector_size(thiz) >= vlen)
{
c_copy(c_vector_begin(V), c_vector_end(V), c_vector_begin(thiz));
}
else
{
c_iterator bg = c_vector_begin(thiz);
c_copy(bg, ITER_POSITIVE_N(bg, c_vector_size(thiz)), _A_get_iterator(pl->_start));
c_uninitialized_copy(ITER_POSITIVE_N(bg, c_vector_size(thiz)),
c_vector_end(thiz),
_A_get_iterator(pl->_finish));
}
pl->_finish = pl->_start + vlen;
}
return thiz;
}
static void _A_insert_aux1(c_pvector thiz, c_iterator pos, node_t val)
{
_c_vector_impl * pl = (_c_vector_impl *)thiz->_l;
if(pl->_finish != pl->_end_of_storage)
{
node_t node;
*pl->_finish = *(pl->_finish - 1);
++ pl->_finish;
node = val;
c_copy_backward(pos,
_A_get_iterator(pl->_finish - 2),
_A_get_iterator(pl->_finish - 1));
ITER_REF_ASSIGN(pos, node);
}
else
{
const size_type old_size = c_vector_size(thiz);
const size_type len = old_size != 0 ? 2 * old_size : 1;
c_iterator new_start = _A_get_iterator(_A_allocate(thiz, len));
c_iterator new_finish = new_start;
new_finish = c_copy(_A_get_iterator(pl->_start), pos, new_start);
ITER_REF_ASSIGN(new_finish, val);
ITER_INC(new_finish);
new_finish = c_copy(pos, _A_get_iterator(pl->_finish), new_finish);
_A_deallocate(thiz, pl->_start, abs(pl->_end_of_storage - pl->_start));
pl->_start = (pnode_t)new_start._i;
pl->_finish = (pnode_t)new_finish._i;
pl->_end_of_storage = pl->_start + len;
}
}
void polymult (header *hd)
{ header *st=hd,*hd1,*result;
int c,c1,c2,i,r,j,k;
double *m1,*m2,*mr,x;
complex *mc1,*mc2,*mcr,xc,hc;
interval *mi1,*mi2,*mir,xi,hi;
hd1=next_param(st);
equal_params_2(&hd,&hd1); if (error) return;
getmatrix(hd,&r,&c1,&m1); if (r!=1) wrong_arg();
getmatrix(hd1,&r,&c2,&m2); if (r!=1) wrong_arg();
if ((LONG)c1+c2-1>INT_MAX) wrong_arg();
c=c1+c2-1;
if (iscomplex(hd))
{ mc1=(complex *)m1; mc2=(complex *)m2;
result=new_cmatrix(1,c,""); if (error) return;
mcr=(complex *)matrixof(result);
c_copy(xc,*mc1); mc1++;
for (i=0; i<c2; i++) c_mult(xc,mc2[i],mcr[i]);
for (j=1; j<c1; j++)
{ c_copy(xc,*mc1); mc1++;
for (k=j,i=0; i<c2-1; i++,k++)
{ c_mult(xc,mc2[i],hc);
c_add(hc,mcr[k],mcr[k]);
}
c_mult(xc,mc2[i],mcr[k]);
}
}
else if (isinterval(hd))
{ mi1=(interval *)m1; mi2=(interval *)m2;
result=new_imatrix(1,c,""); if (error) return;
mir=(interval *)matrixof(result);
i_copy(xi,*mi1); mi1++;
for (i=0; i<c2; i++) i_mult(xi,mi2[i],mir[i]);
for (j=1; j<c1; j++)
{ i_copy(xi,*mi1); mi1++;
for (k=j,i=0; i<c2-1; i++,k++)
{ i_mult(xi,mi2[i],hi);
c_add(hi,mir[k],mir[k]);
}
c_mult(xi,mi2[i],mir[k]);
}
}
else if (isreal(hd))
{ result=new_matrix(1,c,""); if (error) return;
mr=matrixof(result);
x=*m1++;
for (i=0; i<c2; i++) mr[i]=x*m2[i];
for (j=1; j<c1; j++)
{ x=*m1++;
for (k=j,i=0; i<c2-1; i++,k++) mr[k]+=x*m2[i];
mr[k]=x*m2[i];
}
}
else wrong_arg();
moveresult(st,result);
}
static void check_c_compare_file(void **state)
{
int rc;
(void) state;
rc = c_copy(check_src_file, check_dst_file, 0644);
assert_int_equal(rc, 0);
rc = c_compare_file( check_src_file, check_dst_file );
assert_int_equal(rc, 1);
/* Check error conditions */
rc = c_compare_file( NULL, check_dst_file );
assert_int_equal(rc, -1);
rc = c_compare_file( check_dst_file, NULL );
assert_int_equal(rc, -1);
rc = c_compare_file( NULL, NULL );
assert_int_equal(rc, -1);
rc = c_compare_file( check_src_file, "/I_do_not_exist_in_the_filesystem.dummy");
assert_int_equal(rc, -1);
rc = c_compare_file( "/I_do_not_exist_in_the_filesystem.dummy", check_dst_file);
assert_int_equal(rc, -1);
rc = system("echo \"hallo42\" > /tmp/check/foo.txt");
assert_int_equal(rc, 0);
rc = system("echo \"hallo52\" > /tmp/check/bar.txt");
assert_int_equal(rc, 0);
rc = c_compare_file( check_src_file, check_dst_file );
assert_int_equal(rc, 0);
/* Create two 1MB random files */
rc = system("dd if=/dev/urandom of=/tmp/check/foo.txt bs=1024 count=1024");
assert_int_equal(rc, 0);
rc = system("dd if=/dev/urandom of=/tmp/check/bar.txt bs=1024 count=1024");
assert_int_equal(rc, 0);
rc = c_compare_file( check_src_file, check_dst_file );
assert_int_equal(rc, 0);
/* Create two 1MB random files with different size */
rc = system("dd if=/dev/urandom of=/tmp/check/foo.txt bs=1024 count=1024");
assert_int_equal(rc, 0);
rc = system("dd if=/dev/urandom of=/tmp/check/bar.txt bs=1024 count=1020");
assert_int_equal(rc, 0);
rc = c_compare_file( check_src_file, check_dst_file );
assert_int_equal(rc, 0);
/* compare two big files which are equal */
rc = c_copy(check_src_file, check_dst_file, 0644);
assert_int_equal(rc, 0);
rc = c_compare_file( check_src_file, check_dst_file );
assert_int_equal(rc, 1);
}
static void check_c_copy_isdir(void **state)
{
int rc;
(void) state; /* unused */
rc = c_copy(check_src_file, check_dir, 0644);
assert_int_equal(rc, -1);
assert_int_equal(errno, EISDIR);
rc = c_copy(check_dir, check_dst_file, 0644);
assert_int_equal(rc, -1);
assert_int_equal(errno, EISDIR);
}
void c_vector_insert2(c_pvector thiz, c_iterator pos, c_iterator first, c_iterator last)
{
if(!ITER_EQUAL(first, last))
{
_c_vector_impl * pl = (_c_vector_impl *)thiz->_l;
difference_type dn = 0;
size_type n = 0;
c_distance1(first, last, &dn);
n = abs(dn);
if(abs(pl->_end_of_storage - pl->_finish) >= (int)n)
{
const size_type elems_after = pl->_finish - (pnode_t)pos._i;
c_iterator old_finish = c_vector_end(thiz);
if(elems_after > n)
{
c_uninitialized_copy(_A_get_iterator(pl->_finish - n),
_A_get_iterator(pl->_finish),
_A_get_iterator(pl->_finish));
pl->_finish += n;
c_copy_backward(pos, ITER_NEGATIVE_N(old_finish, n), old_finish);
c_copy(first, last, pos);
}
else
{
c_uninitialized_copy(ITER_POSITIVE_N(first, elems_after),
last,
_A_get_iterator(pl->_finish));
pl->_finish += n - elems_after;
c_uninitialized_copy(pos, old_finish, _A_get_iterator(pl->_finish));
pl->_finish += elems_after;
c_copy(first, ITER_POSITIVE_N(first, elems_after), pos);
}
}
else
{
const size_type old_size = c_vector_size(thiz);
const size_type len = old_size + C_MAX(old_size, n);
c_iterator new_start = _A_get_iterator(_A_allocate(thiz, len));
c_iterator new_finish = new_start;
new_finish = c_uninitialized_copy(_A_get_iterator(pl->_start), pos, new_start);
new_finish = c_uninitialized_copy(first, last, new_finish);
new_finish = c_uninitialized_copy(pos, _A_get_iterator(pl->_finish), new_finish);
_A_deallocate(thiz, pl->_start, abs(pl->_end_of_storage - pl->_start));
pl->_start = (pnode_t)new_start._i;
pl->_finish = (pnode_t)new_finish._i;
pl->_end_of_storage = (pnode_t)ITER_POSITIVE_N(new_start, len)._i;
}
}
}
c_iterator c_vector_erase2(c_pvector thiz, c_iterator first, c_iterator last)
{
_c_vector_impl * pl = (_c_vector_impl *)thiz->_l;
c_copy(last, _A_get_iterator(pl->_finish), first);
pl->_finish = pl->_finish - abs(ITER_DIFF(last, first));
return first;
}
static void check_c_copy_same_file(void **state)
{
int rc;
(void) state; /* unused */
rc = c_copy(check_src_file, check_src_file, 0644);
assert_int_equal(rc, -1);
}
void polyadd (header *hd)
{ header *st=hd,*hd1,*result;
int c,c1,c2,i,r;
double *m1,*m2,*mr;
complex *mc1,*mc2,*mcr;
interval *mi1,*mi2,*mir;
hd1=next_param(st);
equal_params_2(&hd,&hd1); if (error) return;
getmatrix(hd,&r,&c1,&m1); if (r!=1) wrong_arg();
getmatrix(hd1,&r,&c2,&m2); if (r!=1) wrong_arg();
c=max(c1,c2);
if (iscomplex(hd)) /* complex values */
{ mc1=(complex *)m1; mc2=(complex *)m2;
result=new_cmatrix(1,c,""); if (error) return;
mcr=(complex *)matrixof(result);
for (i=0; i<c; i++)
{ if (i>=c1) { c_copy(*mcr,*mc2); mcr++; mc2++; }
else if (i>=c2) { c_copy(*mcr,*mc1); mcr++; mc1++; }
else { c_add(*mc1,*mc2,*mcr); mc1++; mc2++; mcr++; }
}
}
else if (isinterval(hd))
{ mi1=(interval *)m1; mi2=(interval *)m2;
result=new_imatrix(1,c,""); if (error) return;
mir=(interval *)matrixof(result);
for (i=0; i<c; i++)
{ if (i>=c1) { i_copy(*mir,*mi2); mir++; mi2++; }
else if (i>=c2) { i_copy(*mir,*mi1); mir++; mi1++; }
else { i_add(*mi1,*mi2,*mir); mi1++; mi2++; mir++; }
}
}
else if (isreal(hd))
{ result=new_matrix(1,c,""); if (error) return;
mr=matrixof(result);
for (i=0; i<c; i++)
{ if (i>=c1) { *mr++ = *m2++; }
else if (i>=c2) { *mr++ = *m1++; }
else { *mr++ = *m1++ + *m2++; }
}
}
else wrong_arg();
moveresult(st,result);
}
c_iterator c_vector_erase(c_pvector thiz, c_iterator pos)
{
c_iterator pos_1 = ITER_POSITIVE_N(pos, 1);
c_iterator end = c_vector_end(thiz);
_c_vector_impl * pl = (_c_vector_impl *)thiz->_l;
if(!ITER_EQUAL(pos_1, end))
c_copy(pos_1, _A_get_iterator(pl->_finish), pos);
-- pl->_finish;
return pos;
}
static void check_c_copy(void **state)
{
int rc;
(void) state; /* unused */
rc = c_copy(check_src_file, check_dst_file, 0644);
assert_int_equal(rc, 0);
rc = test_file(check_dst_file, 0644);
assert_int_equal(rc, 0);
}
void rfft (long m0, long p0, long q0, long n)
/***** rfft
make a fft on x[m],x[m+q0],...,x[m+(p0-1)*q0] (p points).
one has xi_p0 = xi_n^n = zz[n] ; i.e., p0*n=nn.
*****/
{ long p,q,m,l;
long mh,ml;
int found=0;
complex sum,h;
if (p0==1) return;
if (test_key()==escape) { error=301; return; }
if (p0%2==0) { p=p0/2; q=2; }
else
{ q=3;
while (q*q<=p0)
{ if (p0%q==0)
{ found=1; break; }
q+=2;
}
if (found) p=p0/q;
else { q=p0; p=1; }
}
if (p>1) for (m=0; m<q; m++)
rfft((m0+m*q0)%nn,p,q*q0,nn/p);
mh=m0;
for (l=0; l<p0; l++)
{ ml=l%p;
c_copy(sum,ff[(m0+ml*q*q0)%nn]);
for (m=1; m<q; m++)
{ c_mult(ff[(m0+(m+ml*q)*q0)%nn],zz[(n*l*m)%nn],h);
c_add(sum,h,sum);
}
sum[0]/=q; sum[1]/=q;
c_copy(fh[mh],sum);
mh+=q0; if (mh>=nn) mh-=nn;
}
for (l=0; l<p0; l++)
{ c_copy(ff[m0],fh[m0]);
m0+=q0;
}
}
static int _csync_config_copy_default (const char *config) {
int rc = 0;
#ifdef _WIN32
/* For win32, try to copy the conf file from the directory from where the app was started. */
mbchar_t tcharbuf[MAX_PATH+1];
char *buf;
int len = 0;
/* Get the path from where the application was started */
len = GetModuleFileNameW(NULL, tcharbuf, MAX_PATH);
if(len== 0) {
rc = -1;
} else {
char *last_bslash;
buf = c_utf8_from_locale(tcharbuf);
/* cut the trailing filename off */
if ((last_bslash = strrchr(buf, '\\')) != NULL) {
*last_bslash='\0';
}
strncat(buf, "\\" CSYNC_CONF_FILE, MAX_PATH);
if(c_copy(buf, config, 0644) < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_ERROR, "Could not copy /%s to %s", buf, config );
rc = -1;
}
c_free_locale_string(buf);
}
#else
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Copy %s/config/%s to %s", SYSCONFDIR,
CSYNC_CONF_FILE, config);
if (c_copy(SYSCONFDIR "/ocsync/" CSYNC_CONF_FILE, config, 0644) < 0) {
if (c_copy(BINARYDIR "/config/" CSYNC_CONF_FILE, config, 0644) < 0) {
rc = -1;
}
}
#endif
return rc;
}
void polydd (header *hd)
{ header *st=hd,*hd1,*result;
int c1,c2,i,j,r;
double *m1,*m2,*mr,x;
complex *mc1,*mc2,*mcr,hc,xc;
hd1=next_param(st);
equal_params_2(&hd,&hd1); if (error) return;
getmatrix(hd,&r,&c1,&m1); if (r!=1) wrong_arg();
getmatrix(hd1,&r,&c2,&m2); if (r!=1) wrong_arg();
if (c1!=c2) wrong_arg();
if (iscomplex(hd)) /* complex values */
{ mc1=(complex *)m1; mc2=(complex *)m2;
result=new_cmatrix(1,c1,""); if (error) return;
mcr=(complex *)matrixof(result);
c_copy(mcr[c1-1],mc2[c1-1]);
for (i=c1-2; i>=0; i--)
{ c_copy(xc,mc1[i]);
c_mult(xc,mcr[i+1],hc);
c_sub(mc2[i],hc,mcr[i]);
for (j=i+1; j<c1-1; j++)
{ c_mult(xc,mcr[j+1],hc);
c_sub(mcr[j],hc,mcr[j]);
}
}
}
else
{ result=new_matrix(1,c1,""); if (error) return;
mr=matrixof(result);
mr[c1-1]=m2[c1-1];
for (i=c1-2; i>=0; i--)
{ x=m1[i];
mr[i]=m2[i]-x*mr[i+1];
for (j=i+1; j<c1-1; j++) mr[j]=mr[j]-x*mr[j+1];
}
}
moveresult(st,result);
}
int csync_statedb_load(CSYNC *ctx, const char *statedb) {
int rc = -1;
c_strlist_t *result = NULL;
char *statedb_tmp = NULL;
if (_csync_statedb_check(statedb) < 0) {
rc = -1;
goto out;
}
/*
* We want a two phase commit for the jounal, so we create a temporary copy
* of the database.
* The intention is that if something goes wrong we will not loose the
* statedb.
*/
if (asprintf(&statedb_tmp, "%s.ctmp", statedb) < 0) {
rc = -1;
goto out;
}
if (c_copy(statedb, statedb_tmp, 0644) < 0) {
rc = -1;
goto out;
}
/* Open the temporary database */
if (sqlite3_open(statedb_tmp, &ctx->statedb.db) != SQLITE_OK) {
rc = -1;
goto out;
}
if (_csync_statedb_is_empty(ctx)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist");
csync_set_statedb_exists(ctx, 0);
} else {
csync_set_statedb_exists(ctx, 1);
}
/* optimization for speeding up SQLite */
result = csync_statedb_query(ctx, "PRAGMA default_synchronous = OFF;");
c_strlist_destroy(result);
rc = 0;
out:
SAFE_FREE(statedb_tmp);
return rc;
}
int csync_statedb_close(CSYNC *ctx, const char *statedb, int jwritten) {
char *statedb_tmp = NULL;
int rc = 0;
/* close the temporary database */
sqlite3_close(ctx->statedb.db);
if (asprintf(&statedb_tmp, "%s.ctmp", statedb) < 0) {
return -1;
}
/* if we successfully synchronized, overwrite the original statedb */
if (jwritten) {
rc = c_copy(statedb_tmp, statedb, 0644);
if (rc == 0) {
unlink(statedb_tmp);
}
} else {
unlink(statedb_tmp);
}
SAFE_FREE(statedb_tmp);
return rc;
}
void polydiv (header *hd)
{ header *st=hd,*hd1,*result,*rest;
int c1,c2,i,r,j;
double *m1,*m2,*mr,*mh,x,l;
complex *mc1,*mc2,*mcr,*mch,xc,lc,hc;
interval *mi1,*mi2,*mir,*mih,xi,li,hi;
hd1=next_param(st);
equal_params_2(&hd,&hd1); if (error) return;
getmatrix(hd,&r,&c1,&m1); if (r!=1) wrong_arg();
getmatrix(hd1,&r,&c2,&m2); if (r!=1) wrong_arg();
if (c1<c2)
{ result=new_real(0.0,"");
rest=(header *)newram;
moveresult(rest,hd1);
}
else if (iscomplex(hd))
{ mc1=(complex *)m1; mc2=(complex *)m2;
result=new_cmatrix(1,c1-c2+1,""); if (error) return;
mcr=(complex *)matrixof(result);
rest=new_cmatrix(1,c2,""); if (error) return;
mch=(complex *)newram;
if (!freeram(c1*sizeof(complex)))
{ output("Out of memory!\n"); error=190; return;
}
memmove((char *)mch,(char *)mc1,c1*sizeof(complex));
c_copy(lc,mc2[c2-1]);
if (lc[0]==0.0 && lc[1]==0.0) wrong_arg();
for (i=c1-c2; i>=0; i--)
{ c_div(mch[c2+i-1],lc,xc); c_copy(mcr[i],xc);
for(j=0; j<c2; j++)
{ c_mult(mc2[j],xc,hc);
c_sub(mch[i+j],hc,mch[i+j]);
}
}
memmove((char *)matrixof(rest),(char *)mch,c2*sizeof(complex));
}
else if (isinterval(hd))
{ mi1=(interval *)m1; mi2=(interval *)m2;
result=new_imatrix(1,c1-c2+1,""); if (error) return;
mir=(interval *)matrixof(result);
rest=new_imatrix(1,c2,""); if (error) return;
mih=(complex *)newram;
if (!freeram(c1*sizeof(complex)))
{ output("Out of memory!\n"); error=190; return;
}
memmove((char *)mih,(char *)mi1,c1*sizeof(interval));
i_copy(li,mi2[c2-1]);
if (li[0]<=0.0 && li[1]>=0.0) wrong_arg();
for (i=c1-c2; i>=0; i--)
{ i_div(mih[c2+i-1],li,xi); c_copy(mir[i],xi);
for(j=0; j<c2; j++)
{ i_mult(mi2[j],xi,hi);
i_sub(mih[i+j],hi,mih[i+j]);
}
}
memmove((char *)matrixof(rest),(char *)mih,c2*sizeof(interval));
}
else if (isreal(hd))
{ result=new_matrix(1,c1-c2+1,""); if (error) return;
mr=matrixof(result);
rest=new_matrix(1,c2,""); if (error) return;
mh=(double *)newram;
if (!freeram(c1*sizeof(double)))
{ output("Out of memory!\n"); error=190; return;
}
memmove((char *)mh,(char *)m1,c1*sizeof(double));
l=m2[c2-1];
if (l==0.0) wrong_arg();
for (i=c1-c2; i>=0; i--)
{ x=mh[c2+i-1]/l; mr[i]=x;
for(j=0; j<c2; j++) mh[i+j]-=m2[j]*x;
}
memmove((char *)matrixof(rest),(char *)mh,c2*sizeof(double));
}
else wrong_arg();
moveresult(st,result);
moveresult(nextof(st),rest);
}
int csync_statedb_load(CSYNC *ctx, const char *statedb, sqlite3 **pdb) {
int rc = -1;
int check_rc = -1;
c_strlist_t *result = NULL;
char *statedb_tmp = NULL;
sqlite3 *db = NULL;
/* csync_statedb_check tries to open the statedb and creates it in case
* its not there.
*/
check_rc = _csync_statedb_check(statedb);
if (check_rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: checking csync database failed - bail out.");
rc = -1;
goto out;
}
/*
* We want a two phase commit for the jounal, so we create a temporary copy
* of the database.
* The intention is that if something goes wrong we will not loose the
* statedb.
*/
rc = asprintf(&statedb_tmp, "%s.ctmp", statedb);
if (rc < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: could not create statedb name - bail out.");
rc = -1;
goto out;
}
if (c_copy(statedb, statedb_tmp, 0644) < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: Failed to copy statedb -> statedb_tmp - bail out.");
rc = -1;
goto out;
}
_csync_win32_hide_file( statedb_tmp );
/* Open or create the temporary database */
if (sqlite3_open(statedb_tmp, &db) != SQLITE_OK) {
const char *errmsg= sqlite3_errmsg(ctx->statedb.db);
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "ERR: Failed to sqlite3 open statedb - bail out: %s.",
errmsg ? errmsg : "<no sqlite3 errormsg>");
rc = -1;
goto out;
}
SAFE_FREE(statedb_tmp);
/* If check_rc == 1 the database is new and empty as a result. */
if ((check_rc == 1) || _csync_statedb_is_empty(db)) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "statedb doesn't exist");
csync_set_statedb_exists(ctx, 0);
} else {
csync_set_statedb_exists(ctx, 1);
}
/* optimization for speeding up SQLite */
result = csync_statedb_query(db, "PRAGMA synchronous = FULL;");
c_strlist_destroy(result);
result = csync_statedb_query(db, "PRAGMA case_sensitive_like = ON;");
c_strlist_destroy(result);
#ifndef NDEBUG
sqlite3_profile(db, sqlite_profile, 0 );
#endif
*pdb = db;
return 0;
out:
sqlite3_close(db);
SAFE_FREE(statedb_tmp);
return rc;
}
int csync_init(CSYNC *ctx) {
int rc;
time_t timediff = -1;
char *log = NULL;
char *exclude = NULL;
char *lock = NULL;
char *config = NULL;
#ifndef _WIN32
char errbuf[256] = {0};
#endif
if (ctx == NULL) {
errno = EBADF;
return -1;
}
ctx->error_code = CSYNC_ERR_NONE;
/* Do not initialize twice */
if (ctx->status & CSYNC_STATUS_INIT) {
return 1;
}
/* load log file */
if (csync_log_init() < 0) {
ctx->error_code = CSYNC_ERR_LOG;
fprintf(stderr, "csync_init: logger init failed\n");
return -1;
}
/* create dir if it doesn't exist */
if (! c_isdir(ctx->options.config_dir)) {
c_mkdirs(ctx->options.config_dir, 0700);
}
if (asprintf(&log, "%s/%s", ctx->options.config_dir, CSYNC_LOG_FILE) < 0) {
ctx->error_code = CSYNC_ERR_UNSPEC;
rc = -1;
goto out;
}
/* load log if it exists */
if (c_isfile(log)) {
csync_log_load(log);
} else {
#ifndef _WIN32
if (c_copy(SYSCONFDIR "/csync/" CSYNC_LOG_FILE, log, 0644) == 0) {
csync_log_load(log);
}
#endif
}
/* create lock file */
if (asprintf(&lock, "%s/%s", ctx->options.config_dir, CSYNC_LOCK_FILE) < 0) {
ctx->error_code = CSYNC_ERR_UNSPEC;
rc = -1;
goto out;
}
#ifndef _WIN32
if (csync_lock(lock) < 0) {
ctx->error_code = CSYNC_ERR_LOCK;
rc = -1;
goto out;
}
#endif
/* load config file */
if (asprintf(&config, "%s/%s", ctx->options.config_dir, CSYNC_CONF_FILE) < 0) {
rc = -1;
goto out;
}
if (csync_config_load(ctx, config) < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_WARN, "Could not load config file %s, using defaults.", config);
}
#ifndef _WIN32
/* load global exclude list */
if (asprintf(&exclude, "%s/csync/%s", SYSCONFDIR, CSYNC_EXCLUDE_FILE) < 0) {
ctx->error_code = CSYNC_ERR_UNSPEC;
rc = -1;
goto out;
}
if (csync_exclude_load(ctx, exclude) < 0) {
strerror_r(errno, errbuf, sizeof(errbuf));
CSYNC_LOG(CSYNC_LOG_PRIORITY_INFO, "Could not load %s - %s", exclude,
errbuf);
}
SAFE_FREE(exclude);
/* load exclude list */
if (asprintf(&exclude, "%s/%s", ctx->options.config_dir, CSYNC_EXCLUDE_FILE) < 0) {
ctx->error_code = CSYNC_ERR_UNSPEC;
rc = -1;
goto out;
}
if (csync_exclude_load(ctx, exclude) < 0) {
strerror_r(errno, errbuf, sizeof(errbuf));
CSYNC_LOG(CSYNC_LOG_PRIORITY_INFO, "Could not load %s - %s", exclude,
errbuf);
}
#endif
/* create/load statedb */
if (! csync_is_statedb_disabled(ctx)) {
uint64_t h = csync_create_statedb_hash(ctx);
if (asprintf(&ctx->statedb.file, "%s/csync_statedb_%llu.db",
ctx->options.config_dir, (long long unsigned int) h) < 0) {
ctx->error_code = CSYNC_ERR_UNSPEC;
rc = -1;
goto out;
}
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Remote replica: %s", ctx->remote.uri);
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Statedb: %s", ctx->statedb.file);
if (csync_statedb_load(ctx, ctx->statedb.file) < 0) {
ctx->error_code = CSYNC_ERR_STATEDB_LOAD;
rc = -1;
goto out;
}
}
ctx->local.type = LOCAL_REPLICA;
/* check for uri */
if ( !ctx->options.local_only_mode && csync_fnmatch("*://*", ctx->remote.uri, 0) == 0) {
size_t len;
len = strstr(ctx->remote.uri, "://") - ctx->remote.uri;
/* get protocol */
if (len > 0) {
char *module = NULL;
/* module name */
module = c_strndup(ctx->remote.uri, len);
if (module == NULL) {
ctx->error_code = CSYNC_ERR_MODULE;
rc = -1;
goto out;
}
/* load module */
retry_vio_init:
rc = csync_vio_init(ctx, module, NULL);
if (rc < 0) {
len = strlen(module);
if (len > 0 && module[len-1] == 's') {
module[len-1] = '\0';
goto retry_vio_init;
}
/* Now vio init finally failed which means a module could not be found. */
ctx->error_code = CSYNC_ERR_MODULE;
CSYNC_LOG(CSYNC_LOG_PRIORITY_FATAL,
"The csync module %s could not be loaded.", module);
SAFE_FREE(module);
goto out;
}
SAFE_FREE(module);
ctx->remote.type = REMOTE_REPLCIA;
}
} else {
ctx->remote.type = LOCAL_REPLICA;
}
if(!ctx->options.local_only_mode) {
if(ctx->module.capabilities.time_sync_required) {
timediff = csync_timediff(ctx);
if (timediff > ctx->options.max_time_difference) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_FATAL,
"Clock skew detected. The time difference is greater than %d seconds!",
ctx->options.max_time_difference);
ctx->error_code = CSYNC_ERR_TIMESKEW;
rc = -1;
goto out;
} else if (timediff < 0) {
/* error code was set in csync_timediff() */
CSYNC_LOG(CSYNC_LOG_PRIORITY_FATAL, "Synchronisation is not possible!");
/* do not override error code set by timediff */
if(ctx->error_code == CSYNC_ERR_NONE) {
ctx->error_code = CSYNC_ERR_TIMESKEW;
}
rc = -1;
goto out;
}
} else {
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Module does not need time synchronization.");
}
if(ctx->module.capabilities.unix_extensions == -1) { /* detect */
if (csync_unix_extensions(ctx) < 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_FATAL, "Could not detect filesystem type.");
ctx->error_code = CSYNC_ERR_FILESYSTEM;
rc = -1;
goto out;
}
} else {
/* The module specifies the value for the unix_extensions. */
ctx->options.unix_extensions = ctx->module.capabilities.unix_extensions;
}
}
if (c_rbtree_create(&ctx->local.tree, _key_cmp, _data_cmp) < 0) {
ctx->error_code = CSYNC_ERR_TREE;
rc = -1;
goto out;
}
if (c_rbtree_create(&ctx->remote.tree, _key_cmp, _data_cmp) < 0) {
ctx->error_code = CSYNC_ERR_TREE;
rc = -1;
goto out;
}
ctx->status = CSYNC_STATUS_INIT;
/* initialize random generator */
srand(time(NULL));
rc = 0;
out:
SAFE_FREE(log);
SAFE_FREE(lock);
SAFE_FREE(exclude);
SAFE_FREE(config);
return rc;
}
int
main (int argc, char * argv [])
{
mu_stream_t in, out, flt;
int i;
int mode = MU_FILTER_ENCODE;
int flags = MU_STREAM_READ;
char *fltname;
mu_off_t shift = 0;
int newline_option = 0;
size_t bufsize = 0;
if (argc == 1)
usage (NULL);
if (argc < 4)
usage ("not enough arguments");
fltname = argv[1];
if (strcmp (argv[2], "encode") == 0)
mode = MU_FILTER_ENCODE;
else if (strcmp (argv[2], "decode") == 0)
mode = MU_FILTER_DECODE;
else
usage ("2nd arg is wrong");
if (strcmp (argv[3], "read") == 0)
flags = MU_STREAM_READ;
else if (strcmp (argv[3], "write") == 0)
flags = MU_STREAM_WRITE;
else
usage ("3rd arg is wrong");
for (i = 4; i < argc; i++)
{
if (strncmp (argv[i], "shift=", 6) == 0)
shift = strtoul (argv[i] + 6, NULL, 0);
else if (strncmp (argv[i], "bufsize=", 8) == 0)
bufsize = strtoul (argv[i] + 8, NULL, 0);
else if (strcmp (argv[i], "verbose") == 0)
verbose++;
else if (strcmp (argv[i], "printable") == 0)
printable++;
else if (strcmp (argv[i], "nl") == 0)
newline_option++;
else if (strcmp (argv[i], "--") == 0)
{
argv[i] = fltname;
break;
}
else
usage ("wrong option");
}
argc -= i;
argv += i;
MU_ASSERT (mu_stdio_stream_create (&in, MU_STDIN_FD, 0));
if (bufsize)
mu_stream_set_buffer (in, mu_buffer_full, bufsize);
MU_ASSERT (mu_stdio_stream_create (&out, MU_STDOUT_FD, 0));
if (flags == MU_STREAM_READ)
{
MU_ASSERT (mu_filter_create_args (&flt, in, fltname,
argc, (const char **)argv,
mode,
MU_STREAM_READ|MU_STREAM_SEEK));
mu_stream_unref (in);
if (bufsize)
mu_stream_set_buffer (flt, mu_buffer_full, bufsize);
if (shift)
MU_ASSERT (mu_stream_seek (flt, shift, MU_SEEK_SET, NULL));
c_copy (out, flt);
}
else
{
MU_ASSERT (mu_filter_create_args (&flt, out, fltname,
argc, (const char **)argv,
mode,
MU_STREAM_WRITE));
if (bufsize)
mu_stream_set_buffer (flt, mu_buffer_full, bufsize);
if (shift)
MU_ASSERT (mu_stream_seek (in, shift, MU_SEEK_SET, NULL));
c_copy (flt, in);
mu_stream_close (in);
mu_stream_destroy (&in);
}
mu_stream_close (flt);
mu_stream_destroy (&flt);
if (newline_option)
mu_stream_write (out, "\n", 1, NULL);
mu_stream_close (out);
mu_stream_destroy (&out);
if (verbose)
{
fprintf (stderr, "\nInput stream stats:\n");
fprintf (stderr, "Bytes in: %lu\n",
(unsigned long) instat[MU_STREAM_STAT_IN]);
fprintf (stderr, "Bytes out: %lu\n",
(unsigned long) instat[MU_STREAM_STAT_OUT]);
fprintf (stderr, "Reads: %lu\n",
(unsigned long) instat[MU_STREAM_STAT_READS]);
fprintf (stderr, "Seeks: %lu\n",
(unsigned long) instat[MU_STREAM_STAT_SEEKS]);
fprintf (stderr, "\nOutput stream stats:\n");
fprintf (stderr, "Bytes in: %lu\n",
(unsigned long) outstat[MU_STREAM_STAT_IN]);
fprintf (stderr, "Bytes out: %lu\n",
(unsigned long) outstat[MU_STREAM_STAT_OUT]);
fprintf (stderr, "Writes: %lu\n",
(unsigned long) outstat[MU_STREAM_STAT_WRITES]);
fprintf (stderr, "Seeks: %lu\n",
(unsigned long) outstat[MU_STREAM_STAT_SEEKS]);
}
return 0;
}
int csync_config_parse_file(CSYNC *ctx, const char *config)
{
unsigned int count = 0;
char line[1024] = {0};
char *s;
FILE *f;
/* copy default config, if no config exists */
if (! c_isfile(config)) {
/* check if there is still one csync.conf left over in $HOME/.csync
* and copy it over (migration path)
*/
char *home = NULL;
char *home_config = NULL;
char *config_file = NULL;
/* there is no statedb at the expected place. */
home = csync_get_user_home_dir();
if( !c_streq(home, ctx->options.config_dir) ) {
int rc = -1;
config_file = c_basename(config);
if( config_file ) {
rc = asprintf(&home_config, "%s/%s/%s", home, CSYNC_CONF_DIR, config_file);
SAFE_FREE(config_file);
}
if (rc >= 0) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "config file %s not found, checking %s",
config, home_config);
/* check the home file and copy to new statedb if existing. */
if(c_isfile(home_config)) {
if (c_copy(home_config, config, 0644) < 0) {
/* copy failed, but that is not reason to die. */
CSYNC_LOG(CSYNC_LOG_PRIORITY_WARN, "Could not copy config %s => %s",
home_config, config);
} else {
CSYNC_LOG(CSYNC_LOG_PRIORITY_NOTICE, "Copied %s => %s",
home_config, config);
}
}
}
SAFE_FREE(home_config);
}
SAFE_FREE(home);
/* Still install the default one if nothing is there. */
if( ! c_isfile(config)) {
if (_csync_config_copy_default(config) < 0) {
return -1;
}
}
}
f = fopen(config, "r");
if (f == NULL) {
return 0;
}
CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG,
"Reading configuration data from %s",
config);
s = fgets(line, sizeof(line), f);
while (s != NULL) {
int rc;
count++;
rc = csync_config_parse_line(ctx, line, count);
if (rc < 0) {
fclose(f);
return -1;
}
s = fgets(line, sizeof(line), f);
}
fclose(f);
return 0;
}
