Цитата(MAKCim @ 7.6.2009, 13:07  ) | | я могу iso образ к примеру прикрутить через loop или на instance ramfs |
Да. Но стандартный юзер этого делать не станет 
| Цитата(MAKCim @ 7.6.2009, 13:07 ) | берем первую строку из /etc/mtab и делаем stat
по st_dev находим MAJOR номер и сравниваем с linux/major.h |
Это понятно. Но хочется без вызовов системных функций.
Кароче вот что у меня получилось. Жду критики/исправлений/дополнений.
| Код |
#include <fstream>
#include <cctype>
#include <string>
#include <vector>
#include <algorithm>
static const char* hd_fs[] = {
"adfs",
"affs",
"autofs",
"befs",
"bfs",
"binfmt_misc",
"coda",
"coh",
"cramfs",
"devfs",
"devpts",
"efs",
"ext",
"ext2/ext3",
"ext2",
"fat",
"fusectl",
"fuseblk",
"hpfs",
"hugetlbfs",
"jffs2",
"jffs",
"jfs",
"lustre",
"minix",
"minix (30 char.)",
"minix v2",
"minix v2 (30 char.)",
"msdos",
"novell",
"nfs",
"nfsd",
"ntfs",
"openprom",
"proc",
"qnx4",
"ramfs",
"reiserfs",
"romfs",
"smb",
"squashfs",
"sysfs",
"sysv2",
"sysv4",
"tmpfs",
"ufs",
"vfat"
"vxfs",
"xenix",
"xfs",
"xia"
};
static const char* cd_fs[] = {
"iso9660",
"isofs",
"udf"
};
static const char* usb_fs[] = {
"usbdevfs"
};
/***************************************************************************/
template <class InputIterator, class OutputIterator, class Predicate>
OutputIterator copy_if( InputIterator first,
InputIterator last,
OutputIterator result,
Predicate pred
)
{
InputIterator currentIn = first;
OutputIterator currentOut = result;
while (currentIn != last) {
if (pred(*currentIn)) {
*currentOut = *currentIn;
++currentOut;
++currentIn;
} else {
++currentIn;
}
}
return currentOut;
}
/***************************************************************************/
struct Drive {
typedef enum _d_type {hdd, usb, cdrom} d_type;
/**/
Drive() {}
Drive(const Drive& d) {
device = d.device;
mpoint = d.mpoint;
type = d.type;
}
void reset() {
device.clear();
mpoint.clear();
}
std::string device;
std::string mpoint;
d_type type;
};
typedef std::vector<Drive> DriveList;
/***************************************************************************/
bool is_ignored_predicate(std::string::value_type v) {
return (v != ' ' && v != '\t');
}
bool is_not_ignored_predicate(std::string::value_type v) {
return !is_ignored_predicate(v);
}
/***************************************************************************/
bool parse_string(Drive* d, std::string& s) {
if ( !(s.substr(0, 5) == "/dev/") ) return false;
std::string type;
std::string::iterator it1;
std::string::iterator it2;
it1 = s.begin();
it2 = std::find_if(it1, s.end(), is_not_ignored_predicate);
d->device.resize(it2-it1);
std::copy(it1, it2, d->device.begin());
it1 = std::find_if(it2, s.end(), is_ignored_predicate);
it2 = std::find_if(it1, s.end(), is_not_ignored_predicate);
d->mpoint.resize(it2-it1);
std::copy(it1, it2, d->mpoint.begin());
it1 = std::find_if(it2, s.end(), is_ignored_predicate);
it2 = std::find_if(it1, s.end(), is_not_ignored_predicate);
type.resize(it2-it1);
std::copy(it1, it2, type.begin());
/* HDD */
for ( const char** p = &hd_fs[0]; *p != hd_fs[sizeof(hd_fs)/sizeof(hd_fs[0])]; p++ ) {
if ( type == *p ) {
d->type = Drive::hdd;
return true;
}
}
/* USB */
for ( const char** p = &usb_fs[0]; *p != usb_fs[sizeof(usb_fs)/sizeof(usb_fs[0])]; p++ ) {
if ( type == *p ) {
d->type = Drive::usb;
return true;
}
}
/* CD-ROM*/
for ( const char** p = &cd_fs[0]; *p != cd_fs[sizeof(cd_fs)/sizeof(cd_fs[0])]; p++ ) {
if ( type == *p ) {
d->type = Drive::cdrom;
return true;
}
}
return false;
}
/***************************************************************************/
DriveList get_all_drives() {
const char* fname = "/etc/mtab";
std::string buf;
Drive drive;
DriveList list;
std::ifstream in(fname);
if ( !in ) { return list; }
while ( !in.eof() ) {
std::getline(in, buf, '\n');
if ( buf.length() < 5 ) continue;
std::copy(std::find_if(buf.begin(), buf.end(), is_ignored_predicate),
buf.end(),
buf.begin()
);
if ( buf[0] == '#' ) continue;
if ( parse_string(&drive, buf) ) {
list.push_back(drive);
}
drive.reset();
}
return list;
}
/***************************************************************************/
template<Drive::d_type T> bool is_required_drive_type(const Drive& d) {
return d.type == T;
}
template<Drive::d_type T> DriveList get_drives() {
DriveList list = get_all_drives();
DriveList::iterator it;
it = copy_if(list.begin(), list.end(), list.begin(), is_required_drive_type<T>);
list.resize(it-list.begin());
return list;
}
/***************************************************************************/
int main(int argc, char** argv) {
DriveList h = get_drives<Drive::hdd>();
DriveList u = get_drives<Drive::usb>();
DriveList c = get_drives<Drive::cdrom>();
return 0;
}
/***************************************************************************/
|
|
Проще самому написать 
