/* This function takes a relative path, prepends it with the CSYNC_TEST_DIR
* and creates each sub directory.
*/
static void create_dirs( const char *path )
{
int rc;
char *mypath = c_malloc( 2+strlen(CSYNC_TEST_DIR)+strlen(path));
*mypath = '\0';
strcat(mypath, CSYNC_TEST_DIR);
strcat(mypath, "/");
strcat(mypath, path);
char *p = mypath+strlen(CSYNC_TEST_DIR)+1; /* start behind the offset */
int i = 0;
assert_non_null(path);
while( *(p+i) ) {
if( *(p+i) == '/' ) {
p[i] = '\0';
mbchar_t *mb_dir = c_utf8_path_to_locale(mypath);
/* wprintf(L"OOOO %ls (%ld)\n", mb_dir, strlen(mypath)); */
rc = _tmkdir(mb_dir, MKDIR_MASK);
c_free_locale_string(mb_dir);
assert_int_equal(rc, 0);
p[i] = '/';
}
i++;
}
SAFE_FREE(mypath);
}
static void setup_testenv(void **state) {
int rc;
rc = wipe_testdir();
assert_int_equal(rc, 0);
mbchar_t *dir = c_utf8_path_to_locale(CSYNC_TEST_DIR);
rc = _tmkdir(dir, MKDIR_MASK);
assert_int_equal(rc, 0);
assert_non_null(_tgetcwd(wd_buffer, WD_BUFFER_SIZE));
rc = _tchdir(dir);
assert_int_equal(rc, 0);
c_free_locale_string(dir);
/* --- initialize csync */
statevar *mystate = malloc( sizeof(statevar) );
mystate->result = NULL;
csync_create(&(mystate->csync), "/tmp/csync1", "/tmp/csync2");
mystate->csync->replica = LOCAL_REPLICA;
*state = mystate;
}
static void check_logging(void **state)
{
int rc;
csync_stat_t sb;
mbchar_t *path;
path = c_utf8_path_to_locale("/tmp/check_csync1/cb_called");
(void) state; /* unused */
assert_non_null(path);
rc = csync_set_log_level(1);
assert_int_equal(rc, 0);
rc = csync_set_log_callback(check_log_callback);
assert_int_equal(rc, 0);
csync_log(1, __func__, "rc = %d", rc);
rc = _tstat(path, &sb);
c_free_locale_string(path);
assert_int_equal(rc, 0);
}
QString FileSystem::longWinPath( const QString& inpath )
{
QString path(inpath);
#ifdef Q_OS_WIN
path = QString::fromWCharArray( static_cast<wchar_t*>( c_utf8_path_to_locale(inpath.toUtf8() ) ) );
#endif
return path;
}
static void check_to_multibyte(void **state)
{
int rc = -1;
mbchar_t *mb_string = c_utf8_path_to_locale( TESTSTRING );
mbchar_t *mb_null = c_utf8_path_to_locale( NULL );
(void) state;
#ifdef _WIN32
assert_int_equal( wcscmp( LTESTSTRING, mb_string), 0 );
#else
assert_string_equal(mb_string, TESTSTRING);
#endif
assert_true( mb_null == NULL );
assert_int_equal(rc, -1);
c_free_locale_string(mb_string);
c_free_locale_string(mb_null);
}
int c_utimes(const char *uri, const struct timeval *times) {
FILETIME LastAccessTime;
FILETIME LastModificationTime;
HANDLE hFile;
mbchar_t *wuri = c_utf8_path_to_locale( uri );
if(times) {
UnixTimevalToFileTime(times[0], &LastAccessTime);
UnixTimevalToFileTime(times[1], &LastModificationTime);
}
else {
GetSystemTimeAsFileTime(&LastAccessTime);
GetSystemTimeAsFileTime(&LastModificationTime);
}
hFile=CreateFileW(wuri, FILE_WRITE_ATTRIBUTES, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL+FILE_FLAG_BACKUP_SEMANTICS, NULL);
if(hFile==INVALID_HANDLE_VALUE) {
switch(GetLastError()) {
case ERROR_FILE_NOT_FOUND:
errno=ENOENT;
break;
case ERROR_PATH_NOT_FOUND:
case ERROR_INVALID_DRIVE:
errno=ENOTDIR;
break;
/*case ERROR_WRITE_PROTECT: //CreateFile sets ERROR_ACCESS_DENIED on read-only devices
* errno=EROFS;
* break;*/
case ERROR_ACCESS_DENIED:
errno=EACCES;
break;
default:
errno=ENOENT; //what other errors can occur?
}
return -1;
}
if(!SetFileTime(hFile, NULL, &LastAccessTime, &LastModificationTime)) {
//can this happen?
errno=ENOENT;
CloseHandle(hFile);
c_free_locale_string(wuri);
return -1;
}
CloseHandle(hFile);
c_free_locale_string(wuri);
return 0;
}
int csync_vio_local_stat(const char *uri, csync_vio_file_stat_t *buf) {
/* Almost nothing to do since csync_vio_local_readdir already filled up most of the information
But we still need to fetch the file ID.
Possible optimisation: only fetch the file id when we need it (for new files)
*/
HANDLE h;
BY_HANDLE_FILE_INFORMATION fileInfo;
ULARGE_INTEGER FileIndex;
mbchar_t *wuri = c_utf8_path_to_locale( uri );
h = CreateFileW( wuri, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL+FILE_FLAG_BACKUP_SEMANTICS+FILE_FLAG_OPEN_REPARSE_POINT, NULL );
if( h == INVALID_HANDLE_VALUE ) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_CRIT, "CreateFileW failed on %s", uri );
errno = GetLastError();
c_free_locale_string(wuri);
return -1;
}
if(!GetFileInformationByHandle( h, &fileInfo ) ) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_CRIT, "GetFileInformationByHandle failed on %s", uri );
errno = GetLastError();
c_free_locale_string(wuri);
CloseHandle(h);
return -1;
}
/* Get the Windows file id as an inode replacement. */
FileIndex.HighPart = fileInfo.nFileIndexHigh;
FileIndex.LowPart = fileInfo.nFileIndexLow;
FileIndex.QuadPart &= 0x0000FFFFFFFFFFFF;
/* printf("Index: %I64i\n", FileIndex.QuadPart); */
buf->inode = FileIndex.QuadPart;
if (!(buf->fields & CSYNC_VIO_FILE_STAT_FIELDS_SIZE)) {
buf->size = (fileInfo.nFileSizeHigh * ((int64_t)(MAXDWORD)+1)) + fileInfo.nFileSizeLow;
buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_SIZE;
}
if (!(buf->fields & CSYNC_VIO_FILE_STAT_FIELDS_MTIME)) {
DWORD rem;
buf->mtime = FileTimeToUnixTime(&fileInfo.ftLastWriteTime, &rem);
/* CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Local File MTime: %llu", (unsigned long long) buf->mtime ); */
buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_MTIME;
}
c_free_locale_string(wuri);
CloseHandle(h);
return 0;
}
static void setup_dir(void **state) {
int rc;
mbchar_t *dir = c_utf8_path_to_locale(CSYNC_TEST_DIR);
setup(state);
rc = _tmkdir(dir, MKDIR_MASK);
c_free_locale_string(dir);
assert_int_equal(rc, 0);
assert_non_null(getcwd(wd_buffer, WD_BUFFER_SIZE));
rc = chdir(CSYNC_TEST_DIR);
assert_int_equal(rc, 0);
}
static void create_file( const char *path, const char *name, const char *content)
{
#ifdef _WIN32
char *filepath = c_malloc( 2+strlen(CSYNC_TEST_DIR)+strlen(path) + strlen(name) );
*filepath = '\0';
strcpy(filepath, CSYNC_TEST_DIR);
strcat(filepath, "/");
strcat(filepath, path);
strcat(filepath, name);
DWORD dwWritten; // number of bytes written to file
HANDLE hFile;
mbchar_t *w_fname = c_utf8_path_to_locale(filepath);
hFile=CreateFile(w_fname, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, 0,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
assert_int_equal( 0, hFile==INVALID_HANDLE_VALUE );
int len = strlen(content);
mbchar_t *dst = NULL;
dst = c_utf8_string_to_locale(content);
WriteFile(hFile, dst, len * sizeof(mbchar_t), &dwWritten, 0);
CloseHandle(hFile);
SAFE_FREE(dst);
c_free_locale_string(w_fname);
#else
char *filepath = c_malloc( 1+strlen(path) + strlen(name) );
*filepath = '\0';
strcpy(filepath, path);
strcat(filepath, name);
FILE *sink;
sink = fopen(filepath,"w");
fprintf (sink, "we got: %s",content);
fclose(sink);
SAFE_FREE(filepath);
#endif
}
static void check_iconv_to_native_normalization(void **state)
{
mbchar_t *out = NULL;
const char *in= "\x48\xc3\xa4"; // UTF8
#ifdef __APPLE__
const char *exp_out = "\x48\x61\xcc\x88"; // UTF-8-MAC
#else
const char *exp_out = "\x48\xc3\xa4"; // UTF8
#endif
out = c_utf8_path_to_locale(in);
assert_string_equal(out, exp_out);
c_free_locale_string(out);
assert_null(out);
(void) state; /* unused */
}
static void check_csync_vio_opendir_perm(void **state)
{
CSYNC *csync = *state;
csync_vio_handle_t *dh;
int rc;
mbchar_t *dir = c_utf8_path_to_locale(CSYNC_TEST_DIR);
assert_non_null(dir);
rc = _tmkdir(dir, (S_IWUSR|S_IXUSR));
assert_int_equal(rc, 0);
dh = csync_vio_opendir(csync, CSYNC_TEST_DIR);
assert_null(dh);
assert_int_equal(errno, EACCES);
_tchmod(dir, MKDIR_MASK);
c_free_locale_string(dir);
}
csync_vio_handle_t *csync_vio_local_opendir(const char *name) {
dhandle_t *handle = NULL;
mbchar_t *dirname = NULL;
handle = c_malloc(sizeof(dhandle_t));
// the file wildcard has to be attached
int len_name = strlen(name);
if( len_name ) {
char *h = NULL;
// alloc an enough large buffer to take the name + '/*' + the closing zero.
h = c_malloc(len_name+3);
strncpy( h, name, 1+len_name);
strncat(h, "/*", 2);
dirname = c_utf8_path_to_locale(h);
SAFE_FREE(h);
}
if( dirname ) {
handle->hFind = FindFirstFile(dirname, &(handle->ffd));
}
if (!dirname || handle->hFind == INVALID_HANDLE_VALUE) {
int retcode = GetLastError();
if( retcode == ERROR_FILE_NOT_FOUND ) {
errno = ENOENT;
} else {
errno = EACCES;
}
SAFE_FREE(handle);
return NULL;
}
handle->firstFind = 1; // Set a flag that there first fileinfo is available.
handle->path = c_strdup(name);
c_free_locale_string(dirname);
return (csync_vio_handle_t *) handle;
}
static void check_csync_statedb_close(void **state)
{
CSYNC *csync = *state;
csync_stat_t sb;
time_t modtime;
mbchar_t *testdb = c_utf8_path_to_locale(TESTDB);
int rc;
/* statedb not written */
csync_statedb_load(csync, TESTDB, &csync->statedb.db);
rc = _tstat(testdb, &sb);
assert_int_equal(rc, 0);
modtime = sb.st_mtime;
rc = csync_statedb_close(csync);
assert_int_equal(rc, 0);
rc = _tstat(testdb, &sb);
assert_int_equal(rc, 0);
assert_int_equal(modtime, sb.st_mtime);
csync_statedb_load(csync, TESTDB, &csync->statedb.db);
rc = _tstat(testdb, &sb);
assert_int_equal(rc, 0);
modtime = sb.st_mtime;
/* wait a sec or the modtime will be the same */
sleep(1);
/* statedb written */
rc = csync_statedb_close(csync);
assert_int_equal(rc, 0);
rc = _tstat(testdb, &sb);
assert_int_equal(rc, 0);
c_free_locale_string(testdb);
}
/* remove the complete test dir */
static int wipe_testdir()
{
int rc = 0;
#ifdef _WIN32
/* The windows system call to rd bails out if the dir is not existing
* Check first.
*/
WIN32_FIND_DATA FindFileData;
mbchar_t *dir = c_utf8_path_to_locale(CSYNC_TEST_DIR);
HANDLE handle = FindFirstFile(dir, &FindFileData);
c_free_locale_string(dir);
int found = handle != INVALID_HANDLE_VALUE;
if(found) {
FindClose(handle);
rc = system("rd /s /q C:\\tmp\\csync_test");
}
#else
rc = system("rm -rf /tmp/csync_test/");
#endif
return rc;
}
int csync_exclude_load(const char *fname, c_strlist_t **list) {
int fd = -1;
int i = 0;
int rc = -1;
int64_t size;
char *buf = NULL;
char *entry = NULL;
mbchar_t *w_fname;
if (fname == NULL) {
return -1;
}
#ifdef _WIN32
_fmode = _O_BINARY;
#endif
w_fname = c_utf8_path_to_locale(fname);
if (w_fname == NULL) {
return -1;
}
fd = _topen(w_fname, O_RDONLY);
c_free_locale_string(w_fname);
if (fd < 0) {
return -1;
}
size = lseek(fd, 0, SEEK_END);
if (size < 0) {
rc = -1;
goto out;
}
lseek(fd, 0, SEEK_SET);
if (size == 0) {
rc = 0;
goto out;
}
buf = c_malloc(size + 1);
if (read(fd, buf, size) != size) {
rc = -1;
goto out;
}
buf[size] = '\0';
/* FIXME: Use fgets and don't add duplicates */
entry = buf;
for (i = 0; i < size; i++) {
if (buf[i] == '\n' || buf[i] == '\r') {
if (entry != buf + i) {
buf[i] = '\0';
if (*entry != '#') {
const char *unescaped = csync_exclude_expand_escapes(entry);
rc = _csync_exclude_add(list, unescaped);
if( rc == 0 ) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_TRACE, "Adding entry: %s", unescaped);
}
SAFE_FREE(unescaped);
if (rc < 0) {
goto out;
}
}
}
entry = buf + i + 1;
}
}
rc = 0;
out:
SAFE_FREE(buf);
close(fd);
return rc;
}
int csync_vio_local_stat(const char *uri, csync_vio_file_stat_t *buf) {
HANDLE h, hFind;
FILETIME ftCreate, ftAccess, ftWrite;
BY_HANDLE_FILE_INFORMATION fileInfo;
WIN32_FIND_DATAW FindFileData;
ULARGE_INTEGER FileIndex;
mbchar_t *wuri = c_utf8_path_to_locale( uri );
h = CreateFileW( wuri, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL+FILE_FLAG_BACKUP_SEMANTICS, NULL );
if( h == INVALID_HANDLE_VALUE ) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_CRIT, "CreateFileW failed on %s", uri );
errno = GetLastError();
c_free_locale_string(wuri);
return -1;
}
if(!GetFileInformationByHandle( h, &fileInfo ) ) {
CSYNC_LOG(CSYNC_LOG_PRIORITY_CRIT, "GetFileInformationByHandle failed on %s", uri );
errno = GetLastError();
c_free_locale_string(wuri);
CloseHandle(h);
return -1;
}
buf->flags = CSYNC_VIO_FILE_FLAGS_NONE;
do {
// Check first if it is a symlink (code from c_islink)
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
hFind = FindFirstFileW(wuri, &FindFileData );
if (hFind != INVALID_HANDLE_VALUE) {
if( (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) &&
(FindFileData.dwReserved0 & IO_REPARSE_TAG_SYMLINK) ) {
buf->flags = CSYNC_VIO_FILE_FLAGS_SYMLINK;
buf->type = CSYNC_VIO_FILE_TYPE_SYMBOLIC_LINK;
break;
}
}
FindClose(hFind);
}
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DEVICE
|| fileInfo.dwFileAttributes & FILE_ATTRIBUTE_OFFLINE
|| fileInfo.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) {
buf->type = CSYNC_VIO_FILE_TYPE_UNKNOWN;
break;
}
if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
buf->type = CSYNC_VIO_FILE_TYPE_DIRECTORY;
break;
}
// fallthrough:
buf->type = CSYNC_VIO_FILE_TYPE_REGULAR;
break;
} while (0);
/* Check for the hidden flag */
if( fileInfo.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN ) {
buf->flags |= CSYNC_VIO_FILE_FLAGS_HIDDEN;
}
buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_FLAGS;
buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_TYPE;
buf->device = fileInfo.dwVolumeSerialNumber;
buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_DEVICE;
/* Get the Windows file id as an inode replacement. */
FileIndex.HighPart = fileInfo.nFileIndexHigh;
FileIndex.LowPart = fileInfo.nFileIndexLow;
FileIndex.QuadPart &= 0x0000FFFFFFFFFFFF;
/* printf("Index: %I64i\n", FileIndex.QuadPart); */
buf->inode = FileIndex.QuadPart;
buf->size = (fileInfo.nFileSizeHigh * ((int64_t)(MAXDWORD)+1)) + fileInfo.nFileSizeLow;
buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_SIZE;
/* Get the file time with a win32 call rather than through stat. See
* http://www.codeproject.com/Articles/1144/Beating-the-Daylight-Savings-Time-bug-and-getting
* for deeper explanation.
*/
if( GetFileTime(h, &ftCreate, &ftAccess, &ftWrite) ) {
DWORD rem;
buf->atime = FileTimeToUnixTime(&ftAccess, &rem);
buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_ATIME;
buf->mtime = FileTimeToUnixTime(&ftWrite, &rem);
/* CSYNC_LOG(CSYNC_LOG_PRIORITY_DEBUG, "Local File MTime: %llu", (unsigned long long) buf->mtime ); */
buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_MTIME;
buf->ctime = FileTimeToUnixTime(&ftCreate, &rem);
buf->fields |= CSYNC_VIO_FILE_STAT_FIELDS_CTIME;
}
c_free_locale_string(wuri);
CloseHandle(h);
return 0;
}
int c_utimes(const char *uri, const struct timeval *times) {
mbchar_t *wuri = c_utf8_path_to_locale(uri);
int ret = utimes(wuri, times);
c_free_locale_string(wuri);
return ret;
}