int CFileSMB::Stat(const CURL& url, struct __stat64* buffer)
{
smb.Init();
CStdString strFileName = GetAuthenticatedPath(url);
CSingleLock lock(smb);
#ifndef _LINUX
struct __stat64 tmpBuffer = {0};
#else
struct stat tmpBuffer = {0};
#endif
int iResult = smbc_stat(strFileName, &tmpBuffer);
memset(buffer, 0, sizeof(struct __stat64));
buffer->st_dev = tmpBuffer.st_dev;
buffer->st_ino = tmpBuffer.st_ino;
buffer->st_mode = tmpBuffer.st_mode;
buffer->st_nlink = tmpBuffer.st_nlink;
buffer->st_uid = tmpBuffer.st_uid;
buffer->st_gid = tmpBuffer.st_gid;
buffer->st_rdev = tmpBuffer.st_rdev;
buffer->st_size = tmpBuffer.st_size;
buffer->st_atime = tmpBuffer.st_atime;
buffer->st_mtime = tmpBuffer.st_mtime;
buffer->st_ctime = tmpBuffer.st_ctime;
return iResult;
}
CSMBFile::CSMBFile()
{
smb.Init();
m_fd = -1;
smb.AddActiveConnection();
m_allowRetry = true;
}
bool CSMBFile::OpenForWrite(const CURL& url, bool bOverWrite)
{
m_fileSize = 0;
Close();
smb.Init();
// we can't open files like smb://file.f or smb://server/file.f
// if a file matches the if below return false, it can't exist on a samba share.
if (!IsValidFile(url.GetFileName())) return false;
std::string strFileName = GetAuthenticatedPath(url);
CSingleLock lock(smb);
if (bOverWrite)
{
CLog::Log(LOGWARNING, "SMBFile::OpenForWrite() called with overwriting enabled! - %s", strFileName.c_str());
m_fd = smbc_creat(strFileName.c_str(), 0);
}
else
{
m_fd = smbc_open(strFileName.c_str(), O_RDWR, 0);
}
if (m_fd == -1)
{
// write error to logfile
CLog::Log(LOGERROR, "SMBFile->Open: Unable to open file : '%s'\nunix_err:'%x' error : '%s'", strFileName.c_str(), errno, strerror(errno));
return false;
}
// We've successfully opened the file!
return true;
}
int64_t CSMBFile::GetPosition()
{
if (m_fd == -1)
return -1;
smb.Init();
CSingleLock lock(smb);
return smbc_lseek(m_fd, 0, SEEK_CUR);
}
CFileSMB::CFileSMB()
{
smb.Init();
m_fd = -1;
#ifdef _LINUX
smb.AddActiveConnection();
#endif
}
CSmbFile::CSmbFile()
{
smb.Init();
m_fd = -1;
#ifdef TARGET_POSIX
smb.AddActiveConnection();
#endif
}
ssize_t CSMBFile::Write(const void* lpBuf, size_t uiBufSize)
{
if (m_fd == -1) return -1;
// lpBuf can be safely casted to void* since xbmc_write will only read from it.
smb.Init();
CSingleLock lock(smb);
return smbc_write(m_fd, (void*)lpBuf, uiBufSize);
}
int64_t CSMBFile::GetPosition()
{
if (m_fd == -1) return 0;
smb.Init();
CSingleLock lock(smb);
int64_t pos = smbc_lseek(m_fd, 0, SEEK_CUR);
if ( pos < 0 )
return 0;
return pos;
}
int CSMBFile::Stat(const CURL& url, struct __stat64* buffer)
{
smb.Init();
std::string strFileName = GetAuthenticatedPath(url);
CSingleLock lock(smb);
struct stat tmpBuffer = {0};
int iResult = smbc_stat(strFileName.c_str(), &tmpBuffer);
CUtil::StatToStat64(buffer, &tmpBuffer);
return iResult;
}
int64_t CFile::GetPosition()
{
if (m_fd == -1)
return 0;
smb.Init();
PLATFORM::CLockObject lock(smb);
int64_t pos = smbc_lseek(m_fd, 0, SEEK_CUR);
if ( pos < 0 )
return 0;
return pos;
}
int CSMBFile::Write(const void* lpBuf, int64_t uiBufSize)
{
if (m_fd == -1) return -1;
DWORD dwNumberOfBytesWritten = 0;
// lpBuf can be safely casted to void* since xbmc_write will only read from it.
smb.Init();
CSingleLock lock(smb);
dwNumberOfBytesWritten = smbc_write(m_fd, (void*)lpBuf, (DWORD)uiBufSize);
return (int)dwNumberOfBytesWritten;
}
//int CFile::OpenFile(const CURL &url, CStdString& strAuth)
int CFile::OpenFile()
{
int fd = -1;
smb.Init();
//strAuth = GetAuthenticatedPath(url);
//CStdString strPath = strAuth;
CStdString strPath = m_fileName;
{
CLockObject lock(smb);
fd = smbc_open(strPath.c_str(), O_RDONLY, 0);
}
// file open failed, try to open the directory to force authentication
if (fd < 0 && errno == EACCES)
{
#if 0
CURL urlshare(url);
/* just replace the filename with the sharename */
urlshare.SetFileName(url.GetShareName());
CSMBDirectory smbDir;
// TODO: Currently we always allow prompting on files. This may need to
// change in the future as background scanners are more prolific.
smbDir.SetFlags(DIR_FLAG_ALLOW_PROMPT);
fd = smbDir.Open(urlshare);
// directory open worked, try opening the file again
if (fd >= 0)
{
CLockObject lock(smb);
// close current directory filehandle
// dont need to purge since its the same server and share
smbc_closedir(fd);
// set up new filehandle (as CFile::Open does)
strPath = GetAuthenticatedPath(url);
fd = smbc_open(strPath.c_str(), O_RDONLY, 0);
}
#else
XBMC->Log(LOG_ERROR, "%s: File open on %s failed\n", __FUNCTION__, strPath.c_str());
#endif
}
// if (fd >= 0)
// strAuth = strPath;
return fd;
}
bool CSMBFile::Delete(const CURL& url)
{
smb.Init();
std::string strFile = GetAuthenticatedPath(url);
CSingleLock lock(smb);
int result = smb.GetImpl()->smbc_unlink(strFile.c_str());
if (result != 0)
CLog::Log(LOGERROR, "%s - Error( %s )", __FUNCTION__, strerror(errno));
return (result == 0);
}
int CFileSMB::OpenFile(const CURL &url, CStdString& strAuth)
{
int fd = -1;
smb.Init();
strAuth = GetAuthenticatedPath(url);
CStdString strPath = strAuth;
{
CSingleLock lock(smb);
fd = smbc_open(strPath.c_str(), O_RDONLY, 0);
}
// file open failed, try to open the directory to force authentication
#ifndef _LINUX
if (fd < 0 && smb.ConvertUnixToNT(errno) == NT_STATUS_ACCESS_DENIED)
#else
if (fd < 0 && errno == EACCES)
#endif
{
CURL urlshare(url);
/* just replace the filename with the sharename */
urlshare.SetFileName(url.GetShareName());
CSMBDirectory smbDir;
// TODO: Currently we always allow prompting on files. This may need to
// change in the future as background scanners are more prolific.
smbDir.SetAllowPrompting(true);
fd = smbDir.Open(urlshare);
// directory open worked, try opening the file again
if (fd >= 0)
{
CSingleLock lock(smb);
// close current directory filehandle
// dont need to purge since its the same server and share
smbc_closedir(fd);
// set up new filehandle (as CFileSMB::Open does)
strPath = GetAuthenticatedPath(url);
fd = smbc_open(strPath.c_str(), O_RDONLY, 0);
}
}
if (fd >= 0)
strAuth = strPath;
return fd;
}
bool CFile::Rename(const CURL& url, const CURL& urlnew)
{
smb.Init();
CStdString strFile = GetAuthenticatedPath(url);
CStdString strFileNew = GetAuthenticatedPath(urlnew);
CLockObject lock(smb);
int result = smbc_rename(strFile.c_str(), strFileNew.c_str());
if(result != 0)
XBMC->Log(LOG_ERROR, "%s - Error( %s )", __FUNCTION__, strerror(errno));
return (result == 0);
}
bool CSMBFile::Rename(const CURL& url, const CURL& urlnew)
{
smb.Init();
std::string strFile = GetAuthenticatedPath(url);
std::string strFileNew = GetAuthenticatedPath(urlnew);
CSingleLock lock(smb);
int result = smbc_rename(strFile.c_str(), strFileNew.c_str());
if(result != 0)
CLog::Log(LOGERROR, "%s - Error( %s )", __FUNCTION__, strerror(errno));
return (result == 0);
}
int CSMBFile::OpenFile(const CURL &url, std::string& strAuth)
{
smb.Init();
strAuth = GetAuthenticatedPath(url);
std::string strPath = strAuth;
int fd = -1;
{
CSingleLock lock(smb);
fd = smb.GetImpl()->smbc_open(strPath.c_str(), O_RDONLY, 0);
}
if (fd >= 0)
strAuth = strPath;
return fd;
}
bool CFile::Exists(const CStdString& strFileName, bool bUseCache)
{
// we can't open files like smb://file.f or smb://server/file.f
// if a file matches the if below return false, it can't exist on a samba share.
//if (!IsValidFile(url.GetFileName())) return false;
smb.Init();
struct stat info;
CLockObject lock(smb);
int iResult = smbc_stat(strFileName, &info);
if (iResult < 0)
return false;
return true;
}
bool CSMBFile::Exists(const CURL& url)
{
// we can't open files like smb://file.f or smb://server/file.f
// if a file matches the if below return false, it can't exist on a samba share.
if (!IsValidFile(url.GetFileName())) return false;
smb.Init();
std::string strFileName = GetAuthenticatedPath(url);
struct stat info;
CSingleLock lock(smb);
int iResult = smbc_stat(strFileName.c_str(), &info);
if (iResult < 0) return false;
return true;
}
bool CSmbFile::Delete(const CURL& url)
{
smb.Init();
CStdString strFile = GetAuthenticatedPath(url);
CSingleLock lock(smb);
int result = smbc_unlink(strFile.c_str());
if(result != 0)
#ifdef TARGET_WINDOWS
CLog::Log(LOGERROR, "%s - Error( %s )", __FUNCTION__, get_friendly_nt_error_msg(smb.ConvertUnixToNT(errno)));
#else
CLog::Log(LOGERROR, "%s - Error( %s )", __FUNCTION__, strerror(errno));
#endif
return (result == 0);
}
bool CFileSMB::Rename(const CURL& url, const CURL& urlnew)
{
smb.Init();
CStdString strFile = GetAuthenticatedPath(url);
CStdString strFileNew = GetAuthenticatedPath(urlnew);
CSingleLock lock(smb);
int result = smbc_rename(strFile.c_str(), strFileNew.c_str());
if(result != 0)
#ifndef _LINUX
CLog::Log(LOGERROR, "%s - Error( %s )", __FUNCTION__, get_friendly_nt_error_msg(smb.ConvertUnixToNT(errno)));
#else
CLog::Log(LOGERROR, "%s - Error( %s )", __FUNCTION__, strerror(errno));
#endif
return (result == 0);
}
int CSmbFile::OpenFile(const CURL &url, CStdString& strAuth)
{
int fd = -1;
smb.Init();
strAuth = GetAuthenticatedPath(url);
CStdString strPath = strAuth;
{
CSingleLock lock(smb);
fd = smbc_open(strPath.c_str(), O_RDONLY, 0);
}
if (fd >= 0)
strAuth = strPath;
return fd;
}
int CFile::OpenFile()
{
int fd = -1;
smb.Init();
CStdString strPath = m_fileName;
{
CLockObject lock(smb);
fd = smbc_open(strPath.c_str(), O_RDONLY, 0);
}
// file open failed, try to open the directory to force authentication
if (fd < 0 && errno == EACCES)
{
XBMC->Log(LOG_ERROR, "%s: File open on %s failed\n", __FUNCTION__, strPath.c_str());
}
return fd;
}
bool CFileSMB::Exists(const CURL& url)
{
// we can't open files like smb://file.f or smb://server/file.f
// if a file matches the if below return false, it can't exist on a samba share.
if (!IsValidFile(url.GetFileName())) return false;
smb.Init();
CStdString strFileName = GetAuthenticatedPath(url);
#ifndef _LINUX
struct __stat64 info;
#else
struct stat info;
#endif
CSingleLock lock(smb);
int iResult = smbc_stat(strFileName, &info);
if (iResult < 0) return false;
return true;
}
int CSMBFile::Stat(const CURL& url, struct __stat64* buffer)
{
smb.Init();
std::string strFileName = GetAuthenticatedPath(url);
CSingleLock lock(smb);
struct stat tmpBuffer = {0};
int iResult = smbc_stat(strFileName.c_str(), &tmpBuffer);
memset(buffer, 0, sizeof(struct __stat64));
buffer->st_dev = tmpBuffer.st_dev;
buffer->st_ino = tmpBuffer.st_ino;
buffer->st_mode = tmpBuffer.st_mode;
buffer->st_nlink = tmpBuffer.st_nlink;
buffer->st_uid = tmpBuffer.st_uid;
buffer->st_gid = tmpBuffer.st_gid;
buffer->st_rdev = tmpBuffer.st_rdev;
buffer->st_size = tmpBuffer.st_size;
buffer->st_atime = tmpBuffer.st_atime;
buffer->st_mtime = tmpBuffer.st_mtime;
buffer->st_ctime = tmpBuffer.st_ctime;
return iResult;
}
CSMBFile::CSMBFile()
{
smb.Init();
m_fd = -1;
smb.AddActiveConnection();
}