int main(int argc, char** argv)
{
int err = -1;
int fd = 0;
char url[MAX_BUFF_SIZE];
bzero(g_workgroup,MAX_BUFF_SIZE);
bzero(url,MAX_BUFF_SIZE);
if ( argc == 5 )
{
strncpy(g_workgroup,argv[1],strlen(argv[1]));
strncpy(g_username,argv[2],strlen(argv[2]));
strncpy(g_password,argv[3],strlen(argv[3]));
strncpy(url,argv[4],strlen(argv[4]));
smbc_init(auth_fn, 0);
fd = smbc_open(url, O_RDWR | O_CREAT, 0666);
smbc_close(fd);
fd = smbc_open(url, O_RDWR, 0666);
err = errno;
}
return err;
}
int main(int argc, char** argv)
{
int err = -1;
int fd = 0;
int msg_len = 0;
char url[MAX_BUFF_SIZE];
char* message;
char* response;
memset(g_workgroup, '\0', MAX_BUFF_SIZE);
memset(url, '\0', MAX_BUFF_SIZE);
if ( argc == 6 )
{
strncpy(g_workgroup,argv[1],strlen(argv[1]));
strncpy(g_username,argv[2],strlen(argv[2]));
strncpy(g_password,argv[3],strlen(argv[3]));
strncpy(url,argv[4],strlen(argv[4]));
msg_len = strlen(argv[5])+1;
message = malloc(msg_len);
response = malloc(msg_len);
message[msg_len - 1] = 0;
strncpy(message,argv[5],msg_len);
smbc_init(auth_fn, 0);
smbc_unlink(url);
fd = smbc_open(url,O_RDWR | O_CREAT, 0666);
smbc_close(fd);
strncpy(g_username,"xxxxxxxx",8);
strncpy(g_password,"xxxxxxxx",8);
fd = smbc_open(url, O_RDWR, 0666);
if (fd < 0)
err = errno;
else {
smbc_write(fd, message, msg_len);
err = errno;
smbc_close(fd);
}
free(message);
free(response);
}
return err;
}
int main(int argc, char** argv)
{
int err = -1;
int fd = 0;
int msg_len = 0;
char url[MAX_BUFF_SIZE];
char* message;
char* response;
bzero(g_workgroup,MAX_BUFF_SIZE);
bzero(url,MAX_BUFF_SIZE);
if ( argc == 6 )
{
strncpy(g_workgroup,argv[1],strlen(argv[1]));
strncpy(g_username,argv[2],strlen(argv[2]));
strncpy(g_password,argv[3],strlen(argv[3]));
strncpy(url,argv[4],strlen(argv[4]));
msg_len = strlen(argv[5])+1;
message = malloc(msg_len);
response = malloc(msg_len);
message[msg_len - 1] = 0;
strncpy(message,argv[5],msg_len);
smbc_init(auth_fn, 0);
smbc_unlink(url);
fd = smbc_open(url,O_RDWR | O_CREAT, 0666);
smbc_write(fd, message, msg_len);
smbc_close(fd);
fd = smbc_open(url,O_WRONLY, 0666);
err = smbc_read(fd,response,msg_len);
free(message);
free(response);
if ( err < 0 )
err = 1;
else if ( err != msg_len )
err = 1;
else
err = 0;
}
return err;
}
//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;
}
static int smbcfs_open(const char* const path, struct fuse_file_info* const fi)
{
const std::string smbcfs_path = smbcfs_root_path + path;
#ifdef MUTEX_LOCK
pthread_mutex_lock(&mutex_lock);
#endif
const int ret_open = smbc_open(smbcfs_path.c_str(), fi->flags, 0);
#ifdef MUTEX_LOCK
pthread_mutex_unlock(&mutex_lock);
#endif
#ifdef SMBCFS_DEBUG
fprintf(stderr, "[smbc_open] %s %p => %d\n",
smbcfs_path.c_str(), fi, ret_open);
#endif
if(ret_open<0) { return ret_open; }
fi->fh = ret_open;
return 0;
}
int main(int argc, char* argv[])
{
int fd;
struct stat st1;
struct stat st2;
char * pUrl = argv[1];
if(argc != 2)
{
printf("usage: %s <file_url>\n", argv[0]);
return 1;
}
smbc_init(get_auth_data_fn, 0);
if (smbc_stat(pUrl, &st1) < 0)
{
perror("smbc_stat");
return 1;
}
if ((fd = smbc_open(pUrl, O_RDONLY, 0)) < 0)
{
perror("smbc_open");
return 1;
}
if (smbc_fstat(fd, &st2) < 0)
{
perror("smbc_fstat");
return 1;
}
smbc_close(fd);
#define COMPARE(name, field) \
if (st1.field != st2.field) \
{ \
printf("Field " name " MISMATCH: st1=%lu, st2=%lu\n", \
(unsigned long) st1.field, \
(unsigned long) st2.field); \
}
COMPARE("st_dev", st_dev);
COMPARE("st_ino", st_ino);
COMPARE("st_mode", st_mode);
COMPARE("st_nlink", st_nlink);
COMPARE("st_uid", st_uid);
COMPARE("st_gid", st_gid);
COMPARE("st_rdev", st_rdev);
COMPARE("st_size", st_size);
COMPARE("st_blksize", st_blksize);
COMPARE("st_blocks", st_blocks);
COMPARE("st_atime", st_atime);
COMPARE("st_mtime", st_mtime);
COMPARE("st_ctime", st_ctime);
return 0;
}
void* OpenForWrite(VFSURL* url, bool bOverWrite)
{
CSMB2::Get().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->filename))
return NULL;
std::string strFileName = GetAuthenticatedPath(url);
PLATFORM::CLockObject lock(CSMB2::Get());
SMBContext* result = new SMBContext;
if (bOverWrite)
{
XBMC->Log(ADDON::LOG_INFO, "FileSmb::OpenForWrite() called with overwriting enabled! - %s", strFileName.c_str());
result->fd = smbc_creat(strFileName.c_str(), 0);
}
else
{
result->fd = smbc_open(strFileName.c_str(), O_RDWR, 0);
}
if (result->fd == -1)
{
// write error to logfile
XBMC->Log(ADDON::LOG_ERROR, "FileSmb->Open: Unable to open file : '%s'\nunix_err:'%x' error : '%s'", strFileName.c_str(), errno, strerror(errno));
delete result;
return NULL;
}
// We've successfully opened the file!
return result;
}
static int open_f (stream_t *stream, int mode, void *opts, int* file_format) {
struct stream_priv_s *p = (struct stream_priv_s*)opts;
char *filename;
mode_t m = 0;
off_t len;
int fd, err;
filename = stream->url;
if(mode == STREAM_READ)
m = O_RDONLY;
else if (mode == STREAM_WRITE) //who's gonna do that ?
m = O_RDWR|O_CREAT|O_TRUNC;
else {
mp_msg(MSGT_OPEN, MSGL_ERR, "[smb] Unknown open mode %d\n", mode);
m_struct_free (&stream_opts, opts);
return STREAM_UNSUPPORTED;
}
if(!filename) {
mp_msg(MSGT_OPEN,MSGL_ERR, "[smb] Bad url\n");
m_struct_free(&stream_opts, opts);
return STREAM_ERROR;
}
err = smbc_init(smb_auth_fn, 1);
if (err < 0) {
mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_SMBInitError,err);
m_struct_free(&stream_opts, opts);
return STREAM_ERROR;
}
fd = smbc_open(filename, m,0644);
if (fd < 0) {
mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_SMBFileNotFound, filename);
m_struct_free(&stream_opts, opts);
return STREAM_ERROR;
}
stream->flags = mode;
len = 0;
if(mode == STREAM_READ) {
len = smbc_lseek(fd,0,SEEK_END);
smbc_lseek (fd, 0, SEEK_SET);
}
if(len > 0 || mode == STREAM_WRITE) {
stream->flags |= MP_STREAM_SEEK;
stream->seek = seek;
if(mode == STREAM_READ) stream->end_pos = len;
}
stream->type = STREAMTYPE_SMB;
stream->fd = fd;
stream->fill_buffer = fill_buffer;
stream->write_buffer = write_buffer;
stream->close = close_f;
stream->control = control;
m_struct_free(&stream_opts, opts);
return STREAM_OK;
}
int main(int argc, char** argv)
{
int err = -1;
int fd1 = 0;
char url[MAX_BUFF_SIZE];
memset(g_workgroup, '\0', MAX_BUFF_SIZE);
memset(url, '\0', MAX_BUFF_SIZE);
if ( argc == 5 )
{
strncpy( g_workgroup, argv[1], strlen(argv[1]) );
strncpy( g_username, argv[2], strlen(argv[2]) );
strncpy( g_password, argv[3], strlen(argv[3]) );
strncpy( url, argv[4], strlen(argv[4]) );
smbc_init( auth_fn, 0 );
fd1 = smbc_open( url, O_RDWR | O_CREAT, 0666 );
smbc_close( fd1 );
err = smbc_rmdir( url );
if ( err < 0 )
err = 1;
else
err = 0;
}
return err;
}
int main(int argc, char** argv)
{
int err = -1;
char url[MAX_BUFF_SIZE];
bzero(g_workgroup,MAX_BUFF_SIZE);
bzero(url,MAX_BUFF_SIZE);
if ( argc == 6 )
{
strncpy(g_workgroup,argv[1],strlen(argv[1]));
strncpy(g_username,argv[2],strlen(argv[2]));
strncpy(g_password,argv[3],strlen(argv[3]));
strncpy(url,argv[4],strlen(argv[4]));
smbc_init(auth_fn, 0);
smbc_open(url,O_RDWR | O_CREAT,0666);
err = smbc_rename( url, argv[5] );
if ( err < 0 )
err = 1;
}
return err;
}
bool CFile::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;
CStdString strFileName = GetAuthenticatedPath(url);
CLockObject lock(smb);
if (bOverWrite)
{
XBMC->Log(LOG_WARNING, "FileSmb::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
XBMC->Log(LOG_ERROR, "FileSmb->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;
}
int get_smb_server_fd(struct SMB_DS *ds, char* filename)
{
int ret, fd, i;
char buf[256+1];
ret = smbc_init(smb_auth_fn, 0);NE_ERR(ret, 0);
for(i=0;i<strlen(ds->path);i++)
{
if(ds->path[i]=='\\')
ds->path[i] = '/';
}
sprintf(buf, "smb://%s/%s/%s", ds->server, ds->path, filename);
buf[256]='\0';
//fprintf(stderr, "%s\n", buf);
if(ds->user[0]!='\0')
strcpy(smb_username, ds->user);
else
strcpy(smb_username, "dummy");
strcpy(smb_password, ds->passwd);
//fprintf(stderr, "%s %s\n", smb_username, smb_password);
fd = smbc_open(buf, O_RDWR | O_CREAT | O_TRUNC, 0666);EQ_ERR(fd, -1);
return fd;
errout:
if(fd != -1)
smbc_close(fd);
return -1;
}
/*****************************************************
a wrapper for open()
*******************************************************/
int smbw_open(const char *fname, int flags, mode_t mode)
{
int client_fd;
int smbw_fd;
char path[PATH_MAX];
SMBW_INIT();
if (!fname) {
errno = EINVAL;
return -1;
}
smbw_fd = (smbw_libc.open)(SMBW_DUMMY, O_WRONLY, 0200);
if (smbw_fd == -1) {
errno = EMFILE;
return -1;
}
smbw_fix_path(fname, path);
if (flags == creat_bits) {
client_fd = smbc_creat(path, mode);
} else {
client_fd = smbc_open(path, flags, mode);
}
if (client_fd < 0) {
(* smbw_libc.close)(smbw_fd);
return -1;
}
smbw_fd_map[smbw_fd] = client_fd;
smbw_ref(client_fd, SMBW_RCT_Increment);
return smbw_fd;
}
int FSSmb::OpenRead( FSPath& path, int flags, int* err, FSCInfo* info )
{
FREPARE_SMB_OPER( lock, info, &_param );
int n = smbc_open( pathBuffer1.SetPath( path ), O_RDONLY | OPENFLAG_LARGEFILE, 0 );
SetError( err, errno );
return n < 0 ? -1 : n;
}
int FSSmb::OpenCreate( FSPath& path, bool overwrite, int mode, int flags, int* err, FSCInfo* info )
{
FREPARE_SMB_OPER( lock, info, &_param );
int n = smbc_open( pathBuffer1.SetPath( path ),
O_CREAT | O_WRONLY | O_TRUNC | OPENFLAG_LARGEFILE | ( overwrite ? 0 : O_EXCL ) , mode );
SetError( err, errno );
return n < 0 ? -1 : n;
}
static int open_f (stream_t *stream, int mode)
{
char *filename;
mode_t m = 0;
int64_t len;
int fd, err;
struct priv *priv = talloc_zero(stream, struct priv);
stream->priv = priv;
filename = stream->url;
if(mode == STREAM_READ)
m = O_RDONLY;
else if (mode == STREAM_WRITE) //who's gonna do that ?
m = O_RDWR|O_CREAT|O_TRUNC;
else {
MP_ERR(stream, "[smb] Unknown open mode %d\n", mode);
return STREAM_UNSUPPORTED;
}
if(!filename) {
MP_ERR(stream, "[smb] Bad url\n");
return STREAM_ERROR;
}
err = smbc_init(smb_auth_fn, 1);
if (err < 0) {
MP_ERR(stream, "Cannot init the libsmbclient library: %d\n",err);
return STREAM_ERROR;
}
fd = smbc_open(filename, m,0644);
if (fd < 0) {
MP_ERR(stream, "Could not open from LAN: '%s'\n", filename);
return STREAM_ERROR;
}
stream->flags = mode;
len = 0;
if(mode == STREAM_READ) {
len = smbc_lseek(fd,0,SEEK_END);
smbc_lseek (fd, 0, SEEK_SET);
}
if(len > 0 || mode == STREAM_WRITE) {
stream->flags |= MP_STREAM_SEEK;
stream->seek = seek;
if(mode == STREAM_READ) stream->end_pos = len;
}
priv->fd = fd;
stream->fill_buffer = fill_buffer;
stream->write_buffer = write_buffer;
stream->close = close_f;
stream->control = control;
return STREAM_OK;
}
int smbc_wrapper_open(connection* con, const char *furl, int flags, mode_t mode)
{
if(con->mode== SMB_BASIC)
return smbc_open(furl, flags, mode);
else if(con->mode == SMB_NTLM)
return smbc_cli_open(con->smb_info->cli, furl, flags);
return -1;
}
int main(int argc, char** argv)
{
int err = -1;
int fd = 0;
int msg_len = 0;
char url[MAX_BUFF_SIZE];
char* message;
bzero(g_workgroup,MAX_BUFF_SIZE);
bzero(url,MAX_BUFF_SIZE);
bzero(g_print_user,MAX_BUFF_SIZE);
bzero(g_print_name,MAX_BUFF_SIZE);
g_print_id = 0;
g_print_priority = 0;
g_print_size = 0;
if ( argc == 7 )
{
strncpy(g_workgroup,argv[1],strlen(argv[1]));
strncpy(g_username,argv[2],strlen(argv[2]));
strncpy(g_password,argv[3],strlen(argv[3]));
strncpy(url,argv[4],strlen(argv[4]));
msg_len = strlen(argv[5])+1;
message = malloc(msg_len);
message[msg_len - 1] = 0;
strncpy(message,argv[5],msg_len);
/* printf("Message: %s\n",message); */
/* printf("Message len: %i\n",msg_len); */
smbc_init(auth_fn, 0);
smbc_unlink(url);
fd = smbc_open(url,O_RDWR | O_CREAT, 0666);
smbc_write(fd, message, msg_len);
smbc_close(fd);
free(message);
smbc_print_file(url,argv[6]);
smbc_list_print_jobs(argv[6],print_list_fn);
g_print_id = -1;
err = smbc_unlink_print_job(argv[6],g_print_id);
if ( err < 0 )
err = 1;
else
err = 0;
}
return err;
}
/* upload file */
int SMB_upload(char *localpath, int index)
{
if(access(localpath, F_OK) != 0)
{
printf("Local has no %s\n", localpath);
return LOCAL_FILE_LOST;
}
write_log(S_UPLOAD, "", localpath, index);
SMB_init(index);
int buflen;
char buffer[4096] = {0};
char *serverpath = localpath_to_serverpath(localpath, index);
int smb_fd = smbc_open(serverpath, O_RDWR|O_CREAT, FILE_MODE);
int cli_fd;
if((cli_fd = open(localpath, O_RDONLY, FILE_MODE)) > 0)
{//以只读的方式打开，文件
DEBUG("open localpath sucess\n");
unsigned long long cli_filesize = 0;
unsigned long long smb_filesize = 0;
cli_filesize = lseek(cli_fd, 0L, SEEK_END);
lseek(cli_fd, 0L, SEEK_SET);//read or write 文件的偏移量
//2014.11.19 by sherry 判断上传是否成功
//buflen = read(cli_fd, buffer, sizeof(buffer));
//DEBUG("buflen=%d\n",buflen);
//while(buflen > 0 && exit_loop == 0)
while((buflen = read(cli_fd, buffer, sizeof(buffer))) > 0 && exit_loop == 0)
{
smb_filesize += buflen;
//2014.11.19 by sherry 判断上传是否成功
//smbc_write(smb_fd, buffer, buflen);//smb_fd为server端的文件
int res=0;
res=smbc_write(smb_fd, buffer, buflen);
if(res==-1)
return -1;
printf("\rUpload [%s] percent - %f ", localpath, (float)smb_filesize/(float)cli_filesize);
}
if(smb_filesize != cli_filesize && exit_loop != 0)
{
DEBUG("smb_filesize != cli_filesize && exit_loop != 0");
FILE *f_stream = fopen(g_pSyncList[index]->up_item_file, "w");
fprintf(f_stream, "%s", localpath);
fclose(f_stream);
}
smbc_close(smb_fd);
close(cli_fd);
DEBUG("upload --end\n");
}
free(serverpath);
return 0;
}
int main(int argc, char** argv)
{
int err = -1;
int fd = 0;
int msg_len = 0;
char url[MAX_BUFF_SIZE];
char* message = NULL;
bzero(g_workgroup,MAX_BUFF_SIZE);
bzero(url,MAX_BUFF_SIZE);
if ( argc == 5 )
{
strncpy(g_workgroup,argv[1],strlen(argv[1]));
strncpy(g_username,argv[2],strlen(argv[2]));
strncpy(g_password,argv[3],strlen(argv[3]));
strncpy(url,argv[4],strlen(argv[4]));
smbc_init(auth_fn, 0);
smbc_unlink(url);
fd = smbc_open(url,O_RDWR | O_CREAT, 0666);
smbc_close(fd);
msg_len = 10;
fd = smbc_open(url, O_RDWR, 0666);
err = smbc_write(fd, message, msg_len);
smbc_close(fd);
free(message);
if ( err < 0 )
err = 1;
else
err = 0;
}
return err;
}
/*
* Member functions
*/
static gboolean
xmms_samba_init (xmms_xform_t *xform)
{
xmms_samba_data_t *data;
const gchar *url;
const gchar *metakey;
struct stat st;
gint fd, err;
g_return_val_if_fail (xform, FALSE);
url = xmms_xform_indata_get_str (xform, XMMS_STREAM_TYPE_URL);
g_return_val_if_fail (url, FALSE);
G_LOCK (mutex);
err = smbc_stat (url, &st);
G_UNLOCK (mutex);
if (err < 0) {
xmms_log_error ("%s", strerror (errno));
return FALSE;
}
if (!S_ISREG (st.st_mode)) {
xmms_log_error ("%s is not a regular file.", url);
return FALSE;
}
G_LOCK (mutex);
fd = smbc_open (url, O_RDONLY | O_NONBLOCK, 0);
G_UNLOCK (mutex);
if (fd == -1) {
xmms_log_error ("%s", strerror (errno));
return FALSE;
}
data = g_new0 (xmms_samba_data_t, 1);
data->fd = fd;
xmms_xform_private_data_set (xform, data);
xmms_xform_outdata_type_add (xform, XMMS_STREAM_TYPE_MIMETYPE,
"application/octet-stream",
XMMS_STREAM_TYPE_END);
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE;
xmms_xform_metadata_set_int (xform, metakey, st.st_size);
metakey = XMMS_MEDIALIB_ENTRY_PROPERTY_LMOD;
xmms_xform_metadata_set_int (xform, metakey, st.st_mtime);
return TRUE;
}
int main(int argc, char * argv[])
{
int fd;
int ret;
int debug = 0;
int savedErrno;
char buffer[2048];
char path[2048];
char * p;
smbc_init(get_auth_data_fn, debug);
printf("CAUTION: This program will overwrite a file. "
"Press ENTER to continue.");
fgets(buffer, sizeof(buffer), stdin);
for (;;)
{
fprintf(stdout, "\nPath: ");
*path = '\0';
fgets(path, sizeof(path) - 1, stdin);
if (strlen(path) == 0)
{
return 0;
}
p = path + strlen(path) - 1;
if (*p == '\n')
{
*p = '\0';
}
if ((fd = smbc_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0)) < 0)
{
perror("smbc_open");
continue;
}
snprintf(buffer, sizeof(buffer), "%s", "Hello world\n");
ret = smbc_write(fd, buffer, strlen(buffer));
savedErrno = errno;
smbc_close(fd);
if (ret < 0)
{
errno = savedErrno;
perror("write");
}
}
return 0;
}
int main(int argc, char** argv)
{
int err = -1;
int fd1 = 0;
int fd2 = 0;
char url[MAX_BUFF_SIZE];
bzero(g_workgroup,MAX_BUFF_SIZE);
bzero(url,MAX_BUFF_SIZE);
if ( argc == 7 )
{
strncpy( g_workgroup, argv[1], strlen(argv[1]) );
strncpy( g_username, argv[2], strlen(argv[2]) );
strncpy( g_password, argv[3], strlen(argv[3]) );
strncpy( url, argv[4], strlen(argv[4]) );
smbc_init( auth_fn, 0 );
fd1 = smbc_open( url, O_RDWR | O_CREAT, 0666 );
smbc_close( fd1 );
smbc_mkdir( argv[5], 0666 );
smbc_rename( url, argv[6] );
fd1 = smbc_open( url, O_RDWR, 0666 );
fd2 = smbc_open( argv[6], O_RDWR, 0666 );
if ( fd1 == -1 && fd2 != -1 )
err = 0;
else
err = 1;
}
return err;
}
FHANDLE FileOpen( const char *filename, int mode )
{
FHANDLE handle;
int c;
char *ptr;
memset( &handle, -1, sizeof(handle) );
if(!filename)
return handle;
if( (ptr = strchr( filename, ':' )) == NULL ) {
#ifdef _DEBUG
printf("FileOpen : Invalid Path (ptr = NULL)\n");
#endif
return handle;
}
c = ptr - filename;
// file is on cd/dvd
if( !strncmp( filename, "cdfs:", c ) ) {
CD_Init();
CDVD_FlushCache();
handle.fh = fioOpen( filename, mode );
handle.dt = DT_CD;
}
else if( !strncmp( filename, "pfs", 3 ) ) {
handle.fh = fileXioOpen( filename, mode, 0 );
handle.dt = DT_HDD;
}
else if( !strncmp( filename, "mc0:", c ) || !strncmp( filename, "mc1:", c ) ) {
handle.fh = fioOpen( filename, mode );
handle.dt = DT_MC;
}
else if( !strncmp( filename, "mass:", c ) ) {
handle.fh = fioOpen( filename, mode );
handle.dt = DT_USB;
}
else if( !strncmp( filename, "host:", c ) ) {
handle.fh = fioOpen( filename, mode );
handle.dt = DT_HOST;
}
else if( !strncmp( filename, "smb:", c ) ) {
handle.fh = smbc_open( filename, mode, 0666 );
handle.dt = DT_SMB_SHARE;
}
return handle;
}
static csync_vio_method_handle_t *_open(const char *durl, int flags, mode_t mode) {
smb_fhandle_t *handle = NULL;
int fd = -1;
if ((fd = smbc_open(durl, flags, mode)) < 0) {
return NULL;
}
handle = c_malloc(sizeof(smb_fhandle_t));
if (handle == NULL) {
return NULL;
}
handle->fd = fd;
return (csync_vio_method_handle_t *) handle;
}
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;
}
/* upload file */
int SMB_upload(char *localpath, int index)
{
if(access(localpath, F_OK) != 0)
{
printf("Local has no %s\n", localpath);
return LOCAL_FILE_LOST;
}
write_log(S_UPLOAD, "", localpath, index);
SMB_init(index);
int buflen;
char buffer[4096] = {0};
char *serverpath = localpath_to_serverpath(localpath, index);
int smb_fd = smbc_open(serverpath, O_RDWR|O_CREAT, FILE_MODE);
int cli_fd;
if((cli_fd = open(localpath, O_RDONLY, FILE_MODE)) > 0){
unsigned long long cli_filesize = 0;
unsigned long long smb_filesize = 0;
cli_filesize = lseek(cli_fd, 0L, SEEK_END);
lseek(cli_fd, 0L, SEEK_SET);
while((buflen = read(cli_fd, buffer, sizeof(buffer))) > 0 && exit_loop == 0){
smb_filesize += buflen;
smbc_write(smb_fd, buffer, buflen);
printf("\rUpload [%s] percent - %f ", localpath, (float)smb_filesize/(float)cli_filesize);
}
if(smb_filesize != cli_filesize && exit_loop != 0)
{
FILE *f_stream = fopen(g_pSyncList[index]->up_item_file, "w");
fprintf(f_stream, "%s", localpath);
fclose(f_stream);
}
smbc_close(smb_fd);
close(cli_fd);
}
free(serverpath);
return 0;
}
void* Open(VFSURL* url)
{
CSMB2::Get().Init();
CSMB2::Get().AddActiveConnection();
if (!IsValidFile(url->filename))
{
XBMC->Log(ADDON::LOG_INFO, "FileSmb->Open: Bad URL : '%s'",url->redacted);
return NULL;
}
int fd = -1;
std::string filename = GetAuthenticatedPath(url);
PLATFORM::CLockObject lock(CSMB2::Get());
fd = smbc_open(filename.c_str(), O_RDONLY, 0);
if (fd == -1)
{
XBMC->Log(ADDON::LOG_INFO, "FileSmb->Open: Unable to open file : '%s'\nunix_err:'%x' error : '%s'", url->redacted, errno, strerror(errno));
return NULL;
}
XBMC->Log(ADDON::LOG_DEBUG,"CSMB2File::Open - opened %s, fd=%d", url->filename, fd);
struct stat tmpBuffer;
if (smbc_stat(filename.c_str(), &tmpBuffer) < 0)
{
smbc_close(fd);
return NULL;
}
int64_t ret = smbc_lseek(fd, 0, SEEK_SET);
if (ret < 0)
{
smbc_close(fd);
return NULL;
}
SMBContext* result = new SMBContext;
result->fd = fd;
result->size = tmpBuffer.st_size;
return result;
}
int main(int argc, char** argv)
{
int err = -1;
int fd = 0;
int dh = 0;
int entry_num = 0;
int i = 0;
char *file_name;
char *tmp_file_ptr;
char buff[MAX_BUFF_SIZE];
char url[MAX_BUFF_SIZE];
char file_url[MAX_BUFF_SIZE];
char dir_url[MAX_BUFF_SIZE];
bzero(g_workgroup,MAX_BUFF_SIZE);
bzero(url,MAX_BUFF_SIZE);
bzero(file_url,MAX_BUFF_SIZE);
bzero(dir_url,MAX_BUFF_SIZE);
bzero(buff,MAX_BUFF_SIZE);
if ( argc == 6 )
{
strncpy(g_workgroup,argv[1],strlen(argv[1]));
strncpy(g_username,argv[2],strlen(argv[2]));
strncpy(g_password,argv[3],strlen(argv[3]));
strncpy(url,argv[4],strlen(argv[4]));
smbc_init(auth_fn, 0);
strncpy(file_url,"tempfile-",9);
tmp_file_ptr = file_url;
tmp_file_ptr += 9;
smbc_rmdir(url);
smbc_mkdir(url,0666);
entry_num = atoi(argv[5]);
strcat(dir_url,url);
strcat(dir_url,"/");
file_name = dir_url;
file_name += strlen(dir_url);
for ( i = 0; i < entry_num; i++ )
{
sprintf(buff,"%d",i);
memcpy(tmp_file_ptr,buff,strlen(buff)+4);
strncat(tmp_file_ptr,".txt",4);
strcpy(file_name,file_url);
fd = smbc_open(dir_url,O_RDWR | O_CREAT, 0666);
smbc_close(fd);
}
dh = smbc_opendir(url);
smbc_telldir(dh);
err = errno;
}
return err;
}
handler_t stat_cache_get_entry(server *srv, connection *con, buffer *name, stat_cache_entry **ret_sce) {
#ifdef HAVE_FAM_H
fam_dir_entry *fam_dir = NULL;
int dir_ndx = -1;
splay_tree *dir_node = NULL;
#endif
stat_cache_entry *sce = NULL;
stat_cache *sc;
struct stat st;
size_t k;
int fd;
struct stat lst;
#ifdef DEBUG_STAT_CACHE
size_t i;
#endif
int file_ndx;
splay_tree *file_node = NULL;
*ret_sce = NULL;
/*
* check if the directory for this file has changed
*/
sc = srv->stat_cache;
buffer_copy_string_buffer(sc->hash_key, name);
buffer_append_long(sc->hash_key, con->conf.follow_symlink);
file_ndx = hashme(sc->hash_key);
sc->files = splaytree_splay(sc->files, file_ndx);
#ifdef DEBUG_STAT_CACHE
for (i = 0; i < ctrl.used; i++) {
if (ctrl.ptr[i] == file_ndx) break;
}
#endif
if (sc->files && (sc->files->key == file_ndx)) {
#ifdef DEBUG_STAT_CACHE
/* it was in the cache */
assert(i < ctrl.used);
#endif
/* we have seen this file already and
* don't stat() it again in the same second */
file_node = sc->files;
sce = file_node->data;
/* check if the name is the same, we might have a collision */
if (buffer_is_equal(name, sce->name)) {
if (srv->srvconf.stat_cache_engine == STAT_CACHE_ENGINE_SIMPLE) {
if (sce->stat_ts == srv->cur_ts) {
*ret_sce = sce;
return HANDLER_GO_ON;
}
}
} else {
/* oops, a collision,
*
* file_node is used by the FAM check below to see if we know this file
* and if we can save a stat().
*
* BUT, the sce is not reset here as the entry into the cache is ok, we
* it is just not pointing to our requested file.
*
* */
file_node = NULL;
}
} else {
#ifdef DEBUG_STAT_CACHE
if (i != ctrl.used) {
log_error_write(srv, __FILE__, __LINE__, "xSB",
file_ndx, "was already inserted but not found in cache, ", name);
}
assert(i == ctrl.used);
#endif
}
#ifdef HAVE_FAM_H
/* dir-check */
if (srv->srvconf.stat_cache_engine == STAT_CACHE_ENGINE_FAM) {
if (0 != buffer_copy_dirname(sc->dir_name, name)) {
log_error_write(srv, __FILE__, __LINE__, "sb",
"no '/' found in filename:", name);
return HANDLER_ERROR;
}
buffer_copy_string_buffer(sc->hash_key, sc->dir_name);
buffer_append_long(sc->hash_key, con->conf.follow_symlink);
dir_ndx = hashme(sc->hash_key);
sc->dirs = splaytree_splay(sc->dirs, dir_ndx);
if (sc->dirs && (sc->dirs->key == dir_ndx)) {
dir_node = sc->dirs;
}
if (dir_node && file_node) {
/* we found a file */
sce = file_node->data;
fam_dir = dir_node->data;
if (fam_dir->version == sce->dir_version) {
/* the stat()-cache entry is still ok */
*ret_sce = sce;
return HANDLER_GO_ON;
}
}
}
#endif
/*
* *lol*
* - open() + fstat() on a named-pipe results in a (intended) hang.
* - stat() if regular file + open() to see if we can read from it is better
*
* */
int r;
#ifdef HAVE_LIBSMBCLIENT
if(con->mode == DIRECT)
r = stat(name->ptr, &st);
else if(con->mode == SMB_NTLM||con->mode == SMB_BASIC)
r = smbc_wrapper_stat(con, name->ptr, &st);
#else
r = stat(name->ptr, &st);
#endif
if (r == -1) {
return HANDLER_ERROR;
}
if (S_ISREG(st.st_mode)) {
/* fix broken stat/open for symlinks to reg files with appended slash on freebsd,osx */
if (name->ptr[name->used-2] == '/') {
errno = ENOTDIR;
return HANDLER_ERROR;
}
/* try to open the file to check if we can read it */
#ifdef HAVE_LIBSMBCLIENT
if(con->mode == DIRECT) {
fd = open(name->ptr, O_RDONLY);
if(fd == -1) {
return HANDLER_ERROR;
}
close(fd);
}
else if(con->mode == SMB_NTLM) {
smb_file_t *fp;
fp = smbc_cli_ntcreate(con->smb_info->cli, name->ptr,
FILE_READ_DATA | FILE_WRITE_DATA, FILE_OPEN, 0);
if(fp == NULL) {
return HANDLER_ERROR;
}
smbc_cli_close(con->smb_info->cli, fp);
}
else {
//Cdbg(DBE, "call smbc_open..%s", con->smb_info->url.path->ptr);
//Cdbg(DBE, "call smbc_open..%s", name->ptr);
//fd = smbc_open(con->smb_info->url.path->ptr, O_RDONLY, 0);
fd = smbc_open(name->ptr, O_RDONLY, 0);
if(fd == -1) {
Cdbg(DBE, "fail to smbc_open");
return HANDLER_ERROR;
}
//Cdbg(DBE, "call smbc_close");
smbc_close(fd);
}
#else
if (-1 == (fd = open(name->ptr, O_RDONLY))) {
return HANDLER_ERROR;
}
close(fd);
#endif
}
if (NULL == sce) {
#ifdef DEBUG_STAT_CACHE
int osize = splaytree_size(sc->files);
#endif
sce = stat_cache_entry_init();
buffer_copy_string_buffer(sce->name, name);
sc->files = splaytree_insert(sc->files, file_ndx, sce);
#ifdef DEBUG_STAT_CACHE
if (ctrl.size == 0) {
ctrl.size = 16;
ctrl.used = 0;
ctrl.ptr = malloc(ctrl.size * sizeof(*ctrl.ptr));
} else if (ctrl.size == ctrl.used) {
ctrl.size += 16;
ctrl.ptr = realloc(ctrl.ptr, ctrl.size * sizeof(*ctrl.ptr));
}
ctrl.ptr[ctrl.used++] = file_ndx;
assert(sc->files);
assert(sc->files->data == sce);
assert(osize + 1 == splaytree_size(sc->files));
#endif
}
sce->st = st;
sce->stat_ts = srv->cur_ts;
/* catch the obvious symlinks
*
* this is not a secure check as we still have a race-condition between
* the stat() and the open. We can only solve this by
* 1. open() the file
* 2. fstat() the fd
*
* and keeping the file open for the rest of the time. But this can
* only be done at network level.
*
* per default it is not a symlink
* */
#ifdef HAVE_LSTAT
sce->is_symlink = 0;
/* we want to only check for symlinks if we should block symlinks.
*/
if (!con->conf.follow_symlink) {
if (stat_cache_lstat(srv, name, &lst) == 0) {
#ifdef DEBUG_STAT_CACHE
log_error_write(srv, __FILE__, __LINE__, "sb",
"found symlink", name);
#endif
sce->is_symlink = 1;
}
/*
* we assume "/" can not be symlink, so
* skip the symlink stuff if our path is /
**/
else if ((name->used > 2)) {
buffer *dname;
char *s_cur;
dname = buffer_init();
buffer_copy_string_buffer(dname, name);
while ((s_cur = strrchr(dname->ptr,'/'))) {
*s_cur = '\0';
dname->used = s_cur - dname->ptr + 1;
if (dname->ptr == s_cur) {
#ifdef DEBUG_STAT_CACHE
log_error_write(srv, __FILE__, __LINE__, "s", "reached /");
#endif
break;
}
#ifdef DEBUG_STAT_CACHE
log_error_write(srv, __FILE__, __LINE__, "sbs",
"checking if", dname, "is a symlink");
#endif
if (stat_cache_lstat(srv, dname, &lst) == 0) {
sce->is_symlink = 1;
#ifdef DEBUG_STAT_CACHE
log_error_write(srv, __FILE__, __LINE__, "sb",
"found symlink", dname);
#endif
break;
};
};
buffer_free(dname);
};
};
#endif
if (S_ISREG(st.st_mode)) {
/* determine mimetype */
buffer_reset(sce->content_type);
#ifdef HAVE_XATTR
if (con->conf.use_xattr) {
stat_cache_attr_get(sce->content_type, name->ptr);
}
#endif
/* xattr did not set a content-type. ask the config */
if (buffer_is_empty(sce->content_type)) {
for (k = 0; k < con->conf.mimetypes->used; k++) {
data_string *ds = (data_string *)con->conf.mimetypes->data[k];
buffer *type = ds->key;
if (type->used == 0) continue;
/* check if the right side is the same */
if (type->used > name->used) continue;
if (0 == strncasecmp(name->ptr + name->used - type->used, type->ptr, type->used - 1)) {
buffer_copy_string_buffer(sce->content_type, ds->value);
break;
}
}
}
etag_create(sce->etag, &(sce->st), con->etag_flags);
} else if (S_ISDIR(st.st_mode)) {
etag_create(sce->etag, &(sce->st), con->etag_flags);
}
#ifdef HAVE_FAM_H
if (sc->fam &&
(srv->srvconf.stat_cache_engine == STAT_CACHE_ENGINE_FAM)) {
/* is this directory already registered ? */
if (!dir_node) {
fam_dir = fam_dir_entry_init();
fam_dir->fc = sc->fam;
buffer_copy_string_buffer(fam_dir->name, sc->dir_name);
fam_dir->version = 1;
fam_dir->req = calloc(1, sizeof(FAMRequest));
if (0 != FAMMonitorDirectory(sc->fam, fam_dir->name->ptr,
fam_dir->req, fam_dir)) {
log_error_write(srv, __FILE__, __LINE__, "sbsbs",
"monitoring dir failed:",
fam_dir->name,
"file:", name,
FamErrlist[FAMErrno]);
fam_dir_entry_free(fam_dir);
} else {
int osize = 0;
if (sc->dirs) {
osize = sc->dirs->size;
}
sc->dirs = splaytree_insert(sc->dirs, dir_ndx, fam_dir);
assert(sc->dirs);
assert(sc->dirs->data == fam_dir);
assert(osize == (sc->dirs->size - 1));
}
} else {
fam_dir = dir_node->data;
}
/* bind the fam_fc to the stat() cache entry */
if (fam_dir) {
sce->dir_version = fam_dir->version;
sce->dir_ndx = dir_ndx;
}
}
#endif
*ret_sce = sce;
return HANDLER_GO_ON;
}
