rbutil/rbutilqt/base/autodetection.cpp

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  *   Copyright (C) 2007 by Dominik Wenger
  10  *   $Id$
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include <QtCore>
  21 #include "autodetection.h"
  22 #include "rbsettings.h"
  23 #include "systeminfo.h"
  24
  25 #include "../ipodpatcher/ipodpatcher.h"
  26 #include "../sansapatcher/sansapatcher.h"
  27
  28 #if defined(Q_OS_LINUX) || defined(Q_OS_MACX)
  29 #include <stdio.h>
  30 #endif
  31 #if defined(Q_OS_LINUX)
  32 #include <mntent.h>
  33 #endif
  34 #if defined(Q_OS_MACX)
  35 #include <sys/param.h>
  36 #include <sys/ucred.h>
  37 #include <sys/mount.h>
  38 #endif
  39 #if defined(Q_OS_WIN32)
  40 #if defined(UNICODE)
  41 #define _UNICODE
  42 #endif
  43 #include <stdio.h>
  44 #include <tchar.h>
  45 #include <windows.h>
  46 #include <setupapi.h>
  47 #include <winioctl.h>
  48 #endif
  49
  50 #if defined(Q_OS_OPENBSD)
  51 #include <sys/param.h>
  52 #include <sys/mount.h>
  53 #endif
  54
  55 #include "system.h"
  56 #include "utils.h"
  57 #include "rockboxinfo.h"
  58
  59 Autodetection::Autodetection(QObject* parent): QObject(parent)
  60 {
  61 }
  62
  63 bool Autodetection::detect()
  64 {
  65     m_device = "";
  66     m_mountpoint = "";
  67     m_errdev = "";
  68
  69     detectUsb();
  70
  71     // Try detection via rockbox.info / rbutil.log
  72     QStringList mounts = mountpoints();
  73
  74     for(int i=0; i< mounts.size();i++)
  75     {
  76         // do the file checking
  77         QDir dir(mounts.at(i));
  78         qDebug() << "[Autodetect] paths to check:" << mounts;
  79         if(dir.exists())
  80         {
  81             // check logfile first.
  82             if(QFile(mounts.at(i) + "/.rockbox/rbutil.log").exists()) {
  83                 QSettings log(mounts.at(i) + "/.rockbox/rbutil.log",
  84                               QSettings::IniFormat, this);
  85                 if(!log.value("platform").toString().isEmpty()) {
  86                     if(m_device.isEmpty())
  87                         m_device = log.value("platform").toString();
  88                     m_mountpoint = mounts.at(i);
  89                     qDebug() << "[Autodetect] rbutil.log detected:" << m_device << m_mountpoint;
  90                     return true;
  91                 }
  92             }
  93
  94             // check rockbox-info.txt afterwards.
  95             RockboxInfo info(mounts.at(i));
  96             if(info.success())
  97             {
  98                 if(m_device.isEmpty())
  99                 {
 100                     m_device = info.target();
 101                     // special case for video64mb. This is a workaround, and
 102                     // should get replaced when autodetection is reworked.
 103                     if(m_device == "ipodvideo" && info.ram() == 64)
 104                     {
 105                         m_device = "ipodvideo64mb";
 106                     }
 107                 }
 108                 m_mountpoint = mounts.at(i);
 109                 qDebug() << "[Autodetect] rockbox-info.txt detected:"
 110                          << m_device << m_mountpoint;
 111                 return true;
 112             }
 113
 114             // check for some specific files in root folder
 115             QDir root(mounts.at(i));
 116             QStringList rootentries = root.entryList(QDir::Files);
 117             if(rootentries.contains("archos.mod", Qt::CaseInsensitive))
 118             {
 119                 // archos.mod in root folder -> Archos Player
 120                 m_device = "player";
 121                 m_mountpoint = mounts.at(i);
 122                 return true;
 123             }
 124             if(rootentries.contains("ONDIOST.BIN", Qt::CaseInsensitive))
 125             {
 126                 // ONDIOST.BIN in root -> Ondio FM
 127                 m_device = "ondiofm";
 128                 m_mountpoint = mounts.at(i);
 129                 return true;
 130             }
 131             if(rootentries.contains("ONDIOSP.BIN", Qt::CaseInsensitive))
 132             {
 133                 // ONDIOSP.BIN in root -> Ondio SP
 134                 m_device = "ondiosp";
 135                 m_mountpoint = mounts.at(i);
 136                 return true;
 137             }
 138             if(rootentries.contains("ajbrec.ajz", Qt::CaseInsensitive))
 139             {
 140                 qDebug() << "[Autodetect] ajbrec.ajz found. Trying detectAjbrec()";
 141                 if(detectAjbrec(mounts.at(i))) {
 142                     m_mountpoint = mounts.at(i);
 143                     qDebug() << "[Autodetect]" << m_device;
 144                     return true;
 145                 }
 146             }
 147             // detection based on player specific folders
 148             QStringList rootfolders = root.entryList(QDir::Dirs
 149                     | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System);
 150             if(rootfolders.contains("GBSYSTEM", Qt::CaseInsensitive))
 151             {
 152                 // GBSYSTEM folder -> Gigabeat
 153                 m_device = "gigabeatf";
 154                 m_mountpoint = mounts.at(i);
 155                 return true;
 156             }
 157 #if defined(Q_OS_WIN32)
 158             // on windows, try to detect the drive letter of an Ipod
 159             if(rootfolders.contains("iPod_Control", Qt::CaseInsensitive))
 160             {
 161                 // iPod_Control folder -> Ipod found
 162                 // detecting of the Ipod type is done below using ipodpatcher
 163                 m_mountpoint = mounts.at(i);
 164             }
 165 #endif
 166         }
 167
 168     }
 169
 170     int n;
 171     // try ipodpatcher
 172     // initialize sector buffer. Needed.
 173     ipod_sectorbuf = NULL;
 174     ipod_alloc_buffer(&ipod_sectorbuf, BUFFER_SIZE);
 175     struct ipod_t ipod;
 176     n = ipod_scan(&ipod);
 177     if(n == 1) {
 178         qDebug() << "[Autodetect] Ipod found:" << ipod.modelstr << "at" << ipod.diskname;
 179         // if the found ipod is a macpod also notice it as device with problem.
 180         if(ipod.macpod)
 181             m_errdev = ipod.targetname;
 182         m_device = ipod.targetname;
 183         // since resolveMountPoint is doing exact matches we need to select
 184         // the correct partition.
 185         QString mp(ipod.diskname);
 186 #ifdef Q_OS_LINUX
 187         mp.append("2");
 188 #endif
 189 #ifdef Q_OS_MACX
 190         mp.append("s2");
 191 #endif
 192         m_mountpoint = resolveMountPoint(mp);
 193         return true;
 194     }
 195     else {
 196         qDebug() << "[Autodetect] ipodpatcher: no Ipod found." << n;
 197     }
 198     free(ipod_sectorbuf);
 199     ipod_sectorbuf = NULL;
 200
 201     // try sansapatcher
 202     // initialize sector buffer. Needed.
 203     sansa_sectorbuf = NULL;
 204     sansa_alloc_buffer(&sansa_sectorbuf, BUFFER_SIZE);
 205     struct sansa_t sansa;
 206     n = sansa_scan(&sansa);
 207     if(n == 1) {
 208         qDebug() << "[Autodetect] Sansa found:" << sansa.targetname << "at" << sansa.diskname;
 209         m_device = QString("sansa%1").arg(sansa.targetname);
 210         QString mp(sansa.diskname);
 211 #ifdef Q_OS_LINUX
 212         mp.append("1");
 213 #endif
 214 #ifdef Q_OS_MACX
 215         mp.append("s1");
 216 #endif
 217         m_mountpoint = resolveMountPoint(mp);
 218         return true;
 219     }
 220     else {
 221         qDebug() << "[Autodetect] sansapatcher: no Sansa found." << n;
 222     }
 223     free(sansa_sectorbuf);
 224     sansa_sectorbuf = NULL;
 225
 226     if(m_mountpoint.isEmpty() && m_device.isEmpty()
 227             && m_errdev.isEmpty() && m_incompat.isEmpty())
 228         return false;
 229     return true;
 230 }
 231
 232
 233 QStringList Autodetection::mountpoints()
 234 {
 235     QStringList tempList;
 236 #if defined(Q_OS_WIN32)
 237     QFileInfoList list = QDir::drives();
 238     for(int i=0; i<list.size();i++)
 239     {
 240         tempList << list.at(i).absolutePath();
 241         qDebug() << "[Autodetection] Mounted on" << list.at(i).absolutePath();
 242     }
 243
 244 #elif defined(Q_OS_MACX) || defined(Q_OS_OPENBSD)
 245     int num;
 246     struct statfs *mntinf;
 247
 248     num = getmntinfo(&mntinf, MNT_WAIT);
 249     while(num--) {
 250         tempList << QString(mntinf->f_mntonname);
 251         qDebug() << "[Autodetection] Mounted on" << mntinf->f_mntonname
 252                  << "is" << mntinf->f_mntfromname << "type" << mntinf->f_fstypename;
 253         mntinf++;
 254     }
 255 #elif defined(Q_OS_LINUX)
 256
 257     FILE *mn = setmntent("/etc/mtab", "r");
 258     if(!mn)
 259         return QStringList("");
 260
 261     struct mntent *ent;
 262     while((ent = getmntent(mn))) {
 263         tempList << QString(ent->mnt_dir);
 264         qDebug() << "[Autodetection] Mounted on" << ent->mnt_dir
 265                  << "is" << ent->mnt_fsname << "type" << ent->mnt_type;
 266     }
 267     endmntent(mn);
 268
 269 #else
 270 #error Unknown Plattform
 271 #endif
 272     return tempList;
 273 }
 274
 275
 276 /** resolve device name to mount point / drive letter
 277  *  @param device device name / disk number
 278  *  @return mount point / drive letter
 279  */
 280 QString Autodetection::resolveMountPoint(QString device)
 281 {
 282     qDebug() << "[Autodetect] resolving mountpoint:" << device;
 283
 284 #if defined(Q_OS_LINUX)
 285     FILE *mn = setmntent("/etc/mtab", "r");
 286     if(!mn)
 287         return QString("");
 288
 289     struct mntent *ent;
 290     while((ent = getmntent(mn))) {
 291         // Check for valid filesystem. Allow hfs too, as an Ipod might be a
 292         // MacPod.
 293         if(QString(ent->mnt_fsname) == device) {
 294             QString result;
 295             if(QString(ent->mnt_type).contains("vfat", Qt::CaseInsensitive)
 296                     || QString(ent->mnt_type).contains("hfs", Qt::CaseInsensitive)) {
 297                 qDebug() << "[Autodetect] resolved mountpoint is:" << ent->mnt_dir;
 298                 result = QString(ent->mnt_dir);
 299             }
 300             else {
 301                 qDebug() << "[Autodetect] mountpoint is wrong filesystem!";
 302             }
 303             endmntent(mn);
 304             return result;
 305         }
 306     }
 307     endmntent(mn);
 308
 309 #endif
 310
 311 #if defined(Q_OS_MACX) || defined(Q_OS_OPENBSD)
 312     int num;
 313     struct statfs *mntinf;
 314
 315     num = getmntinfo(&mntinf, MNT_WAIT);
 316     while(num--) {
 317         // Check for valid filesystem. Allow hfs too, as an Ipod might be a
 318         // MacPod.
 319         if(QString(mntinf->f_mntfromname) == device) {
 320             if(QString(mntinf->f_fstypename).contains("msdos", Qt::CaseInsensitive)
 321                 || QString(mntinf->f_fstypename).contains("hfs", Qt::CaseInsensitive)) {
 322                 qDebug() << "[Autodetect] resolved mountpoint is:" << mntinf->f_mntonname;
 323                 return QString(mntinf->f_mntonname);
 324             }
 325             else {
 326                 qDebug() << "[Autodetect] mountpoint is wrong filesystem!";
 327                 return QString();
 328             }
 329         }
 330         mntinf++;
 331     }
 332 #endif
 333
 334 #if defined(Q_OS_WIN32)
 335     QString result;
 336     unsigned int driveno = device.replace(QRegExp("^.*([0-9]+)"), "\\1").toInt();
 337
 338     int letter;
 339     for(letter = 'A'; letter <= 'Z'; letter++) {
 340         if(resolveDevicename(QString(letter)).toUInt() == driveno) {
 341             result = letter;
 342             break;
 343         }
 344     }
 345     qDebug() << "[Autodetect] resolved mountpoint is:" << result;
 346     if(!result.isEmpty())
 347         return result + ":/";
 348 #endif
 349     return QString("");
 350 }
 351
 352
 353 /** Resolve mountpoint to devicename / disk number
 354  *  @param path mountpoint path / drive letter
 355  *  @return devicename / disk number
 356  */
 357 QString Autodetection::resolveDevicename(QString path)
 358 {
 359     qDebug() << "[Autodetect] resolving device name" << path;
 360 #if defined(Q_OS_LINUX)
 361     FILE *mn = setmntent("/etc/mtab", "r");
 362     if(!mn)
 363         return QString("");
 364
 365     struct mntent *ent;
 366     while((ent = getmntent(mn))) {
 367         // check for valid filesystem type.
 368         // Linux can handle hfs (and hfsplus), so consider it a valid file
 369         // system. Otherwise resolving the device name would fail, which in
 370         // turn would make it impossible to warn about a MacPod.
 371         if(QString(ent->mnt_dir) == path
 372            && (QString(ent->mnt_type).contains("vfat", Qt::CaseInsensitive)
 373             || QString(ent->mnt_type).contains("hfs", Qt::CaseInsensitive))) {
 374             endmntent(mn);
 375             qDebug() << "[Autodetect] device name is" << ent->mnt_fsname;
 376             return QString(ent->mnt_fsname);
 377         }
 378     }
 379     endmntent(mn);
 380
 381 #endif
 382
 383 #if defined(Q_OS_MACX) || defined(Q_OS_OPENBSD)
 384     int num;
 385     struct statfs *mntinf;
 386
 387     num = getmntinfo(&mntinf, MNT_WAIT);
 388     while(num--) {
 389         // check for valid filesystem type. OS X can handle hfs (hfs+ is
 390         // treated as hfs), BSD should be the same.
 391         if(QString(mntinf->f_mntonname) == path
 392            && (QString(mntinf->f_fstypename).contains("msdos", Qt::CaseInsensitive)
 393             || QString(mntinf->f_fstypename).contains("hfs", Qt::CaseInsensitive))) {
 394             qDebug() << "[Autodetect] device name is" << mntinf->f_mntfromname;
 395             return QString(mntinf->f_mntfromname);
 396         }
 397         mntinf++;
 398     }
 399 #endif
 400
 401 #if defined(Q_OS_WIN32)
 402     DWORD written;
 403     HANDLE h;
 404     TCHAR uncpath[MAX_PATH];
 405     UCHAR buffer[0x400];
 406     PVOLUME_DISK_EXTENTS extents = (PVOLUME_DISK_EXTENTS)buffer;
 407
 408     _stprintf(uncpath, _TEXT("\\\\.\\%c:"), path.toAscii().at(0));
 409     h = CreateFile(uncpath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
 410             NULL, OPEN_EXISTING, 0, NULL);
 411     if(h == INVALID_HANDLE_VALUE) {
 412         //qDebug() << "error getting extents for" << uncpath;
 413         return "";
 414     }
 415     // get the extents
 416     if(DeviceIoControl(h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS,
 417                 NULL, 0, extents, sizeof(buffer), &written, NULL)) {
 418         if(extents->NumberOfDiskExtents > 1) {
 419             qDebug() << "[Autodetect] resolving device name: volume spans multiple disks!";
 420             return "";
 421         }
 422         qDebug() << "[Autodetect] device name is" << extents->Extents[0].DiskNumber;
 423         return QString("%1").arg(extents->Extents[0].DiskNumber);
 424     }
 425 #endif
 426     return QString("");
 427
 428 }
 429
 430
 431 /** @brief detect devices based on usb pid / vid.
 432  *  @return true upon success, false otherwise.
 433  */
 434 bool Autodetection::detectUsb()
 435 {
 436     // usbids holds the mapping in the form
 437     // ((VID<<16)|(PID)), targetname
 438     // the ini file needs to hold the IDs as hex values.
 439     QMap<int, QString> usbids = SystemInfo::usbIdMap(SystemInfo::MapDevice);
 440     QMap<int, QString> usberror = SystemInfo::usbIdMap(SystemInfo::MapError);
 441     QMap<int, QString> usbincompat = SystemInfo::usbIdMap(SystemInfo::MapIncompatible);
 442
 443     // usb pid detection
 444     QList<uint32_t> attached;
 445     attached = System::listUsbIds();
 446
 447     int i = attached.size();
 448     while(i--) {
 449         if(usbids.contains(attached.at(i))) {
 450             m_device = usbids.value(attached.at(i));
 451             qDebug() << "[USB] detected supported player" << m_device;
 452             return true;
 453         }
 454         if(usberror.contains(attached.at(i))) {
 455             m_errdev = usberror.value(attached.at(i));
 456             qDebug() << "[USB] detected problem with player" << m_errdev;
 457             return true;
 458         }
 459         QString idstring = QString("%1").arg(attached.at(i), 8, 16, QChar('0'));
 460         if(!SystemInfo::platformValue(idstring, SystemInfo::CurName).toString().isEmpty()) {
 461             m_incompat = idstring;
 462             qDebug() << "[USB] detected incompatible player" << m_incompat;
 463             return true;
 464         }
 465     }
 466     return false;
 467 }
 468
 469
 470 bool Autodetection::detectAjbrec(QString root)
 471 {
 472     QFile f(root + "/ajbrec.ajz");
 473     char header[24];
 474     f.open(QIODevice::ReadOnly);
 475     if(!f.read(header, 24)) return false;
 476
 477     // check the header of the file.
 478     // recorder v1 had a 6 bytes sized header
 479     // recorder v2, FM, Ondio SP and FM have a 24 bytes header.
 480
 481     // recorder v1 has the binary length in the first 4 bytes, so check
 482     // for them first.
 483     int len = (header[0]<<24) | (header[1]<<16) | (header[2]<<8) | header[3];
 484     qDebug() << "[Autodetect] ABJREC possible bin length:" << len
 485              << "file len:" << f.size();
 486     if((f.size() - 6) == len)
 487         m_device = "recorder";
 488
 489     // size didn't match, now we need to assume we have a headerlength of 24.
 490     switch(header[11]) {
 491         case 2:
 492             m_device = "recorderv2";
 493             break;
 494
 495         case 4:
 496             m_device = "fmrecorder";
 497             break;
 498
 499         case 8:
 500             m_device = "ondiofm";
 501             break;
 502
 503         case 16:
 504             m_device = "ondiosp";
 505             break;
 506
 507         default:
 508             break;
 509     }
 510     f.close();
 511
 512     if(m_device.isEmpty()) return false;
 513     return true;
 514 }
 515