~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; }