smb4k/core/smb4kcustomsettings.cpp

0001 /*
0002     This class carries custom settings
0003
0004     SPDX-FileCopyrightText: 2011-2023 Alexander Reinholdt <alexander.reinholdt@kdemail.net>
0005     SPDX-License-Identifier: GPL-2.0-or-later
0006 */
0007
0008 // application specific includes
0009 #include "smb4kcustomsettings.h"
0010 #include "smb4khost.h"
0011 #include "smb4ksettings.h"
0012 #include "smb4kshare.h"
0013
0014 #if defined(Q_OS_LINUX)
0015 #include "smb4kmountsettings_linux.h"
0016 #elif defined(Q_OS_FREEBSD) || defined(Q_OS_NETBSD)
0017 #include "smb4kmountsettings_bsd.h"
0018 #endif
0019
0020 // Qt includes
0021 #include <QDebug>
0022 #include <QHostAddress>
0023 #include <QRegularExpression>
0024
0025 // KDE includes
0026 #include <KLocalizedString>
0027
0028 class Smb4KCustomSettingsPrivate
0029 {
0030 public:
0031     QString workgroup;
0032     QUrl url;
0033     QHostAddress ip;
0034     NetworkItem type;
0035     int remount;
0036     bool useUser;
0037     KUser user;
0038     bool useGroup;
0039     KUserGroup group;
0040     bool useFileMode;
0041     QString fileMode;
0042     bool useDirectoryMode;
0043     QString directoryMode;
0044 #if defined(Q_OS_LINUX)
0045     bool cifsUnixExtensionsSupport;
0046     bool useFileSystemPort;
0047     int fileSystemPort;
0048     bool useMountProtocolVersion;
0049     int mountProtocolVersion;
0050     bool useSecurityMode;
0051     int securityMode;
0052     bool useWriteAccess;
0053     int writeAccess;
0054 #endif
0055     QString profile;
0056     bool useClientProtocolVersions;
0057     int minimalClientProtocolVersion;
0058     int maximalClientProtocolVersion;
0059     bool useSmbPort;
0060     int smbPort;
0061     bool useKerberos;
0062     QString macAddress;
0063     bool wakeOnLanBeforeFirstScan;
0064     bool wakeOnLanBeforeMount;
0065 };
0066
0067 Smb4KCustomSettings::Smb4KCustomSettings(Smb4KBasicNetworkItem *networkItem)
0068     : d(new Smb4KCustomSettingsPrivate)
0069 {
0070     d->type = networkItem->type();
0071     d->url = networkItem->url();
0072     d->remount = UndefinedRemount;
0073     d->useFileMode = Smb4KMountSettings::useFileMode();
0074     d->fileMode = Smb4KMountSettings::fileMode();
0075     d->useDirectoryMode = Smb4KMountSettings::useDirectoryMode();
0076     d->directoryMode = Smb4KMountSettings::directoryMode();
0077 #if defined(Q_OS_LINUX)
0078     d->cifsUnixExtensionsSupport = Smb4KMountSettings::cifsUnixExtensionsSupport();
0079     d->useMountProtocolVersion = Smb4KMountSettings::useSmbProtocolVersion();
0080     d->mountProtocolVersion = Smb4KMountSettings::smbProtocolVersion();
0081     d->useSecurityMode = Smb4KMountSettings::useSecurityMode();
0082     d->securityMode = Smb4KMountSettings::securityMode();
0083     d->useWriteAccess = Smb4KMountSettings::useWriteAccess();
0084     d->writeAccess = Smb4KMountSettings::writeAccess();
0085 #endif
0086
0087     switch (d->type) {
0088     case Host: {
0089         Smb4KHost *host = static_cast<Smb4KHost *>(networkItem);
0090
0091         if (host) {
0092             d->workgroup = host->workgroupName();
0093             d->ip.setAddress(host->ipAddress());
0094             d->useUser = Smb4KMountSettings::useUserId();
0095             d->user = KUser((K_UID)Smb4KMountSettings::userId().toInt());
0096             d->useGroup = Smb4KMountSettings::useGroupId();
0097             d->group = KUserGroup((K_GID)Smb4KMountSettings::groupId().toInt());
0098             d->useSmbPort = Smb4KSettings::useRemoteSmbPort();
0099             d->smbPort = host->port() != -1 ? host->port() : Smb4KSettings::remoteSmbPort();
0100 #if defined(Q_OS_LINUX)
0101             d->useFileSystemPort = Smb4KMountSettings::useRemoteFileSystemPort();
0102             d->fileSystemPort = Smb4KMountSettings::remoteFileSystemPort();
0103 #endif
0104         }
0105         break;
0106     }
0107     case Share: {
0108         Smb4KShare *share = static_cast<Smb4KShare *>(networkItem);
0109
0110         if (share) {
0111             d->workgroup = share->workgroupName();
0112             d->ip.setAddress(share->hostIpAddress());
0113             d->useUser = Smb4KMountSettings::useUserId();
0114             d->user = share->user();
0115             d->useGroup = Smb4KMountSettings::useGroupId();
0116             d->group = share->group();
0117             d->useSmbPort = Smb4KSettings::useRemoteSmbPort();
0118             d->smbPort = Smb4KSettings::remoteSmbPort();
0119 #if defined(Q_OS_LINUX)
0120             d->useFileSystemPort = Smb4KMountSettings::useRemoteFileSystemPort();
0121             d->fileSystemPort = share->port() != -1 ? share->port() : Smb4KMountSettings::remoteFileSystemPort();
0122 #endif
0123         }
0124         break;
0125     }
0126     default: {
0127         break;
0128     }
0129     }
0130
0131     d->useClientProtocolVersions = Smb4KSettings::useClientProtocolVersions();
0132     d->minimalClientProtocolVersion = Smb4KSettings::minimalClientProtocolVersion();
0133     d->maximalClientProtocolVersion = Smb4KSettings::maximalClientProtocolVersion();
0134     d->useKerberos = Smb4KSettings::useKerberos();
0135     d->wakeOnLanBeforeFirstScan = false;
0136     d->wakeOnLanBeforeMount = false;
0137 }
0138
0139 Smb4KCustomSettings::Smb4KCustomSettings(const Smb4KCustomSettings &o)
0140     : d(new Smb4KCustomSettingsPrivate)
0141 {
0142     *d = *o.d;
0143 }
0144
0145 Smb4KCustomSettings::Smb4KCustomSettings()
0146     : d(new Smb4KCustomSettingsPrivate)
0147 {
0148     d->type = UnknownNetworkItem;
0149     d->remount = UndefinedRemount;
0150     d->useUser = Smb4KMountSettings::useUserId();
0151     d->user = KUser((K_UID)Smb4KMountSettings::userId().toInt());
0152     d->useGroup = Smb4KMountSettings::useGroupId();
0153     d->group = KUserGroup((K_GID)Smb4KMountSettings::groupId().toInt());
0154     d->useFileMode = Smb4KMountSettings::useFileMode();
0155     d->fileMode = Smb4KMountSettings::fileMode();
0156     d->useDirectoryMode = Smb4KMountSettings::useDirectoryMode();
0157     d->directoryMode = Smb4KMountSettings::directoryMode();
0158 #if defined(Q_OS_LINUX)
0159     d->cifsUnixExtensionsSupport = Smb4KMountSettings::cifsUnixExtensionsSupport();
0160     d->useFileSystemPort = Smb4KMountSettings::useRemoteFileSystemPort();
0161     d->fileSystemPort = Smb4KMountSettings::remoteFileSystemPort();
0162     d->useMountProtocolVersion = Smb4KMountSettings::useSmbProtocolVersion();
0163     d->mountProtocolVersion = Smb4KMountSettings::smbProtocolVersion();
0164     d->useSecurityMode = Smb4KMountSettings::useSecurityMode();
0165     d->securityMode = Smb4KMountSettings::securityMode();
0166     d->useWriteAccess = Smb4KMountSettings::useWriteAccess();
0167     d->writeAccess = Smb4KMountSettings::writeAccess();
0168 #endif
0169     d->useClientProtocolVersions = Smb4KSettings::useClientProtocolVersions();
0170     d->minimalClientProtocolVersion = Smb4KSettings::minimalClientProtocolVersion();
0171     d->maximalClientProtocolVersion = Smb4KSettings::maximalClientProtocolVersion();
0172     d->useSmbPort = Smb4KSettings::useRemoteSmbPort();
0173     d->smbPort = Smb4KSettings::remoteSmbPort();
0174     d->useKerberos = Smb4KSettings::useKerberos();
0175     d->wakeOnLanBeforeFirstScan = false;
0176     d->wakeOnLanBeforeMount = false;
0177 }
0178
0179 Smb4KCustomSettings::~Smb4KCustomSettings()
0180 {
0181 }
0182
0183 void Smb4KCustomSettings::setNetworkItem(Smb4KBasicNetworkItem *networkItem) const
0184 {
0185     if (networkItem && d->type == UnknownNetworkItem) {
0186         d->type = networkItem->type();
0187         d->url = networkItem->url();
0188
0189         switch (d->type) {
0190         case Host: {
0191             Smb4KHost *host = static_cast<Smb4KHost *>(networkItem);
0192
0193             if (host) {
0194                 d->workgroup = host->workgroupName();
0195                 d->smbPort = host->port() != -1 ? host->port() : d->smbPort;
0196                 d->ip.setAddress(host->ipAddress());
0197             }
0198             break;
0199         }
0200         case Share: {
0201             Smb4KShare *share = static_cast<Smb4KShare *>(networkItem);
0202
0203             if (share) {
0204                 d->workgroup = share->workgroupName();
0205 #if defined(Q_OS_LINUX)
0206                 d->fileSystemPort = share->port() != -1 ? share->port() : d->fileSystemPort;
0207 #endif
0208                 d->user = share->user();
0209                 d->group = share->group();
0210                 d->ip.setAddress(share->hostIpAddress());
0211             }
0212             break;
0213         }
0214         default: {
0215             break;
0216         }
0217         }
0218     }
0219 }
0220
0221 Smb4KGlobal::NetworkItem Smb4KCustomSettings::type() const
0222 {
0223     return d->type;
0224 }
0225
0226 void Smb4KCustomSettings::setWorkgroupName(const QString &workgroup) const
0227 {
0228     d->workgroup = workgroup;
0229 }
0230
0231 QString Smb4KCustomSettings::workgroupName() const
0232 {
0233     return d->workgroup;
0234 }
0235
0236 void Smb4KCustomSettings::setUrl(const QUrl &url) const
0237 {
0238     d->url = url;
0239 }
0240
0241 QUrl Smb4KCustomSettings::url() const
0242 {
0243     return d->url;
0244 }
0245
0246 QString Smb4KCustomSettings::hostName() const
0247 {
0248     return d->url.host().toUpper();
0249 }
0250
0251 QString Smb4KCustomSettings::shareName() const
0252 {
0253     if (d->url.path().startsWith(QStringLiteral("/"))) {
0254         return d->url.path().remove(0, 1);
0255     }
0256
0257     return d->url.path();
0258 }
0259
0260 void Smb4KCustomSettings::setIpAddress(const QString &ip) const
0261 {
0262     d->ip.setAddress(ip);
0263 }
0264
0265 QString Smb4KCustomSettings::ipAddress() const
0266 {
0267     return d->ip.toString();
0268 }
0269
0270 bool Smb4KCustomSettings::hasIpAddress() const
0271 {
0272     return !d->ip.isNull();
0273 }
0274
0275 QString Smb4KCustomSettings::displayString() const
0276 {
0277     QString string;
0278
0279     switch (d->type) {
0280     case Host: {
0281         string = hostName();
0282         break;
0283     }
0284     case Share: {
0285         string = i18n("%1 on %2", shareName(), hostName());
0286         break;
0287     }
0288     default: {
0289         break;
0290     }
0291     }
0292
0293     return string;
0294 }
0295
0296 void Smb4KCustomSettings::setRemount(int remount) const
0297 {
0298     switch (d->type) {
0299     case Share: {
0300         if (d->remount != remount) {
0301             d->remount = remount;
0302         }
0303         break;
0304     }
0305     default: {
0306         d->remount = UndefinedRemount;
0307         break;
0308     }
0309     }
0310 }
0311
0312 int Smb4KCustomSettings::remount() const
0313 {
0314     return d->remount;
0315 }
0316
0317 void Smb4KCustomSettings::setUseUser(bool use) const
0318 {
0319     d->useUser = use;
0320 }
0321
0322 bool Smb4KCustomSettings::useUser() const
0323 {
0324     return d->useUser;
0325 }
0326
0327 void Smb4KCustomSettings::setUser(const KUser &user) const
0328 {
0329     d->user = user;
0330 }
0331
0332 KUser Smb4KCustomSettings::user() const
0333 {
0334     return d->user;
0335 }
0336
0337 void Smb4KCustomSettings::setUseGroup(bool use) const
0338 {
0339     d->useGroup = use;
0340 }
0341
0342 bool Smb4KCustomSettings::useGroup() const
0343 {
0344     return d->useGroup;
0345 }
0346
0347 void Smb4KCustomSettings::setGroup(const KUserGroup &group) const
0348 {
0349     d->group = group;
0350 }
0351
0352 KUserGroup Smb4KCustomSettings::group() const
0353 {
0354     return d->group;
0355 }
0356
0357 void Smb4KCustomSettings::setUseFileMode(bool use) const
0358 {
0359     d->useFileMode = use;
0360 }
0361
0362 bool Smb4KCustomSettings::useFileMode() const
0363 {
0364     return d->useFileMode;
0365 }
0366
0367 void Smb4KCustomSettings::setFileMode(const QString &mode) const
0368 {
0369     d->fileMode = mode;
0370 }
0371
0372 QString Smb4KCustomSettings::fileMode() const
0373 {
0374     return d->fileMode;
0375 }
0376
0377 void Smb4KCustomSettings::setUseDirectoryMode(bool use) const
0378 {
0379     d->useDirectoryMode = use;
0380 }
0381
0382 bool Smb4KCustomSettings::useDirectoryMode() const
0383 {
0384     return d->useDirectoryMode;
0385 }
0386
0387 void Smb4KCustomSettings::setDirectoryMode(const QString &mode) const
0388 {
0389     d->directoryMode = mode;
0390 }
0391
0392 QString Smb4KCustomSettings::directoryMode() const
0393 {
0394     return d->directoryMode;
0395 }
0396
0397 #if defined(Q_OS_LINUX)
0398 void Smb4KCustomSettings::setCifsUnixExtensionsSupport(bool support) const
0399 {
0400     d->cifsUnixExtensionsSupport = support;
0401 }
0402
0403 bool Smb4KCustomSettings::cifsUnixExtensionsSupport() const
0404 {
0405     return d->cifsUnixExtensionsSupport;
0406 }
0407
0408 void Smb4KCustomSettings::setUseFileSystemPort(bool use) const
0409 {
0410     d->useFileSystemPort = use;
0411 }
0412
0413 bool Smb4KCustomSettings::useFileSystemPort() const
0414 {
0415     return d->useFileSystemPort;
0416 }
0417
0418 void Smb4KCustomSettings::setFileSystemPort(int port) const
0419 {
0420     d->fileSystemPort = port;
0421
0422     switch (d->type) {
0423     case Share: {
0424         d->url.setPort(port);
0425         break;
0426     }
0427     default: {
0428         break;
0429     }
0430     }
0431 }
0432
0433 int Smb4KCustomSettings::fileSystemPort() const
0434 {
0435     return d->fileSystemPort;
0436 }
0437
0438 void Smb4KCustomSettings::setUseMountProtocolVersion(bool use) const
0439 {
0440     d->useMountProtocolVersion = use;
0441 }
0442
0443 bool Smb4KCustomSettings::useMountProtocolVersion() const
0444 {
0445     return d->useMountProtocolVersion;
0446 }
0447
0448 void Smb4KCustomSettings::setMountProtocolVersion(int version) const
0449 {
0450     d->mountProtocolVersion = version;
0451 }
0452
0453 int Smb4KCustomSettings::mountProtocolVersion() const
0454 {
0455     return d->mountProtocolVersion;
0456 }
0457
0458 void Smb4KCustomSettings::setUseSecurityMode(bool use) const
0459 {
0460     d->useSecurityMode = use;
0461 }
0462
0463 bool Smb4KCustomSettings::useSecurityMode() const
0464 {
0465     return d->useSecurityMode;
0466 }
0467
0468 void Smb4KCustomSettings::setSecurityMode(int mode) const
0469 {
0470     d->securityMode = mode;
0471 }
0472
0473 int Smb4KCustomSettings::securityMode() const
0474 {
0475     return d->securityMode;
0476 }
0477
0478 void Smb4KCustomSettings::setUseWriteAccess(bool use) const
0479 {
0480     d->useWriteAccess = use;
0481 }
0482
0483 bool Smb4KCustomSettings::useWriteAccess() const
0484 {
0485     return d->useWriteAccess;
0486 }
0487
0488 void Smb4KCustomSettings::setWriteAccess(int access) const
0489 {
0490     d->writeAccess = access;
0491 }
0492
0493 int Smb4KCustomSettings::writeAccess() const
0494 {
0495     return d->writeAccess;
0496 }
0497 #endif
0498
0499 void Smb4KCustomSettings::setProfile(const QString &profile) const
0500 {
0501     d->profile = profile;
0502 }
0503
0504 QString Smb4KCustomSettings::profile() const
0505 {
0506     return d->profile;
0507 }
0508
0509 void Smb4KCustomSettings::setUseClientProtocolVersions(bool use) const
0510 {
0511     d->useClientProtocolVersions = use;
0512 }
0513
0514 bool Smb4KCustomSettings::useClientProtocolVersions() const
0515 {
0516     return d->useClientProtocolVersions;
0517 }
0518
0519 void Smb4KCustomSettings::setMinimalClientProtocolVersion(int version) const
0520 {
0521     d->minimalClientProtocolVersion = version;
0522 }
0523
0524 int Smb4KCustomSettings::minimalClientProtocolVersion() const
0525 {
0526     return d->minimalClientProtocolVersion;
0527 }
0528
0529 void Smb4KCustomSettings::setMaximalClientProtocolVersion(int version) const
0530 {
0531     d->maximalClientProtocolVersion = version;
0532 }
0533
0534 int Smb4KCustomSettings::maximalClientProtocolVersion() const
0535 {
0536     return d->maximalClientProtocolVersion;
0537 }
0538
0539 void Smb4KCustomSettings::setUseSmbPort(bool use) const
0540 {
0541     d->useSmbPort = use;
0542 }
0543
0544 bool Smb4KCustomSettings::useSmbPort() const
0545 {
0546     return d->useSmbPort;
0547 }
0548
0549 void Smb4KCustomSettings::setSmbPort(int port) const
0550 {
0551     d->smbPort = port;
0552
0553     switch (d->type) {
0554     case Host: {
0555         d->url.setPort(port);
0556         break;
0557     }
0558     default: {
0559         break;
0560     }
0561     }
0562 }
0563
0564 int Smb4KCustomSettings::smbPort() const
0565 {
0566     return d->smbPort;
0567 }
0568
0569 void Smb4KCustomSettings::setUseKerberos(bool use) const
0570 {
0571     d->useKerberos = use;
0572 }
0573
0574 bool Smb4KCustomSettings::useKerberos() const
0575 {
0576     return d->useKerberos;
0577 }
0578
0579 void Smb4KCustomSettings::setMACAddress(const QString &macAddress) const
0580 {
0581     QRegularExpression expression(QStringLiteral("..\\:..\\:..\\:..\\:..\\:.."));
0582
0583     if (expression.match(macAddress).hasMatch() || macAddress.isEmpty()) {
0584         d->macAddress = macAddress;
0585     }
0586 }
0587
0588 QString Smb4KCustomSettings::macAddress() const
0589 {
0590     return d->macAddress;
0591 }
0592
0593 void Smb4KCustomSettings::setWakeOnLanSendBeforeNetworkScan(bool send) const
0594 {
0595     d->wakeOnLanBeforeFirstScan = send;
0596 }
0597
0598 bool Smb4KCustomSettings::wakeOnLanSendBeforeNetworkScan() const
0599 {
0600     return d->wakeOnLanBeforeFirstScan;
0601 }
0602
0603 void Smb4KCustomSettings::setWakeOnLanSendBeforeMount(bool send) const
0604 {
0605     d->wakeOnLanBeforeMount = send;
0606 }
0607
0608 bool Smb4KCustomSettings::wakeOnLanSendBeforeMount() const
0609 {
0610     return d->wakeOnLanBeforeMount;
0611 }
0612
0613 QMap<QString, QString> Smb4KCustomSettings::customSettings() const
0614 {
0615     QMap<QString, QString> entries;
0616
0617     //
0618     // Remounting
0619     //
0620     entries.insert(QStringLiteral("remount"), QString::number(d->remount));
0621
0622     //
0623     // User
0624     //
0625     entries.insert(QStringLiteral("use_user"), QString::number(d->useUser));
0626     entries.insert(QStringLiteral("uid"), d->user.userId().toString());
0627
0628     //
0629     // Group
0630     //
0631     entries.insert(QStringLiteral("use_group"), QString::number(d->useGroup));
0632     entries.insert(QStringLiteral("gid"), d->group.groupId().toString());
0633
0634     //
0635     // File mode
0636     //
0637     entries.insert(QStringLiteral("use_file_mode"), QString::number(d->useFileMode));
0638     entries.insert(QStringLiteral("file_mode"), d->fileMode);
0639
0640     //
0641     // Directory mode
0642     //
0643     entries.insert(QStringLiteral("use_directory_mode"), QString::number(d->useDirectoryMode));
0644     entries.insert(QStringLiteral("directory_mode"), d->directoryMode);
0645
0646 #if defined(Q_OS_LINUX)
0647     //
0648     // Unix CIFS extensions supported
0649     //
0650     entries.insert(QStringLiteral("cifs_unix_extensions_support"), QString::number(d->cifsUnixExtensionsSupport));
0651
0652     //
0653     // File system port
0654     //
0655     entries.insert(QStringLiteral("use_filesystem_port"), QString::number(d->useFileSystemPort));
0656     entries.insert(QStringLiteral("filesystem_port"), QString::number(fileSystemPort()));
0657
0658     //
0659     // Mount protocol version
0660     //
0661     entries.insert(QStringLiteral("use_smb_mount_protocol_version"), QString::number(d->useMountProtocolVersion));
0662     entries.insert(QStringLiteral("smb_mount_protocol_version"), QString::number(d->mountProtocolVersion));
0663
0664     //
0665     // Security mode
0666     //
0667     entries.insert(QStringLiteral("use_security_mode"), QString::number(d->useSecurityMode));
0668     entries.insert(QStringLiteral("security_mode"), QString::number(d->securityMode));
0669
0670     //
0671     // Write access
0672     //
0673     entries.insert(QStringLiteral("use_write_access"), QString::number(d->useWriteAccess));
0674     entries.insert(QStringLiteral("write_access"), QString::number(d->writeAccess));
0675 #endif
0676
0677     //
0678     // Client protocol versions
0679     //
0680     entries.insert(QStringLiteral("use_client_protocol_versions"), QString::number(d->useClientProtocolVersions));
0681     entries.insert(QStringLiteral("minimal_client_protocol_version"), QString::number(d->minimalClientProtocolVersion));
0682     entries.insert(QStringLiteral("maximal_client_protocol_version"), QString::number(d->maximalClientProtocolVersion));
0683
0684     //
0685     // SMB port used by the client
0686     //
0687     entries.insert(QStringLiteral("use_smb_port"), QString::number(d->useSmbPort));
0688     entries.insert(QStringLiteral("smb_port"), QString::number(smbPort()));
0689
0690     //
0691     // Usage of Kerberos
0692     //
0693     entries.insert(QStringLiteral("kerberos"), QString::number(d->useKerberos));
0694
0695     //
0696     // MAC address
0697     //
0698     entries.insert(QStringLiteral("mac_address"), d->macAddress);
0699
0700     //
0701     // Wake-On_LAN settings
0702     //
0703     entries.insert(QStringLiteral("wol_send_before_first_scan"), QString::number(d->wakeOnLanBeforeFirstScan));
0704     entries.insert(QStringLiteral("wol_send_before_mount"), QString::number(d->wakeOnLanBeforeMount));
0705
0706     return entries;
0707 }
0708
0709 bool Smb4KCustomSettings::hasCustomSettings(bool withoutRemountOnce) const
0710 {
0711     // NOTE: This function does not honor the workgroup, the url,
0712     // the ip address, the type and the profile, because these things
0713     // are not custom settings.
0714
0715     // Perform remounts
0716     if ((!withoutRemountOnce && d->remount != Smb4KCustomSettings::UndefinedRemount) || d->remount == Smb4KCustomSettings::RemountAlways) {
0717         return true;
0718     }
0719
0720     // Use user information
0721     if (d->useUser != Smb4KMountSettings::useUserId()) {
0722         return true;
0723     }
0724
0725     // User information
0726     if (d->user.userId().toString() != Smb4KMountSettings::userId()) {
0727         return true;
0728     }
0729
0730     // Use group information
0731     if (d->useGroup != Smb4KMountSettings::useGroupId()) {
0732         return true;
0733     }
0734
0735     // Group information
0736     if (d->group.groupId().toString() != Smb4KMountSettings::groupId()) {
0737         return true;
0738     }
0739
0740     // Use file mask
0741     if (d->useFileMode != Smb4KMountSettings::useFileMode()) {
0742         return true;
0743     }
0744
0745     if (d->fileMode != Smb4KMountSettings::fileMode()) {
0746         return true;
0747     }
0748
0749     if (d->useDirectoryMode != Smb4KMountSettings::useDirectoryMode()) {
0750         return true;
0751     }
0752
0753     if (d->directoryMode != Smb4KMountSettings::directoryMode()) {
0754         return true;
0755     }
0756 #if defined(Q_OS_LINUX)
0757     // CIFS Unix extension support
0758     if (d->cifsUnixExtensionsSupport != Smb4KMountSettings::cifsUnixExtensionsSupport()) {
0759         return true;
0760     }
0761
0762     // Use filesystem port
0763     if (d->useFileSystemPort != Smb4KMountSettings::useRemoteFileSystemPort()) {
0764         return true;
0765     }
0766
0767     // File system port (used for mounting)
0768     if (d->fileSystemPort != Smb4KMountSettings::remoteFileSystemPort()) {
0769         return true;
0770     }
0771
0772     // Use SMB mount protocol version
0773     if (d->useMountProtocolVersion != Smb4KMountSettings::useSmbProtocolVersion()) {
0774         return true;
0775     }
0776
0777     // SMB mount protocol version
0778     if (d->mountProtocolVersion != Smb4KMountSettings::smbProtocolVersion()) {
0779         return true;
0780     }
0781
0782     // Use security mode
0783     if (d->useSecurityMode != Smb4KMountSettings::useSecurityMode()) {
0784         return true;
0785     }
0786
0787     // Security mode
0788     if (d->securityMode != Smb4KMountSettings::securityMode()) {
0789         return true;
0790     }
0791
0792     // Use write access
0793     if (d->useWriteAccess != Smb4KMountSettings::useWriteAccess()) {
0794         return true;
0795     }
0796
0797     // Write access
0798     if (d->writeAccess != Smb4KMountSettings::writeAccess()) {
0799         return true;
0800     }
0801 #endif
0802
0803     // Use client protocol versions
0804     if (d->useClientProtocolVersions != Smb4KSettings::useClientProtocolVersions()) {
0805         return true;
0806     }
0807
0808     // Minimal client protocol version
0809     if (d->minimalClientProtocolVersion != Smb4KSettings::minimalClientProtocolVersion()) {
0810         return true;
0811     }
0812
0813     // Maximal client protocol version
0814     if (d->maximalClientProtocolVersion != Smb4KSettings::maximalClientProtocolVersion()) {
0815         return true;
0816     }
0817
0818     // Use SMB port
0819     if (d->useSmbPort != Smb4KSettings::useRemoteSmbPort()) {
0820         return true;
0821     }
0822
0823     // SMB port
0824     if (d->smbPort != Smb4KSettings::remoteSmbPort()) {
0825         return true;
0826     }
0827
0828     // Kerberos
0829     if (d->useKerberos != Smb4KSettings::useKerberos()) {
0830         return true;
0831     }
0832
0833     // MAC address
0834     if (!d->macAddress.isEmpty()) {
0835         return true;
0836     }
0837
0838     // Send WOL packets before first scan
0839     if (d->wakeOnLanBeforeFirstScan) {
0840         return true;
0841     }
0842
0843     // Send WOL packets before mount
0844     if (d->wakeOnLanBeforeMount) {
0845         return true;
0846     }
0847
0848     return false;
0849 }
0850
0851 void Smb4KCustomSettings::update(Smb4KCustomSettings *customSettings)
0852 {
0853     // NOTE: Do not update the workgroup, URL and the type
0854
0855     d->ip.setAddress(customSettings->ipAddress());
0856     d->remount = customSettings->remount();
0857     d->useUser = customSettings->useUser();
0858     d->user = customSettings->user();
0859     d->useGroup = customSettings->useGroup();
0860     d->group = customSettings->group();
0861     d->useFileMode = customSettings->useFileMode();
0862     d->fileMode = customSettings->fileMode();
0863     d->useDirectoryMode = customSettings->useDirectoryMode();
0864     d->directoryMode = customSettings->directoryMode();
0865 #if defined(Q_OS_LINUX)
0866     d->cifsUnixExtensionsSupport = customSettings->cifsUnixExtensionsSupport();
0867     d->useFileSystemPort = customSettings->useFileSystemPort();
0868     d->fileSystemPort = customSettings->fileSystemPort();
0869     d->useMountProtocolVersion = customSettings->useMountProtocolVersion();
0870     d->mountProtocolVersion = customSettings->mountProtocolVersion();
0871     d->useSecurityMode = customSettings->useSecurityMode();
0872     d->securityMode = customSettings->securityMode();
0873     d->useWriteAccess = customSettings->useWriteAccess();
0874     d->writeAccess = customSettings->writeAccess();
0875 #endif
0876     d->profile = customSettings->profile();
0877     d->useClientProtocolVersions = customSettings->useClientProtocolVersions();
0878     d->minimalClientProtocolVersion = customSettings->minimalClientProtocolVersion();
0879     d->maximalClientProtocolVersion = customSettings->maximalClientProtocolVersion();
0880     d->useSmbPort = customSettings->useSmbPort();
0881     d->smbPort = customSettings->smbPort();
0882     d->useKerberos = customSettings->useKerberos();
0883     d->macAddress = customSettings->macAddress();
0884     d->wakeOnLanBeforeFirstScan = customSettings->wakeOnLanSendBeforeNetworkScan();
0885     d->wakeOnLanBeforeMount = customSettings->wakeOnLanSendBeforeMount();
0886 }
0887
0888 Smb4KCustomSettings &Smb4KCustomSettings::operator=(const Smb4KCustomSettings &other)
0889 {
0890     *d = *other.d;
0891     return *this;
0892 }