• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.10.5 API Reference
  • KDE Home
  • Contact Us
 

KDECore

  • kdecore
  • io
kmountpoint.cpp
Go to the documentation of this file.
1 /*
2  * This file is part of the KDE libraries
3  * Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
4  * 2007 David Faure <faure@kde.org>
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License version 2 as published by the Free Software Foundation.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB. If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20 
21 #include "kmountpoint.h"
22 
23 #include <config.h>
24 #include <stdlib.h>
25 
26 #include <QtCore/QFile>
27 #include <QtCore/QTextIStream>
28 
29 #include "kstandarddirs.h"
30 
31 #ifdef Q_WS_WIN
32 #include <windows.h>
33 #include <QDir>
34 #endif
35 
36 #ifdef HAVE_VOLMGT
37 #include <volmgt.h>
38 #endif
39 #ifdef HAVE_SYS_MNTTAB_H
40 #include <sys/mnttab.h>
41 #endif
42 #ifdef HAVE_MNTENT_H
43 #include <mntent.h>
44 #elif defined(HAVE_SYS_MNTENT_H)
45 #include <sys/mntent.h>
46 #endif
47 
48 // This is the *BSD branch
49 #ifdef HAVE_SYS_MOUNT_H
50 #ifdef HAVE_SYS_TYPES_H
51 #include <sys/types.h>
52 #endif
53 #ifdef HAVE_SYS_PARAM_H
54 #include <sys/param.h>
55 #endif
56 #include <sys/mount.h>
57 #endif
58 
59 #ifdef HAVE_FSTAB_H
60 #include <fstab.h>
61 #endif
62 #if defined(_AIX)
63 #include <sys/mntctl.h>
64 #include <sys/vmount.h>
65 #include <sys/vfs.h>
66 /* AIX does not prototype mntctl anywhere that I can find */
67 #ifndef mntctl
68 extern "C" int mntctl(int command, int size, void* buffer);
69 #endif
70 extern "C" struct vfs_ent *getvfsbytype(int vfsType);
71 extern "C" void endvfsent( );
72 #endif
73 
74 
75 #ifndef HAVE_GETMNTINFO
76 # ifdef _PATH_MOUNTED
77 // On some Linux, MNTTAB points to /etc/fstab !
78 # undef MNTTAB
79 # define MNTTAB _PATH_MOUNTED
80 # else
81 # ifndef MNTTAB
82 # ifdef MTAB_FILE
83 # define MNTTAB MTAB_FILE
84 # else
85 # define MNTTAB "/etc/mnttab"
86 # endif
87 # endif
88 # endif
89 #endif
90 
91 #include "kdebug.h"
92 
93 
94 #ifdef _OS_SOLARIS_
95 #define FSTAB "/etc/vfstab"
96 #else
97 #define FSTAB "/etc/fstab"
98 #endif
99 
100 class KMountPoint::Private {
101 public:
102  void finalizePossibleMountPoint(DetailsNeededFlags infoNeeded);
103  void finalizeCurrentMountPoint(DetailsNeededFlags infoNeeded);
104 
105  QString mountedFrom;
106  QString device; // Only available when the NeedRealDeviceName flag was set.
107  QString mountPoint;
108  QString mountType;
109  QStringList mountOptions;
110 };
111 
112 KMountPoint::KMountPoint()
113  :d( new Private )
114 {
115 }
116 
117 KMountPoint::~KMountPoint()
118 {
119  delete d;
120 }
121 
122 // There are (at least) four kind of APIs:
123 // setmntent + getmntent + struct mntent (linux...)
124 // getmntent + struct mnttab
125 // mntctl + struct vmount (AIX)
126 // getmntinfo + struct statfs&flags (BSD 4.4 and friends)
127 // getfsent + char* (BSD 4.3 and friends)
128 
129 #ifdef HAVE_SETMNTENT
130 #define SETMNTENT setmntent
131 #define ENDMNTENT endmntent
132 #define STRUCT_MNTENT struct mntent *
133 #define STRUCT_SETMNTENT FILE *
134 #define GETMNTENT(file, var) ((var = getmntent(file)) != 0)
135 #define MOUNTPOINT(var) var->mnt_dir
136 #define MOUNTTYPE(var) var->mnt_type
137 #define MOUNTOPTIONS(var) var->mnt_opts
138 #define FSNAME(var) var->mnt_fsname
139 #else
140 #define SETMNTENT fopen
141 #define ENDMNTENT fclose
142 #define STRUCT_MNTENT struct mnttab
143 #define STRUCT_SETMNTENT FILE *
144 #define GETMNTENT(file, var) (getmntent(file, &var) == 0)
145 #define MOUNTPOINT(var) var.mnt_mountp
146 #define MOUNTTYPE(var) var.mnt_fstype
147 #define MOUNTOPTIONS(var) var.mnt_mntopts
148 #define FSNAME(var) var.mnt_special
149 #endif
150 
155 static QString devNameFromOptions(const QStringList &options)
156 {
157  // Search options to find the device name
158  for ( QStringList::ConstIterator it = options.begin(); it != options.end(); ++it)
159  {
160  if( (*it).startsWith(QLatin1String("dev=")))
161  return (*it).mid(4);
162  }
163  return QString::fromLatin1("none");
164 }
165 
166 void KMountPoint::Private::finalizePossibleMountPoint(DetailsNeededFlags infoNeeded)
167 {
168  if (mountType == QLatin1String("supermount")) {
169  mountedFrom = devNameFromOptions(mountOptions);
170  }
171 
172  if (mountedFrom.startsWith(QLatin1String("UUID="))) {
173  const QString uuid = mountedFrom.mid(5);
174  const QString potentialDevice = QFile::symLinkTarget(QString::fromLatin1("/dev/disk/by-uuid/") + uuid);
175  if (QFile::exists(potentialDevice)) {
176  mountedFrom = potentialDevice;
177  }
178  }
179  if (mountedFrom.startsWith(QLatin1String("LABEL="))) {
180  const QString label = mountedFrom.mid(6);
181  const QString potentialDevice = QFile::symLinkTarget(QString::fromLatin1("/dev/disk/by-label/") + label);
182  if (QFile::exists(potentialDevice)) {
183  mountedFrom = potentialDevice;
184  }
185  }
186 
187  if (infoNeeded & NeedRealDeviceName) {
188  if (mountedFrom.startsWith(QLatin1Char('/')))
189  device = KStandardDirs::realFilePath(mountedFrom);
190  }
191  // TODO: Strip trailing '/' ?
192 }
193 
194 void KMountPoint::Private::finalizeCurrentMountPoint(DetailsNeededFlags infoNeeded)
195 {
196  if (infoNeeded & NeedRealDeviceName) {
197  if (mountedFrom.startsWith(QLatin1Char('/')))
198  device = KStandardDirs::realFilePath(mountedFrom);
199  }
200 }
201 
202 KMountPoint::List KMountPoint::possibleMountPoints(DetailsNeededFlags infoNeeded)
203 {
204 #ifdef Q_WS_WIN
205  return KMountPoint::currentMountPoints(infoNeeded);
206 #endif
207 
208  KMountPoint::List result;
209 
210 #ifdef HAVE_SETMNTENT
211  STRUCT_SETMNTENT fstab;
212  if ((fstab = SETMNTENT(FSTAB, "r")) == 0)
213  return result;
214 
215  STRUCT_MNTENT fe;
216  while (GETMNTENT(fstab, fe))
217  {
218  Ptr mp(new KMountPoint);
219  mp->d->mountedFrom = QFile::decodeName(FSNAME(fe));
220 
221  mp->d->mountPoint = QFile::decodeName(MOUNTPOINT(fe));
222  mp->d->mountType = QFile::decodeName(MOUNTTYPE(fe));
223 
224  //Devices using supermount have their device names in the mount options
225  //instead of the device field. That's why we need to read the mount options
226  if (infoNeeded & NeedMountOptions || (mp->d->mountType == QLatin1String("supermount")))
227  {
228  QString options = QFile::decodeName(MOUNTOPTIONS(fe));
229  mp->d->mountOptions = options.split( QLatin1Char(',') );
230  }
231 
232  mp->d->finalizePossibleMountPoint(infoNeeded);
233 
234  result.append(mp);
235  }
236  ENDMNTENT(fstab);
237 #else
238  QFile f(QLatin1String(FSTAB));
239  if ( !f.open(QIODevice::ReadOnly) )
240  return result;
241 
242  QTextStream t (&f);
243  QString s;
244 
245  while (! t.atEnd())
246  {
247  s=t.readLine().simplified();
248  if ( s.isEmpty() || (s[0] == QLatin1Char('#')))
249  continue;
250 
251  // not empty or commented out by '#'
252  const QStringList item = s.split(QLatin1Char(' '));
253 
254 #ifdef _OS_SOLARIS_
255  if (item.count() < 5)
256  continue;
257 #else
258  if (item.count() < 4)
259  continue;
260 #endif
261 
262  Ptr mp(new KMountPoint);
263 
264  int i = 0;
265  mp->d->mountedFrom = item[i++];
266 #ifdef _OS_SOLARIS_
267  //device to fsck
268  i++;
269 #endif
270  mp->d->mountPoint = item[i++];
271  mp->d->mountType = item[i++];
272  QString options = item[i++];
273 
274  if (infoNeeded & NeedMountOptions)
275  {
276  mp->d->mountOptions = options.split(QLatin1Char(','));
277  }
278 
279  mp->d->finalizePossibleMountPoint(infoNeeded);
280 
281  result.append(mp);
282  } //while
283 
284  f.close();
285 #endif
286  return result;
287 }
288 
289 KMountPoint::List KMountPoint::currentMountPoints(DetailsNeededFlags infoNeeded)
290 {
291  KMountPoint::List result;
292 
293 #ifdef HAVE_GETMNTINFO
294 
295 #ifdef GETMNTINFO_USES_STATVFS
296  struct statvfs *mounted;
297 #else
298  struct statfs *mounted;
299 #endif
300 
301  int num_fs = getmntinfo(&mounted, MNT_NOWAIT);
302 
303  for (int i=0;i< num_fs;i++)
304  {
305  Ptr mp(new KMountPoint);
306  mp->d->mountedFrom = QFile::decodeName(mounted[i].f_mntfromname);
307  mp->d->mountPoint = QFile::decodeName(mounted[i].f_mntonname);
308 
309 #ifdef __osf__
310  mp->d->mountType = QFile::decodeName(mnt_names[mounted[i].f_type]);
311 #else
312  mp->d->mountType = QFile::decodeName(mounted[i].f_fstypename);
313 #endif
314 
315  if (infoNeeded & NeedMountOptions)
316  {
317  struct fstab *ft = getfsfile(mounted[i].f_mntonname);
318  if (ft != 0) {
319  QString options = QFile::decodeName(ft->fs_mntops);
320  mp->d->mountOptions = options.split(QLatin1Char(','));
321  } else {
322  // TODO: get mount options if not mounted via fstab, see mounted[i].f_flags
323  }
324  }
325 
326  mp->d->finalizeCurrentMountPoint(infoNeeded);
327  // TODO: Strip trailing '/' ?
328  result.append(mp);
329  }
330 
331 #elif defined(_AIX)
332 
333  struct vmount *mntctl_buffer;
334  struct vmount *vm;
335  char *mountedfrom;
336  char *mountedto;
337  int fsname_len, num;
338  int buf_sz = 4096;
339 
340  mntctl_buffer = (struct vmount*)malloc(buf_sz);
341  num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
342  if (num == 0)
343  {
344  buf_sz = *(int*)mntctl_buffer;
345  free(mntctl_buffer);
346  mntctl_buffer = (struct vmount*)malloc(buf_sz);
347  num = mntctl(MCTL_QUERY, buf_sz, mntctl_buffer);
348  }
349 
350  if (num > 0)
351  {
352  /* iterate through items in the vmount structure: */
353  vm = (struct vmount *)mntctl_buffer;
354  for ( ; num > 0; --num )
355  {
356  /* get the name of the mounted file systems: */
357  fsname_len = vmt2datasize(vm, VMT_STUB);
358  mountedto = (char*)malloc(fsname_len + 1);
359  mountedto[fsname_len] = '\0';
360  strncpy(mountedto, (char *)vmt2dataptr(vm, VMT_STUB), fsname_len);
361 
362  fsname_len = vmt2datasize(vm, VMT_OBJECT);
363  mountedfrom = (char*)malloc(fsname_len + 1);
364  mountedfrom[fsname_len] = '\0';
365  strncpy(mountedfrom, (char *)vmt2dataptr(vm, VMT_OBJECT), fsname_len);
366 
367  /* Look up the string for the file system type,
368  * as listed in /etc/vfs.
369  * ex.: nfs,jfs,afs,cdrfs,sfs,cachefs,nfs3,autofs
370  */
371  struct vfs_ent* ent = getvfsbytype(vm->vmt_gfstype);
372 
373  KMountPoint *mp = new KMountPoint;
374  mp->d->mountedFrom = QFile::decodeName(mountedfrom);
375  mp->d->mountPoint = QFile::decodeName(mountedto);
376  mp->d->mountType = QFile::decodeName(ent->vfsent_name);
377 
378  free(mountedfrom);
379  free(mountedto);
380 
381  if (infoNeeded & NeedMountOptions)
382  {
383  // TODO
384  }
385 
386  mp->d->finalizeCurrentMountPoint(infoNeeded);
387  result.append(mp);
388 
389  /* goto the next vmount structure: */
390  vm = (struct vmount *)((char *)vm + vm->vmt_length);
391  }
392 
393  endvfsent( );
394  }
395 
396  free( mntctl_buffer );
397 #elif defined(Q_WS_WIN) && !defined(_WIN32_WCE)
398  //nothing fancy with infoNeeded but it gets the job done
399  DWORD bits = GetLogicalDrives();
400  if(!bits)
401  return result;
402 
403  for(int i = 0; i < 26; i++)
404  {
405  if(bits & (1 << i))
406  {
407  Ptr mp(new KMountPoint);
408  mp->d->mountPoint = QString(QLatin1Char('A' + i) + QLatin1String(":/"));
409  result.append(mp);
410  }
411  }
412 
413 #elif defined(_WIN32_WCE)
414  Ptr mp(new KMountPoint);
415  mp->d->mountPoint = QString("/");
416  result.append(mp);
417 
418 #else
419  STRUCT_SETMNTENT mnttab;
420  if ((mnttab = SETMNTENT(MNTTAB, "r")) == 0)
421  return result;
422 
423  STRUCT_MNTENT fe;
424  while (GETMNTENT(mnttab, fe))
425  {
426  Ptr mp(new KMountPoint);
427  mp->d->mountedFrom = QFile::decodeName(FSNAME(fe));
428 
429  mp->d->mountPoint = QFile::decodeName(MOUNTPOINT(fe));
430  mp->d->mountType = QFile::decodeName(MOUNTTYPE(fe));
431 
432  //Devices using supermount have their device names in the mount options
433  //instead of the device field. That's why we need to read the mount options
434  if (infoNeeded & NeedMountOptions || (mp->d->mountType == QLatin1String("supermount")))
435  {
436  QString options = QFile::decodeName(MOUNTOPTIONS(fe));
437  mp->d->mountOptions = options.split( QLatin1Char(',') );
438  }
439  mp->d->finalizeCurrentMountPoint(infoNeeded);
440 
441  result.append(mp);
442  }
443  ENDMNTENT(mnttab);
444 #endif
445  return result;
446 }
447 
448 QString KMountPoint::mountedFrom() const
449 {
450  return d->mountedFrom;
451 }
452 
453 QString KMountPoint::realDeviceName() const
454 {
455  return d->device;
456 }
457 
458 QString KMountPoint::mountPoint() const
459 {
460  return d->mountPoint;
461 }
462 
463 QString KMountPoint::mountType() const
464 {
465  return d->mountType;
466 }
467 
468 QStringList KMountPoint::mountOptions() const
469 {
470  return d->mountOptions;
471 }
472 
473 KMountPoint::List::List()
474  : QList<Ptr>()
475 {
476 }
477 
478 static bool pathsAreParentAndChildOrEqual(const QString& parent, const QString& child)
479 {
480  const QLatin1Char slash('/');
481 
482  if (child.startsWith(parent)) {
483  // Check if either
484  // (a) both paths are equal, or
485  // (b) parent ends with '/', or
486  // (c) the first character of child that is not shared with parent is '/'.
487  // Note that child is guaranteed to be longer than parent if (a) is false.
488  //
489  // This prevents that we incorrectly consider "/books" a child of "/book".
490  return parent == child || parent.endsWith(slash) || child.at(parent.length()) == slash;
491  } else {
492  // Note that "/books" is a child of "/books/".
493  return parent.endsWith(slash) && (parent.length() == child.length() + 1) && parent.startsWith(child);
494  }
495 }
496 
497 KMountPoint::Ptr KMountPoint::List::findByPath(const QString& path) const
498 {
499 #ifndef Q_WS_WIN
500  /* If the path contains symlinks, get the real name */
501  const QString realname = KStandardDirs::realFilePath(path);
502 #else
503  const QString realname = QDir::fromNativeSeparators(QDir(path).absolutePath());
504 #endif
505 
506  int max = 0;
507  KMountPoint::Ptr result;
508  for (const_iterator it = begin(); it != end(); ++it) {
509  const QString mountpoint = (*it)->d->mountPoint;
510  const int length = mountpoint.length();
511  if (length > max && pathsAreParentAndChildOrEqual(mountpoint, realname)) {
512  max = length;
513  result = *it;
514  // keep iterating to check for a better match (bigger max)
515  }
516  }
517  return result;
518 }
519 
520 KMountPoint::Ptr KMountPoint::List::findByDevice(const QString& device) const
521 {
522  const QString realDevice = KStandardDirs::realFilePath(device);
523  if (realDevice.isEmpty()) // d->device can be empty in the loop below, don't match empty with it
524  return Ptr();
525  for (const_iterator it = begin(); it != end(); ++it) {
526  if ((*it)->d->device == realDevice ||
527  (*it)->d->mountedFrom == realDevice)
528  return *it;
529  }
530  return Ptr();
531 }
532 
533 bool KMountPoint::probablySlow() const
534 {
535  bool nfs = d->mountType == QLatin1String("nfs");
536  bool autofs = d->mountType == QLatin1String("autofs") || d->mountType == QLatin1String("subfs");
537  //bool pid = d->mountPoint.contains(":(pid");
538  // The "pid" thing was in kde3's KIO::probably_slow_mounted, with obscure logic
539  // (looks like it used state from the previous line or something...)
540  // This needs to be revised once we have a testcase or explanation about it.
541  // But autofs works already, it shows nfs as mountType in mtab.
542  if (nfs || autofs) {
543  return true;
544  }
545  return false;
546 }
547 
548 bool KMountPoint::testFileSystemFlag(FileSystemFlag flag) const
549 {
550  const bool isMsDos = ( d->mountType == QLatin1String("msdos") || d->mountType == QLatin1String("fat") || d->mountType == QLatin1String("vfat") );
551  const bool isNtfs = d->mountType.contains(QLatin1String("fuse.ntfs")) || d->mountType.contains(QLatin1String("fuseblk.ntfs"))
552  // fuseblk could really be anything. But its most common use is for NTFS mounts, these days.
553  || d->mountType == QLatin1String("fuseblk");
554  const bool isSmb = d->mountType == QLatin1String("cifs") || d->mountType == QLatin1String("smbfs");
555 
556  switch (flag) {
557  case SupportsChmod:
558  case SupportsChown:
559  case SupportsUTime:
560  case SupportsSymlinks:
561  return !isMsDos && !isNtfs && !isSmb; // it's amazing the number of things Microsoft filesystems don't support :)
562  case CaseInsensitive:
563  return isMsDos;
564  }
565  return false;
566 }
567 
FSTAB
#define FSTAB
Definition: kmountpoint.cpp:97
KSharedPtr
Can be used to control the lifetime of an object that has derived QSharedData.
Definition: kconfiggroup.h:38
KMountPoint::probablySlow
bool probablySlow() const
Checks if the filesystem that is probably slow (nfs mounts).
Definition: kmountpoint.cpp:533
KMountPoint
The KMountPoint class provides information about mounted and unmounted disks.
Definition: kmountpoint.h:35
kdebug.h
GETMNTENT
#define GETMNTENT(file, var)
Definition: kmountpoint.cpp:144
KStandardDirs::realFilePath
static QString realFilePath(const QString &filename)
Expands all symbolic links and resolves references to &#39;/.
Definition: kstandarddirs.cpp:967
KSharedPtr::d
T * d
Definition: ksharedptr.h:193
STRUCT_SETMNTENT
#define STRUCT_SETMNTENT
Definition: kmountpoint.cpp:143
STRUCT_MNTENT
#define STRUCT_MNTENT
Definition: kmountpoint.cpp:142
kmountpoint.h
KMountPoint::currentMountPoints
static List currentMountPoints(DetailsNeededFlags infoNeeded=BasicInfoNeeded)
This function gives a list of all currently used mountpoints.
Definition: kmountpoint.cpp:289
KMountPoint::mountedFrom
QString mountedFrom() const
Where this filesystem gets mounted from.
Definition: kmountpoint.cpp:448
KMountPoint::~KMountPoint
~KMountPoint()
Destructor.
Definition: kmountpoint.cpp:117
KMountPoint::realDeviceName
QString realDeviceName() const
Canonical name of the device where the filesystem got mounted from.
Definition: kmountpoint.cpp:453
KMountPoint::List::findByDevice
Ptr findByDevice(const QString &device) const
Returns the mount point associated with device, i.e.
Definition: kmountpoint.cpp:520
QString
KMountPoint::NeedMountOptions
Definition: kmountpoint.h:70
SETMNTENT
#define SETMNTENT
Definition: kmountpoint.cpp:140
KMountPoint::SupportsUTime
Definition: kmountpoint.h:122
FSNAME
#define FSNAME(var)
Definition: kmountpoint.cpp:148
QStringList
KMountPoint::mountType
QString mountType() const
Type of filesystem.
Definition: kmountpoint.cpp:463
KMountPoint::SupportsChown
Definition: kmountpoint.h:122
MOUNTPOINT
#define MOUNTPOINT(var)
Definition: kmountpoint.cpp:145
KMountPoint::testFileSystemFlag
bool testFileSystemFlag(FileSystemFlag flag) const
Checks the capabilities of the filesystem.
Definition: kmountpoint.cpp:548
ENDMNTENT
#define ENDMNTENT
Definition: kmountpoint.cpp:141
KMountPoint::CaseInsensitive
Definition: kmountpoint.h:123
devNameFromOptions
static QString devNameFromOptions(const QStringList &options)
When using supermount, the device name is in the options field as dev=/my/device. ...
Definition: kmountpoint.cpp:155
KMountPoint::mountPoint
QString mountPoint() const
Path where the filesystem is mounted or can be mounted.
Definition: kmountpoint.cpp:458
KMountPoint::List::List
List()
Definition: kmountpoint.cpp:473
KMountPoint::Ptr
KSharedPtr< KMountPoint > Ptr
Definition: kmountpoint.h:38
KMountPoint::mountOptions
QStringList mountOptions() const
Options used to mount the filesystem.
Definition: kmountpoint.cpp:468
KMountPoint::possibleMountPoints
static List possibleMountPoints(DetailsNeededFlags infoNeeded=BasicInfoNeeded)
This function gives a list of all possible mountpoints.
Definition: kmountpoint.cpp:202
MOUNTOPTIONS
#define MOUNTOPTIONS(var)
Definition: kmountpoint.cpp:147
kstandarddirs.h
KMountPoint::List::findByPath
Ptr findByPath(const QString &path) const
Find the mountpoint on which resides path For instance if /home is a separate partition, findByPath(&quot;/home/user/blah&quot;) will return /home.
Definition: kmountpoint.cpp:497
KMountPoint::SupportsSymlinks
Definition: kmountpoint.h:123
pathsAreParentAndChildOrEqual
static bool pathsAreParentAndChildOrEqual(const QString &parent, const QString &child)
Definition: kmountpoint.cpp:478
KMountPoint::List
List of mount points.
Definition: kmountpoint.h:42
MOUNTTYPE
#define MOUNTTYPE(var)
Definition: kmountpoint.cpp:146
MNTTAB
#define MNTTAB
Definition: kmountpoint.cpp:85
KMountPoint::SupportsChmod
Definition: kmountpoint.h:122
KMountPoint::FileSystemFlag
FileSystemFlag
Definition: kmountpoint.h:122
QList
Definition: kaboutdata.h:33
This file is part of the KDE documentation.
Documentation copyright © 1996-2014 The KDE developers.
Generated on Wed Jun 11 2014 00:28:24 by doxygen 1.8.5 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KDECore

Skip menu "KDECore"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Modules
  • Related Pages

kdelibs-4.10.5 API Reference

Skip menu "kdelibs-4.10.5 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal