~SmbDir()
{
#if HAVE_SAMBA
if (m_dh >= 0)
smbc_closedir(m_dh);
#endif
}
int main(int argc, char** argv)
{
int err = -1;
int dh = 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);
dh = smbc_opendir(url);
/* printf("directory handle: %i\n",dh); */
smbc_closedir(dh);
err = errno;
}
return err;
}
void search_smb(char *url)
{
struct smbc_dirent* dirptr;
int dh = 0;
dh = smbc_opendir(url);
while((dirptr = smbc_readdir(dh)) != NULL){
if(!strcmp(dirptr->name, ".") || !strcmp(dirptr->name, ".."))
continue;
char buf[MAX_BUFF_SIZE] = {0};
sprintf(buf, "%s%s", url, dirptr->name);
struct stat info;
smbc_stat(buf, &info);
if(dirptr->smbc_type == SMBC_FILE) {
printf("FILE-------%s%s\n", url, dirptr->name);
printf("-----------mtime:%lu\n", info.st_mtime);
printf("-----------size :%lld\n", info.st_size);
printf("-----------mode :%d S_IDDIR :%d\n", info.st_mode, S_ISDIR(info.st_mode));
}
else if(dirptr->smbc_type == SMBC_DIR) {
printf("FOLDER-----%s%s\n", url, dirptr->name);
printf("-----------mode :%d S_IDDIR :%d\n", info.st_mode, S_ISDIR(info.st_mode));
char new_url[255] = {0};
sprintf(new_url, "%s%s/", url, dirptr->name);
search_smb(new_url);
}
}
smbc_closedir(dh);
}
/** First information such as permissions is gathered for each directory entry.
* All entries are then sorted. */
static struct directory_entry *
get_smb_directory_entries(int dir, struct string *prefix)
{
struct directory_entry *entries = NULL;
int size = 0;
struct smbc_dirent *entry;
while ((entry = smbc_readdir(dir))) {
struct stat st, *stp;
struct directory_entry *new_entries;
struct string attrib;
struct string name;
if (!strcmp(entry->name, "."))
continue;
new_entries = mem_realloc(entries, (size + 2) * sizeof(*new_entries));
if (!new_entries) continue;
entries = new_entries;
if (!init_string(&attrib)) {
continue;
}
if (!init_string(&name)) {
done_string(&attrib);
continue;
}
add_string_to_string(&name, prefix);
add_to_string(&name, entry->name);
stp = (smbc_stat(name.source, &st)) ? NULL : &st;
stat_type(&attrib, stp);
stat_mode(&attrib, stp);
stat_links(&attrib, stp);
stat_user(&attrib, stp);
stat_group(&attrib, stp);
stat_size(&attrib, stp);
stat_date(&attrib, stp);
entries[size].name = stracpy(entry->name);
entries[size].attrib = attrib.source;
done_string(&name);
size++;
}
smbc_closedir(dir);
if (!size) {
/* We may have allocated space for entries but added none. */
mem_free_if(entries);
return NULL;
}
qsort(entries, size, sizeof(*entries), compare_dir_entries);
memset(&entries[size], 0, sizeof(*entries));
return entries;
}
/*
* FUNCTION : static BOOL access_dir(char* name, char* user, char *passwd)
* DESCRIPTION : check user can access directory or not
* INPUT : char* name - server name
* char* user - username
* char *passwd - password
* int id -
* OUTPUT : N/A
* RETURN : TRUE - can access
* FALSE - can't access
*/
void *access_dir(void *value)
{
int err, dh1;
char url[MAX_NAME_LEN] = {0};
struct smbserverinfo_t *psmbserverinfo = NULL;
if(value == NULL)
return NULL;
psmbserverinfo = (struct smbserverinfo_t *)value;
printf("%s[%d], name = [%s], ip = [%s], user = [%s], passwd = [%s], cmd_id = [%d]\n", __FILE__, __LINE__, psmbserverinfo->name, psmbserverinfo->ip, psmbserverinfo->user, psmbserverinfo->passwd, psmbserverinfo->cmd_id);
memset(smb_username, 0, sizeof(smb_username));
memset(smb_passwd, 0, sizeof(smb_passwd));
if(psmbserverinfo->user != NULL) {
strncpy(smb_username, psmbserverinfo->user, strlen(psmbserverinfo->user));
smb_username[strlen(psmbserverinfo->user)] = '\0';
}
if(psmbserverinfo->passwd != NULL) {
strncpy(smb_passwd, psmbserverinfo->passwd, strlen(psmbserverinfo->passwd));
smb_passwd[strlen(psmbserverinfo->passwd)] = '\0';
}
printf("%s[%d], smb_username = [%s], smb_passwd = [%s]\n", __FILE__, __LINE__, smb_username, smb_passwd);
snprintf(url, sizeof(url), "smb://%s:%s@%s", smb_username, smb_passwd, psmbserverinfo->name);
err = smbc_init(get_static_auth_data_fn, 0); /* Initialize things */
if (err < 0) {
printf("%s[%d], Initializing the smbclient library ...: %s\n", __FILE__, __LINE__, strerror(errno));
if(errno == EACCES) {
printf("\033[1;33;41m%s[%d], errno = EACCES (%s)\033[0m\n", __FILE__, __LINE__, strerror(errno));
SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_LOGIN_FAILED, psmbserverinfo->cmd_id, NULL);
} else {
printf("\033[1;33;41m%s[%d], SMB_ACCESS_FAILED\033[0m\n", __FILE__, __LINE__);
SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_FAILED, psmbserverinfo->cmd_id, NULL);
}
SMBTREE_free_smbserverinfo(psmbserverinfo);
return NULL;
}
if ((dh1 = smbc_opendir(url))<1) {
printf("%s[%d], Could not open directory: %s: %s\n", __FILE__, __LINE__, url, strerror(errno));
if(errno == EACCES) {
printf("\033[1;33;41m%s[%d], errno = EACCES (%s)\033[0m\n", __FILE__, __LINE__, strerror(errno));
SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_LOGIN_FAILED, psmbserverinfo->cmd_id, NULL);
} else {
printf("\033[1;33;41m%s[%d], SMB_ACCESS_FAILED\033[0m\n", __FILE__, __LINE__);
SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_FAILED, psmbserverinfo->cmd_id, NULL);
}
SMBTREE_free_smbserverinfo(psmbserverinfo);
return NULL;
}
smbc_closedir(dh1);
SMBTREE_send_event_to_OSD(SMB_CMD_ACCESS_RESPONSE, SMB_ACCESS_OK, psmbserverinfo->cmd_id, NULL);
SMBTREE_free_smbserverinfo(psmbserverinfo);
return NULL;
}
int smbc_wrapper_closedir(connection* con, int dh)
{
if(con->mode== SMB_BASIC)
return smbc_closedir(dh);
else if(con->mode == SMB_NTLM)
return smbc_cli_closedir(dh);
return -1;
}
int main(int argc, char **argv)
{
if (argc <= 1)
{
usage();
}
smbc_init(samba_auth_data_fn, 0);
if (argc==3 && argv[1][0]=='-' && argv[1][1]=='r')
{
struct in_addr ip;
if (samba_resolve_name(argv[2], &ip, 0x20))
{
puts(START_OUTPUT);
puts(inet_ntoa(ip));
return 0;
} else
return E_NAMENOTFOUND;
}
int i;
for (i = 1; i <= argc; i++)
{
if (argv[i][0]=='-' && argv[i][1]=='u')
{
i++;
g_user = argv[i];
} else
if (argv[i][0]=='-' && argv[i][1]=='p')
{
i++;
g_pass = argv[i];
} else
{
g_path = argv[i];
break;
}
}
int dh = smbc_opendir(g_path);
if (dh < 0)
return errno == EACCES ? E_ACCESS : E_OPENDIRFAILED;
puts(START_OUTPUT);
struct smbc_dirent *pdirent;
while ((pdirent = smbc_readdir(dh)) != NULL)
{
if (pdirent->name[strlen(pdirent->name)-1] != '$')
puts(pdirent->name);
}
smbc_closedir(dh);
return 0;
}
//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;
}
/*****************************************************************************
* Close: free unused data structures
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
stream_t *p_access = (stream_t*)p_this;
access_sys_t *p_sys = p_access->p_sys;
vlc_UrlClean( &p_sys->url );
#ifndef _WIN32
if( p_access->pf_readdir )
smbc_closedir( p_sys->i_smb );
else
#endif
smbc_close( p_sys->i_smb );
}
static gboolean
xmms_samba_browse (xmms_xform_t *xform,
const gchar *url,
xmms_error_t *error)
{
struct smbc_dirent *dir;
int handle;
G_LOCK (mutex);
handle = smbc_opendir (url);
G_UNLOCK (mutex);
if (handle < 0) {
xmms_error_set (error, XMMS_ERROR_GENERIC, "Couldn't browse URL");
xmms_log_error ("Couldn't open directory %s!", url);
return FALSE;
}
while (42) {
guint32 flags = 0;
G_LOCK (mutex);
dir = smbc_readdir (handle);
if (!dir) {
G_UNLOCK (mutex);
break;
}
if (dir->name[0] == '.') {
G_UNLOCK (mutex);
continue;
}
if (dir->smbc_type == SMBC_DIR ||
dir->smbc_type == SMBC_WORKGROUP ||
dir->smbc_type == SMBC_SERVER ||
dir->smbc_type == SMBC_FILE_SHARE)
flags |= XMMS_XFORM_BROWSE_FLAG_DIR;
xmms_xform_browse_add_entry (xform, dir->name, flags);
G_UNLOCK (mutex);
}
G_LOCK (mutex);
smbc_closedir (handle);
G_UNLOCK (mutex);
return TRUE;
}
static int _closedir(csync_vio_method_handle_t *dhandle) {
smb_dhandle_t *handle = NULL;
int rc = -1;
if (dhandle == NULL) {
errno = EBADF;
return -1;
}
handle = (smb_dhandle_t *) dhandle;
rc = smbc_closedir(handle->dh);
SAFE_FREE(handle->path);
SAFE_FREE(handle);
return rc;
}
static int smbcfs_releasedir(const char* const path, struct fuse_file_info* const fi)
{
const int fh = fi->fh;
#ifdef MUTEX_LOCK
pthread_mutex_lock(&mutex_lock);
#endif
const int ret_closedir = smbc_closedir(fh);
#ifdef MUTEX_LOCK
pthread_mutex_unlock(&mutex_lock);
#endif
#ifdef SMBCFS_DEBUG
fprintf(stderr, "[smbc_closedir] %d => %d\n", fh, ret_closedir);
#endif
return ret_closedir;
}
static bool test_opendir(struct torture_context *tctx,
SMBCCTX *ctx,
const char *fname,
bool expect_success)
{
int handle, ret;
torture_comment(tctx, "Testing smbc_opendir(%s)\n", fname);
handle = smbc_opendir(fname);
if (!expect_success) {
return true;
}
if (handle < 0) {
torture_fail(tctx, talloc_asprintf(tctx, "failed to obain file handle for '%s'", fname));
}
ret = smbc_closedir(handle);
torture_assert_int_equal(tctx, ret, 0,
talloc_asprintf(tctx, "failed to close file handle for '%s'", fname));
return true;
}
int SMB_del(char *url, int index)
{
SMB_init(index);
int res = 0;
int dh = 0;
dh = smbc_opendir(url);
printf("SMB_del() - dh = %d\n", dh);
if(dh < 0){
res = smbc_unlink(url);
}
else{
struct smbc_dirent* dirptr;
if(url[strlen(url) - 1] != '/')
strcat(url, "/");
while((dirptr = smbc_readdir(dh)) != NULL){
if(!strcmp(dirptr->name, ".") || !strcmp(dirptr->name, ".."))
continue;
char new_url[255] = {0};
sprintf(new_url, "%s%s", url, dirptr->name);
printf("-------%s\n", new_url);
if(dirptr->smbc_type == SMBC_DIR) {
if(new_url[strlen(new_url) - 1] != '/')
strcat(new_url, "/");
SMB_del(new_url, index);
}
else if(dirptr->smbc_type == SMBC_FILE) {
res = smbc_unlink(new_url);
}
}
res = smbc_rmdir(url);//删除成功返回0，失败返回-1
}
smbc_closedir(dh);
return res;
}
int Spider::ScanSMBDir(const std::string &dir) {
int directory_handler = 0, dirc = 0, dsize = 0;
char *dirp = NULL;
struct smbc_dirent *entry = NULL;
char buf[BUF_SIZE];
// Open given smb directory.
if (UNLIKELY((directory_handler = smbc_opendir(dir.c_str())) < 0)) {
DetectError();
MSS_ERROR(("smbc_opendir " + dir).c_str(), error_);
return -1;
}
// Getting content of the directory.
// smbc_getdents() returns the readen size.
// When no more content in the directory smbc_getdents() returns 0.
// Use smbc_getdents() while returned value not equal 0.
while (true) {
dirp = static_cast<char *>(buf);
// Get dir content which can placed in buf.
if (UNLIKELY((dirc = smbc_getdents(
static_cast<unsigned int>(directory_handler),
reinterpret_cast<struct smbc_dirent *>(dirp),
sizeof(buf)))) < 0) {
DetectError();
MSS_ERROR("smbc_getdents", error_);
return -1;
}
// Break the cycle if no more content in this directory.
if (dirc == 0)
break;
// Put readen content in list
while (dirc > 0) {
entry = reinterpret_cast<struct smbc_dirent *>(dirp);
dsize = static_cast<int>(entry->dirlen);
// Ignoring "." and ".."
if ((strcmp(entry->name, ".") == 0) || (strcmp(entry->name, "..") == 0)) {
dirp += dsize; // Use char * to promote pointer exactly on dsize
dirc -= dsize; // Decrease size
continue;
}
switch (reinterpret_cast<struct smbc_dirent *>(dirp)->smbc_type) {
case SMBC_WORKGROUP:
case SMBC_SERVER:
case SMBC_FILE_SHARE:
case SMBC_DIR:
ScanSMBDir(dir + "/" + entry->name);
break;
case SMBC_FILE:
AddSMBFile(dir + "/" + entry->name);
break;
case SMBC_PRINTER_SHARE:
case SMBC_COMMS_SHARE:
case SMBC_IPC_SHARE:
case SMBC_LINK:
// Do nothing
break;
default:
MSS_FATAL_MESSAGE("Unknown smb entry type");
assert(0); // This can't happen
}
dirp += dsize; // Use char * to promote pointer exactly on dsize
dirc -= dsize; // Decrease size
}
}
// Close given smb directory
if (UNLIKELY(smbc_closedir(directory_handler) < 0)) {
DetectError();
MSS_ERROR(("smbc_closedir " + dir).c_str(), error_);
}
return 0;
}
void *smb_getdir(void *value)
{
int err, dh1, dsize, dirc, i, count;
char dirbuf[2048] = {0};
struct smbc_dirent *dirp;
char url[MAX_NAME_LEN] = {0};
char buf[MAX_NAME_LEN] = {0};
char tmpdirname[MAX_NAME_LEN] = {0};
char dir_path[MAX_NAME_LEN] = {0};
int ret, mount_ok_num, mount_fail_num;
char *p = NULL;
struct smbserverinfo_t *psmbserverinfo = NULL;
struct smbEventProxyCmd *pevent = NULL;
if(value == NULL)
return NULL;
psmbserverinfo = (struct smbserverinfo_t *)value;
printf("%s[%d], name = [%s], ip = [%s], user = [%s], passwd = [%s], cmd_id = [%d]\n", __FILE__, __LINE__, psmbserverinfo->name, psmbserverinfo->ip, psmbserverinfo->user, psmbserverinfo->passwd, psmbserverinfo->cmd_id);
memset(smb_username, 0, sizeof(smb_username));
memset(smb_passwd, 0, sizeof(smb_passwd));
if(psmbserverinfo->user != NULL) {
strncpy(smb_username, psmbserverinfo->user, strlen(psmbserverinfo->user));
smb_username[strlen(psmbserverinfo->user)] = '\0';
}
if(psmbserverinfo->passwd != NULL) {
strncpy(smb_passwd, psmbserverinfo->passwd, strlen(psmbserverinfo->passwd));
smb_passwd[strlen(psmbserverinfo->passwd)] = '\0';
}
printf("%s[%d], smb_username = [%s], smb_passwd = [%s]\n", __FILE__, __LINE__, smb_username, smb_passwd);
snprintf(url, sizeof(url), "smb://%s:%s@%s", smb_username, smb_passwd, psmbserverinfo->name);
err = smbc_init(get_static_auth_data_fn, 0); /* Initialize things */
if (err < 0) {
printf("%s[%d], Initializing the smbclient library ...: %s\n", __FILE__, __LINE__, strerror(errno));
SMBTREE_send_event_to_OSD(SMB_CMD_BROWSE_RESPONSE, SMB_MOUNT_FAILED, psmbserverinfo->cmd_id, NULL);
SMBTREE_free_smbserverinfo(psmbserverinfo);
return NULL;
}
if ((dh1 = smbc_opendir(url))<1) {
printf("%s[%d], Could not open directory: %s: %s\n", __FILE__, __LINE__, url, strerror(errno));
SMBTREE_send_event_to_OSD(SMB_CMD_BROWSE_RESPONSE, SMB_MOUNT_FAILED, psmbserverinfo->cmd_id, NULL);
SMBTREE_free_smbserverinfo(psmbserverinfo);
return NULL;
}
snprintf(dir_path, sizeof(dir_path), "%s/%s", CONF_SAMBA_MOUNT_POINT, psmbserverinfo->name);
smb_umount(dir_path);
/* Now, list those directories, but in funny ways ... */
/* keep call smbc_getdents() until there is no share folder to fix Device only can browse less than 8 root folder.*/
while(0 != (dirc = smbc_getdents(dh1, (struct smbc_dirent *)dirbuf, sizeof(dirbuf)))) {
if(dirc < 0) {
fprintf(stderr, "Problems getting directory entries: %s\n", strerror(errno));
smbc_closedir(dh1);
SMBTREE_send_event_to_OSD(SMB_CMD_BROWSE_RESPONSE, SMB_MOUNT_FAILED, psmbserverinfo->cmd_id, NULL);
SMBTREE_free_smbserverinfo(psmbserverinfo);
return NULL;
}
/* Now, process the list of names ... */
fprintf(stdout, "Directory listing, size = %u\n", dirc);
dirp = (struct smbc_dirent *)dirbuf;
count = 0;
mount_ok_num = 0;
mount_fail_num = 0;
while (dirc > 0) {
dsize = dirp->dirlen;
switch (dirp->smbc_type) {
case SMBC_DIR:
case SMBC_FILE:
case SMBC_FILE_SHARE:
snprintf(buf, sizeof(buf), "%s\\%s\\%s", psmbserverinfo->name, psmbserverinfo->ip, dirp->name);
fprintf(stdout, "Shared Dir Type: %u, Name: %s\n", dirp->smbc_type, dirp->name);
/*if share-folder-name is end of $, system doesn't mount it*/
if((p=strrchr(buf, '$')) != NULL && strlen(p) == 1) {
printf("%s[%d], ##### %s not match ####\n", __FILE__, __LINE__, buf);
break;
}
memset(tmpdirname, '\0', sizeof(tmpdirname));
smb_replace_special_char(dirp->name, tmpdirname);
ret = smb_mount(psmbserverinfo->user, psmbserverinfo->passwd, psmbserverinfo->name, psmbserverinfo->ip, tmpdirname);
if (ret == 0) {
#ifdef ENABLE_PTHREAD
pevent = malloc(sizeof(struct smbEventProxyCmd));
pevent->cmd = SMB_CMD_BROWSE_RESPONSE;
pevent->status = SMB_MOUNTING;
pevent->id = psmbserverinfo->cmd_id;
pevent->datalen = strlen(buf) + 1;
strcpy((char *)pevent->data, buf);
XLinkedList_Lock(sharefolderlist);
XLinkedList_AddTail(sharefolderlist, (void *)pevent);
XLinkedList_UnLock(sharefolderlist);
#else
SMBTREE_send_event_to_OSD(SMB_CMD_BROWSE_RESPONSE, SMB_MOUNTING, psmbserverinfo->cmd_id, buf);
#endif
mount_ok_num++;
} else {
mount_fail_num++;
}
break;
default:
break;
}
i = dsize % 4 == 0 ? 0 : (4 - dsize % 4);
dsize += i;
count += dsize;
dirp = (struct smbc_dirent *)(dirbuf + count);
dirc -= dsize;
}
memset(dirbuf, 0, sizeof(dirbuf));
}
smbc_closedir(dh1);
if(mount_fail_num > 0 && mount_ok_num == 0) {
SMBTREE_send_event_to_OSD(SMB_CMD_BROWSE_RESPONSE, SMB_MOUNT_FAILED, psmbserverinfo->cmd_id, NULL);
} else {
SMBTREE_send_event_to_OSD(SMB_CMD_BROWSE_RESPONSE, SMB_MOUNT_OK, psmbserverinfo->cmd_id, NULL);
}
SMBTREE_free_smbserverinfo(psmbserverinfo);
return NULL;
}
int browse(int (*scan_found_share)(char share[]),char * path, int scan, int indent)
{
char * p;
char buf[1024];
int dir;
struct stat stat;
struct smbc_dirent * dirent;
if (! scan)
{
bblog(INFO, "Opening (%s)...", path);
}
if ((dir = smbc_opendir(path)) < 0)
{
bblog(ERROR, "Could not open directory [%s] (%d:%s)", path, errno, strerror(errno));
return 0;
}
while ((dirent = smbc_readdir(dir)) != NULL)
{
bblog(INFO, "%*.*s%-30s", indent, indent, "", dirent->name);
switch(dirent->smbc_type)
{
case SMBC_WORKGROUP:
bblog(INFO, "WORKGROUP");
break;
case SMBC_SERVER:
bblog(INFO, "SERVER");
break;
case SMBC_FILE_SHARE:
bblog(INFO, "FILE_SHARE");
(*scan_found_share)(dirent->name);
break;
case SMBC_PRINTER_SHARE:
bblog(INFO, "PRINTER_SHARE");
break;
case SMBC_COMMS_SHARE:
bblog(INFO, "COMMS_SHARE");
break;
case SMBC_IPC_SHARE:
bblog(INFO, "IPC_SHARE");
break;
case SMBC_DIR:
bblog(INFO, "DIR");
break;
case SMBC_FILE:
bblog(INFO, "FILE");
p = path + strlen(path);
strcat(p, "/");
strcat(p+1, dirent->name);
if (smbc_stat(path, &stat) < 0)
{
bblog(WARN, " unknown size (reason %d: %s)",
errno, strerror(errno));
}
else
{
bblog(INFO, " size %lu", (unsigned long) stat.st_size);
}
*p = '\0';
break;
case SMBC_LINK:
bblog(INFO, "LINK");
break;
}
if (scan &&
(dirent->smbc_type == SMBC_WORKGROUP ||
dirent->smbc_type == SMBC_SERVER))
{
/*
* don't append server name to workgroup; what we want is:
*
* smb://workgroup_name
* or
* smb://server_name
*
*/
snprintf(buf, sizeof(buf), "smb://%s", dirent->name);
browse(scan_found_share,buf, scan, indent + 2);
}
}
smbc_closedir(dir);
return 1;
}
int smb_download_dir(const char *base, const char *name, int resume)
{
char path[SMB_MAXPATHLEN];
int dirhandle;
struct smbc_dirent *dirent;
const char *relname = name;
char *tmpname;
struct stat remotestat;
snprintf(path, SMB_MAXPATHLEN-1, "%s%s%s", base, (base[0] && name[0] && name[0] != '/' && base[strlen(base)-1] != '/')?"/":"", name);
/* List files in directory and call smb_download_file on them */
dirhandle = smbc_opendir(path);
if(dirhandle < 1) {
if(errno == ENOTDIR) return smb_download_file(base, name, 1, resume, NULL);
fprintf(stderr, "Can't open directory %s: %s\n", path, strerror(errno));
return 0;
}
while(*relname == '/')relname++;
mkdir(relname, 0755);
tmpname = strdup(name);
while((dirent = smbc_readdir(dirhandle))) {
char *newname;
if(!strcmp(dirent->name, ".") || !strcmp(dirent->name, ".."))continue;
asprintf(&newname, "%s/%s", tmpname, dirent->name);
switch(dirent->smbc_type) {
case SMBC_DIR:
smb_download_dir(base, newname, resume);
break;
case SMBC_WORKGROUP:
smb_download_dir("smb://", dirent->name, resume);
break;
case SMBC_SERVER:
smb_download_dir("smb://", dirent->name, resume);
break;
case SMBC_FILE:
smb_download_file(base, newname, 1, resume, NULL);
break;
case SMBC_FILE_SHARE:
smb_download_dir(base, newname, resume);
break;
case SMBC_PRINTER_SHARE:
if(!quiet)printf("Ignoring printer share %s\n", dirent->name);
break;
case SMBC_COMMS_SHARE:
if(!quiet)printf("Ignoring comms share %s\n", dirent->name);
break;
case SMBC_IPC_SHARE:
if(!quiet)printf("Ignoring ipc$ share %s\n", dirent->name);
break;
default:
fprintf(stderr, "Ignoring file '%s' of type '%d'\n", newname, dirent->smbc_type);
break;
}
free(newname);
}
free(tmpname);
if(keep_permissions) {
if(smbc_fstat(dirhandle, &remotestat) < 0) {
fprintf(stderr, "Unable to get stats on %s on remote server\n", path);
smbc_closedir(dirhandle);
return 0;
}
if(chmod(relname, remotestat.st_mode) < 0) {
fprintf(stderr, "Unable to change mode of local dir %s to %o\n", relname, remotestat.st_mode);
smbc_closedir(dirhandle);
return 0;
}
}
smbc_closedir(dirhandle);
return 1;
}
int DirGetContents( const char *path, const char *filter, fileInfo_t *fileInfo, int maxItems )
{
int c, i;
char *ptr;
int numRead;
int index = 0;
if( !path || !fileInfo || !maxItems )
return -1;
if( (ptr = strchr( path, '/' )) == NULL ) {
printf("DirGetContents : Invalid Path (ptr = NULL)\n");
return -1;
}
c = ptr - path;
// try to read in dir from cd/dvd
if( !strncmp( path, "cdfs:/", c ) )
{
// just make sure we are initialized
CD_Init();
struct TocEntry *tocEntries = (struct TocEntry*) malloc( sizeof(struct TocEntry) * maxItems );
if( !tocEntries )
return -1;
CDVD_FlushCache();
numRead = CDVD_GetDir( ptr, NULL, CDVD_GET_FILES_AND_DIRS, tocEntries, maxItems, NULL );
CDVD_Stop();
index = 0;
ptr = NULL;
if( filter )
ptr = (char*) malloc( strlen(filter) + 1 );
for( i = 0; i < numRead; i++ )
{
if( index >= maxItems )
break;
if( !strcmp( tocEntries[i].filename, ".." ) || !strcmp( tocEntries[i].filename, "." ) )
continue;
// check for filters
c = 1;
if( filter && !(tocEntries[i].fileProperties & FLAG_DIRECTORY) )
{
strcpy( ptr, filter );
c = 0;
char *token = strtok( ptr, " " );
while( token ) {
// found matching extension
if( CmpFileExtension( tocEntries[i].filename, token ) ) {
c = 1;
break;
}
token = strtok( NULL, " " );
}
}
if( c == 1 )
{
strncpy( fileInfo[index].name, tocEntries[i].filename, sizeof(fileInfo[index].name) );
fileInfo[index].size = tocEntries[i].fileSize;
fileInfo[index].flags = tocEntries[i].fileProperties;
index++;
}
}
if( ptr )
free(ptr);
free(tocEntries);
}
else if( !strncmp( path, "pfs", 3 ) )
{
// try to read in dir from hdd
int hDir = fileXioDopen( path );
int nRet;
iox_dirent_t dirEntry;
if( hDir < 0 )
return -1;
index = 0;
ptr = NULL;
if( filter )
ptr = (char*) malloc( strlen(filter) + 1 );
do {
if( !(nRet = fileXioDread( hDir, &dirEntry )) )
break;
if(!strcmp( dirEntry.name, "." ) || !strcmp( dirEntry.name, ".."))
continue;
if( index >= maxItems )
break;
if( FIO_S_ISDIR(dirEntry.stat.mode) )
fileInfo[index].flags = FLAG_DIRECTORY;
else
fileInfo[index].flags = 0;
// check for filters
c = 1;
if( filter && !(fileInfo[index].flags & FLAG_DIRECTORY) )
{
strcpy( ptr, filter );
c = 0;
char *token = strtok( ptr, " " );
while( token ) {
// found matching extension
if( CmpFileExtension( dirEntry.name, token ) ) {
c = 1;
break;
}
token = strtok( NULL, " " );
}
}
if( c == 1 )
{
strncpy( fileInfo[index].name, dirEntry.name, sizeof(fileInfo[index].name) );
fileInfo[index].size = dirEntry.stat.size;
index++;
}
} while( nRet > 0 );
if( ptr )
free(ptr);
fileXioDclose( hDir );
}
else if( !strncmp( path, "mc0:/", c ) || !strncmp( path, "mc1:/", c ) )
{
// try to read in dir from memory card
int nPort;
char mcPath[256];
mcTable mcEntries[MAX_DIR_FILES] __attribute__((aligned(64)));
if( !strncmp( path, "mc0:/", c ) )
nPort = 0;
else
nPort = 1;
strcpy( mcPath, ptr );
strcat( mcPath, "*" );
mcGetDir( nPort, 0, mcPath, 0, MAX_DIR_FILES, mcEntries );
mcSync( 0, NULL, &numRead );
index = 0;
ptr = NULL;
if( filter )
ptr = (char*) malloc( strlen(filter) + 1 );
for( i = 0; i < numRead; i++ )
{
if( index >= maxItems )
break;
if( !strcmp( mcEntries[i].name, "." ) || !strcmp( mcEntries[i].name, "..") )
continue;
if( mcEntries[i].attrFile & MC_ATTR_SUBDIR )
fileInfo[index].flags = FLAG_DIRECTORY;
else
fileInfo[index].flags = 0;
// check for filters
c = 1;
if( filter && !(mcEntries[i].attrFile & MC_ATTR_SUBDIR) )
{
strcpy( ptr, filter );
c = 0;
char *token = strtok( ptr, " " );
while( token ) {
// found matching extension
if( CmpFileExtension( mcEntries[i].name, token ) ) {
c = 1;
break;
}
token = strtok( NULL, " " );
}
}
if( c == 1 )
{
strncpy( fileInfo[index].name, mcEntries[i].name, sizeof(fileInfo[index].name) );
fileInfo[index].size = mcEntries[i].fileSizeByte;
index++;
}
}
if( ptr )
free(ptr);
}
else if( !strncmp( path, "mass:/", c ) )
{
// try to read in dir from USB device
int nRet;
fat_dir_record dirEntry;
// returns number of entries in directory
nRet = usb_mass_getFirstDirentry( ptr, &dirEntry );
index = 0;
ptr = NULL;
if( filter )
ptr = (char*) malloc( strlen(filter) + 1 );
// loop through all entries in directory
while( nRet > 0 ) {
if(!strcmp( dirEntry.name, "." ) || !strcmp( dirEntry.name, "..")) {
nRet = usb_mass_getNextDirentry(&dirEntry);
continue;
}
// ignore volume label
if( dirEntry.attr & USB_VOLUME ) {
nRet = usb_mass_getNextDirentry(&dirEntry);
continue;
}
if( index >= maxItems )
break;
if( dirEntry.attr & USB_DIRECTORY )
fileInfo[index].flags = FLAG_DIRECTORY;
else
fileInfo[index].flags = 0;
// check for filters
c = 1;
if( filter && !(fileInfo[index].flags & FLAG_DIRECTORY) )
{
strcpy( ptr, filter );
c = 0;
char *token = strtok( ptr, " " );
while( token ) {
// found matching extension
if( CmpFileExtension( dirEntry.name, token ) ) {
c = 1;
break;
}
token = strtok( NULL, " " );
}
}
if( c == 1 )
{
strncpy( fileInfo[index].name, dirEntry.name, sizeof(fileInfo[index].name) );
fileInfo[index].size = dirEntry.size;
index++;
}
nRet = usb_mass_getNextDirentry( &dirEntry );
}
if( ptr )
free(ptr);
}
else if( !strncmp( path, "smb", 3 ) )
{
// read from a samba share
int hDir = smbc_opendir( path );
const struct smbc_dirent *dirEntry;
if( hDir < 0 )
return -1;
index = 0;
ptr = NULL;
if( filter )
ptr = (char*) malloc( strlen(filter) + 1 );
while( (dirEntry = smbc_readdir( hDir )) != NULL )
{
if(!strcmp( dirEntry->name, "." ) || !strcmp( dirEntry->name, ".."))
continue;
if( index >= maxItems )
break;
if( dirEntry->smbc_type == SMBC_DIR )
fileInfo[index].flags = FLAG_DIRECTORY;
else
fileInfo[index].flags = 0;
// check for filters
c = 1;
if( filter && !(fileInfo[index].flags & FLAG_DIRECTORY) )
{
strcpy( ptr, filter );
c = 0;
char *token = strtok( ptr, " " );
while( token ) {
// found matching extension
if( CmpFileExtension( dirEntry->name, token ) ) {
c = 1;
break;
}
token = strtok( NULL, " " );
}
}
if( c == 1 )
{
strncpy( fileInfo[index].name, dirEntry->name, sizeof(fileInfo[index].name) );
fileInfo[index].size = 0; // fixme
index++;
}
};
if( ptr )
free(ptr);
smbc_closedir( hDir );
}
return index;
}
int FSSmb::ReadDir( FSList* list, FSPath& _path, int* err, FSCInfo* info )
{
FREPARE_SMB_OPER( lock, info, &_param );
if ( info && info->Stopped() ) { return -2; }
list->Clear();
FSPath path( _path );
int d = smbc_opendir( pathBuffer1.SetPath( path ) );
if ( d < 0 )
{
SetError( err, errno );
return -1;
}
try
{
struct smbc_dirent* pEnt;
int n = path.Count();
while ( true )
{
if ( info && info->Stopped() )
{
smbc_closedir( d );
return -2;
}
pEnt = smbc_readdir( d );
if ( !pEnt )
{
//???
break;
}
//skip . and ..
if ( pEnt->name[0] == '.' && ( !pEnt->name[1] || ( pEnt->name[1] == '.' && !pEnt->name[2] ) ) )
{
continue;
}
if ( //ignore it
pEnt->smbc_type == SMBC_PRINTER_SHARE ||
pEnt->smbc_type == SMBC_IPC_SHARE
) { continue; }
clPtr<FSNode> pNode = new FSNode();
path.SetItem( n, CS_UTF8, pEnt->name );
switch ( pEnt->smbc_type )
{
case SMBC_WORKGROUP:
pNode->extType = FSNode::WORKGROUP;
pNode->st.mode = S_IFDIR;
break;
case SMBC_SERVER:
pNode->extType = FSNode::SERVER;
pNode->st.mode = S_IFDIR;
break;
case SMBC_FILE_SHARE:
pNode->extType = FSNode::FILESHARE;
pNode->st.mode = S_IFDIR;
break;
case SMBC_PRINTER_SHARE:
case SMBC_COMMS_SHARE:
case SMBC_IPC_SHARE:
case SMBC_DIR:
pNode->st.mode = S_IFDIR;
break;
default:
InternalStat( path, &pNode->st, info );
}
pNode->name.Set( sys_charset_id, pEnt->name );
list->Append( pNode );
};
smbc_closedir( d );
return 0;
err:
SetError( err, errno );
smbc_closedir( d );
return -1;
}
catch ( ... )
{
smbc_closedir( d );
throw;
}
}
static void browse(char * path, int scan, int indent)
{
char * p;
char buf[1024];
int dir;
struct stat stat;
struct smbc_dirent * dirent;
if (! scan)
{
printf("Opening (%s)...\n", path);
}
if ((dir = smbc_opendir(path)) < 0)
{
printf("Could not open directory [%s] (%d:%s)\n",
path, errno, strerror(errno));
return;
}
while ((dirent = smbc_readdir(dir)) != NULL)
{
printf("%*.*s%-30s", indent, indent, "", dirent->name);
switch(dirent->smbc_type)
{
case SMBC_WORKGROUP:
printf("WORKGROUP");
break;
case SMBC_SERVER:
printf("SERVER");
break;
case SMBC_FILE_SHARE:
printf("FILE_SHARE");
break;
case SMBC_PRINTER_SHARE:
printf("PRINTER_SHARE");
break;
case SMBC_COMMS_SHARE:
printf("COMMS_SHARE");
break;
case SMBC_IPC_SHARE:
printf("IPC_SHARE");
break;
case SMBC_DIR:
printf("DIR");
break;
case SMBC_FILE:
printf("FILE");
p = path + strlen(path);
strcat(p, "/");
strcat(p+1, dirent->name);
if (smbc_stat(path, &stat) < 0)
{
printf(" unknown size (reason %d: %s)",
errno, strerror(errno));
}
else
{
printf(" size %lu", (unsigned int) stat.st_size);
}
*p = '\0';
break;
case SMBC_LINK:
printf("LINK");
break;
}
printf("\n");
if (scan &&
(dirent->smbc_type == SMBC_WORKGROUP ||
dirent->smbc_type == SMBC_SERVER))
{
/*
* don't append server name to workgroup; what we want is:
*
* smb://workgroup_name
* or
* smb://server_name
*
*/
snprintf(buf, sizeof(buf), "smb://%s", dirent->name);
browse(buf, scan, indent + 2);
}
}
smbc_closedir(dir);
}
vector<string> FileBrowser::GetFolderList()
{
vector<string> retVal;
if(m_CurrentFolder.size()==0)
{
//List Drives
retVal.push_back("Game:");
if (SETTINGS::getInstance().getSambaClientOn())
retVal.push_back("smb:");
std::vector<Drive* const> mountedDrives;
DrivesManager::getInstance().getMountedDrives(&mountedDrives);
for(unsigned int x=0;x<mountedDrives.size();x++)
{
retVal.push_back(mountedDrives[x]->GetCleanDriveName() + ":");
}
return retVal;
}
else
{
retVal.push_back("..");
string path = GetCurrentPath();
if (path.substr(0,4).compare("smb:") == 0) {
map<string, unsigned int> m_SambaTypes;
int dir;
if (path.length() == 5) {
if (SambaClient::getInstance().m_SambaTopLevelTypes.size() > 0) {
for (map<string, unsigned int>::const_iterator it = SambaClient::getInstance().m_SambaTopLevelTypes.begin(); it != SambaClient::getInstance().m_SambaTopLevelTypes.end(); ++it)
{
retVal.push_back(it->first);
}
return retVal;
}
}
path.append("/");
if ((dir = smbc_opendir(path.c_str())) < 0)
{
DebugMsg("FileBrowser", "Could not open directory [%s] (%d:%s)\n", path.c_str(), errno, strerror(errno));
if (errno == 13) { // permission denied
string user;
string password;
string share;
string rawpath = GetRawSmbPath(user, password, share);
XUIMessage xuiMsg;
XuiMessage(&xuiMsg, XM_SMB_PERMISSION_DENIED);
Credentials * cred = new Credentials();
_XuiMessageExtra(&xuiMsg,(XUIMessageData*) cred, sizeof(*cred));
cred->smbPath = rawpath;
cred->user = user;
cred->password = password;
cred->share = share;
XuiSendMessage( parentScene , &xuiMsg );
}
return retVal;
}
struct smbc_dirent * dirent;
while ((dirent = smbc_readdir(dir)) != NULL)
{
if (dirent->smbc_type != SMBC_WORKGROUP &&
dirent->smbc_type != SMBC_SERVER &&
dirent->smbc_type != SMBC_FILE_SHARE &&
dirent->smbc_type != SMBC_DIR)
continue;
if (strcmp(dirent->name, ".") == 0 || strcmp(dirent->name, "..") == 0)
continue;
if (hasEnding(dirent->name, "$"))
continue;
if (m_CurrentFolder.size() == 1) {
SambaClient::getInstance().m_SambaTopLevelTypes[dirent->name] = dirent->smbc_type;
}
// filter ourselves out of the list of servers
if (SETTINGS::getInstance().getSambaServerOn() && CFreestyleApp::getInstance().hasInternetConnection()) {
if (m_CurrentFolder.size() == 2) {
string wrkgroup = SETTINGS::getInstance().getSambaClientWorkgroup();
if (stricmp(wrkgroup.c_str(), m_CurrentFolder[1].c_str()) == 0) {
string hostname = SETTINGS::getInstance().getHostname();
if (stricmp(hostname.c_str(), dirent->name) == 0)
continue;
}
}
}
retVal.push_back(dirent->name);
}
// if (m_CurrentFolder.size() == 1) {
// m_SambaTopLevelTypes = m_SambaTypes;
// //m_CurrentFolderSambaTypes.push_back(m_SambaTypes);
// }
smbc_closedir(dir);
return retVal;
}
WIN32_FIND_DATA findFileData;
memset(&findFileData,0,sizeof(WIN32_FIND_DATA));
string searchcmd = GetCurrentPath() + "\\*";
HANDLE hFind = FindFirstFile(searchcmd.c_str(), &findFileData);
if (hFind == INVALID_HANDLE_VALUE)
return retVal;
do {
string s = findFileData.cFileName;
if(findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
retVal.push_back(s);
}
} while (FindNextFile(hFind, &findFileData));
FindClose(hFind);
return retVal;
}
}
vector<string> FileBrowser::GetFileList()
{
DebugMsg("FileBrowser", "In Get FileList");
vector<string> retVal;
if(m_CurrentFolder.size()>0)
{
string path = GetCurrentPath();
if (path.substr(0,4).compare("smb:") == 0) {
map<string, unsigned int> m_SambaTypes;
if (path.length() == 5)
return retVal; // there are no "FILES" at the top level
path.append("/");
int dir;
DebugMsg("FileBrowser", "calling opendir on %s", path.c_str());
if ((dir = smbc_opendir(path.c_str())) < 0)
{
DebugMsg("FileBrowser", "Could not open directory [%s] (%d:%s)\n", path.c_str(), errno, strerror(errno));
if (errno == 13) {
retVal.push_back("*Permission Denied*");
}
return retVal;
}
struct smbc_dirent *dirent;
DebugMsg("FileBrowser", "calling smbc_readdir on %s", path.c_str());
while ((dirent = smbc_readdir(dir)) != NULL)
{
if (dirent->smbc_type != SMBC_FILE)
continue;
if (strcmp(dirent->name, ".") == 0 || strcmp(dirent->name, "..") == 0)
continue;
// DebugMsg("FileBrowser","Inserting %s as type %d", dirent->name, dirent->smbc_type);
// m_SambaTypes[dirent->name] = dirent->smbc_type;
retVal.push_back(dirent->name);
}
smbc_closedir(dir);
// if (m_CurrentFolderSambaTypes.size() < m_CurrentFolder.size()) {
// m_CurrentFolderSambaTypes.push_back(m_SambaTypes);
// }
return retVal;
}
WIN32_FIND_DATA findFileData;
memset(&findFileData,0,sizeof(WIN32_FIND_DATA));
string searchcmd = GetCurrentPath() + "\\*";
HANDLE hFind = FindFirstFile(searchcmd.c_str(), &findFileData);
if (hFind == INVALID_HANDLE_VALUE)
return retVal;
do {
string s = findFileData.cFileName;
if(findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
}
else
{
if(strcmp(s.c_str(),"..")!=0)
{
retVal.push_back(s);
}
}
} while (FindNextFile(hFind, &findFileData));
FindClose(hFind);
}
return retVal;
}
