rbutil/rbutilqt/base/system.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
  21 #include "system.h"
  22
  23 #include <QtCore>
  24 #include <QDebug>
  25
  26 #include <cstdlib>
  27 #include <stdio.h>
  28
  29 // Windows Includes
  30 #if defined(Q_OS_WIN32)
  31 #if defined(UNICODE)
  32 #define _UNICODE
  33 #endif
  34 #include <windows.h>
  35 #include <tchar.h>
  36 #include <lm.h>
  37 #include <windows.h>
  38 #include <setupapi.h>
  39 #endif
  40
  41 // Linux and Mac includes
  42 #if defined(Q_OS_LINUX) || defined(Q_OS_MACX)
  43 #if defined(LIBUSB1)
  44 #include <libusb-1.0/libusb.h>
  45 #else
  46 #include <usb.h>
  47 #endif
  48 #include <sys/utsname.h>
  49 #include <unistd.h>
  50 #include <pwd.h>
  51 #endif
  52
  53 // Linux includes
  54 #if defined(Q_OS_LINUX)
  55 #include <mntent.h>
  56 #endif
  57
  58 // Mac includes
  59 #if defined(Q_OS_MACX)
  60 #include <sys/param.h>
  61 #include <sys/ucred.h>
  62 #include <sys/mount.h>
  63
  64 #include <CoreFoundation/CoreFoundation.h>
  65 #include <SystemConfiguration/SystemConfiguration.h>
  66 #include <CoreServices/CoreServices.h>
  67 #include <IOKit/IOKitLib.h>
  68 #include <IOKit/usb/IOUSBLib.h>
  69 #endif
  70
  71 #include "utils.h"
  72 #include "rbsettings.h"
  73
  74 /** @brief detect permission of user (only Windows at moment).
  75  *  @return enum userlevel.
  76  */
  77 #if defined(Q_OS_WIN32)
  78 enum System::userlevel System::userPermissions(void)
  79 {
  80     LPUSER_INFO_1 buf;
  81     NET_API_STATUS napistatus;
  82     wchar_t userbuf[UNLEN];
  83     DWORD usersize = UNLEN;
  84     BOOL status;
  85     enum userlevel result;
  86
  87     status = GetUserNameW(userbuf, &usersize);
  88     if(!status)
  89         return ERR;
  90
  91     napistatus = NetUserGetInfo(NULL, userbuf, (DWORD)1, (LPBYTE*)&buf);
  92
  93     switch(buf->usri1_priv) {
  94         case USER_PRIV_GUEST:
  95             result = GUEST;
  96             break;
  97         case USER_PRIV_USER:
  98             result = USER;
  99             break;
 100         case USER_PRIV_ADMIN:
 101             result = ADMIN;
 102             break;
 103         default:
 104             result = ERR;
 105             break;
 106     }
 107     NetApiBufferFree(buf);
 108
 109     return result;
 110 }
 111
 112 /** @brief detects user permissions (only Windows at moment).
 113  *  @return a user readable string with the permission.
 114  */
 115 QString System::userPermissionsString(void)
 116 {
 117     QString result;
 118     int perm = userPermissions();
 119     switch(perm) {
 120         case GUEST:
 121             result = tr("Guest");
 122             break;
 123         case ADMIN:
 124             result = tr("Admin");
 125             break;
 126         case USER:
 127             result = tr("User");
 128             break;
 129         default:
 130             result = tr("Error");
 131             break;
 132     }
 133     return result;
 134 }
 135 #endif
 136
 137
 138 /** @brief detects current Username.
 139  *  @return string with Username.
 140  */
 141 QString System::userName(void)
 142 {
 143 #if defined(Q_OS_WIN32)
 144     wchar_t userbuf[UNLEN];
 145     DWORD usersize = UNLEN;
 146     BOOL status;
 147
 148     status = GetUserNameW(userbuf, &usersize);
 149
 150     return QString::fromWCharArray(userbuf);
 151 #endif
 152 #if defined(Q_OS_LINUX) || defined(Q_OS_MACX)
 153     struct passwd *user;
 154     user = getpwuid(geteuid());
 155     return QString(user->pw_name);
 156 #endif
 157 }
 158
 159
 160 /** @brief detects the OS Version
 161  *  @return String with OS Version.
 162  */
 163 QString System::osVersionString(void)
 164 {
 165     QString result;
 166 #if defined(Q_OS_WIN32)
 167     SYSTEM_INFO sysinfo;
 168     OSVERSIONINFO osvi;
 169     ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
 170     osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 171     GetVersionEx(&osvi);
 172     GetSystemInfo(&sysinfo);
 173
 174     result = QString("Windows version %1.%2, ").arg(osvi.dwMajorVersion).arg(osvi.dwMinorVersion);
 175     if(osvi.szCSDVersion)
 176         result += QString("build %1 (%2)").arg(osvi.dwBuildNumber)
 177             .arg(QString::fromWCharArray(osvi.szCSDVersion));
 178     else
 179         result += QString("build %1").arg(osvi.dwBuildNumber);
 180     result += QString("<br/>CPU: %1, %2 processor(s)").arg(sysinfo.dwProcessorType)
 181               .arg(sysinfo.dwNumberOfProcessors);
 182 #endif
 183 #if defined(Q_OS_LINUX) || defined(Q_OS_MACX)
 184     struct utsname u;
 185     int ret;
 186     ret = uname(&u);
 187
 188 #if defined(Q_OS_MACX)
 189     ItemCount cores = MPProcessors();
 190 #else
 191     long cores = sysconf(_SC_NPROCESSORS_ONLN);
 192 #endif
 193     result = QString("CPU: %1, %2 processor(s)").arg(u.machine).arg(cores);
 194     result += QString("<br/>System: %2<br/>Release: %3<br/>Version: %4")
 195         .arg(u.sysname).arg(u.release).arg(u.version);
 196 #if defined(Q_OS_MACX)
 197     SInt32 major;
 198     SInt32 minor;
 199     SInt32 bugfix;
 200     OSErr error;
 201     error = Gestalt(gestaltSystemVersionMajor, &major);
 202     error = Gestalt(gestaltSystemVersionMinor, &minor);
 203     error = Gestalt(gestaltSystemVersionBugFix, &bugfix);
 204
 205     result += QString("<br/>OS X %1.%2.%3 ").arg(major).arg(minor).arg(bugfix);
 206     // 1: 86k, 2: ppc, 10: i386
 207     SInt32 arch;
 208     error = Gestalt(gestaltSysArchitecture, &arch);
 209     switch(arch) {
 210         case 1:
 211         result.append("(86k)");
 212         break;
 213     case 2:
 214         result.append("(ppc)");
 215         break;
 216     case 10:
 217         result.append("(x86)");
 218         break;
 219     default:
 220         result.append("(unknown)");
 221         break;
 222     }
 223 #endif
 224 #endif
 225     result += QString("<br/>Qt version %1").arg(qVersion());
 226     return result;
 227 }
 228
 229 QList<uint32_t> System::listUsbIds(void)
 230 {
 231     return listUsbDevices().keys();
 232 }
 233
 234 /** @brief detect devices based on usb pid / vid.
 235  *  @return list with usb VID / PID values.
 236  */
 237 QMap<uint32_t, QString> System::listUsbDevices(void)
 238 {
 239     QMap<uint32_t, QString> usbids;
 240     // usb pid detection
 241     qDebug() << "[System] Searching for USB devices";
 242 #if defined(Q_OS_LINUX)
 243 #if defined(LIBUSB1)
 244     libusb_device **devs;
 245     int res;
 246     ssize_t count;
 247     res = libusb_init(NULL);
 248
 249     count = libusb_get_device_list(NULL, &devs);
 250     libusb_device *dev;
 251     int i = 0;
 252     while((dev = devs[i++]) != NULL) {
 253         QString name;
 254         unsigned char buf[256];
 255         uint32_t id;
 256         struct libusb_device_descriptor descriptor;
 257         if(libusb_get_device_descriptor(dev, &descriptor) == 0) {
 258             id = descriptor.idVendor << 16 | descriptor.idProduct;
 259
 260             libusb_device_handle *dh;
 261             if(libusb_open(dev, &dh) == 0) {
 262                 libusb_get_string_descriptor_ascii(dh, descriptor.iManufacturer, buf, 256);
 263                 name += QString::fromAscii((char*)buf) + " ";
 264                 libusb_get_string_descriptor_ascii(dh, descriptor.iProduct, buf, 256);
 265                 name += QString::fromAscii((char*)buf);
 266                 libusb_close(dh);
 267             }
 268             if(name.isEmpty())
 269                 name = tr("(no description available)");
 270             if(id) {
 271                 usbids.insert(id, name);
 272                 qDebug("[System] USB: 0x%08x, %s", id, name.toLocal8Bit().data());
 273             }
 274         }
 275     }
 276
 277     libusb_free_device_list(devs, 1);
 278     libusb_exit(NULL);
 279 #else
 280     usb_init();
 281     usb_find_busses();
 282     usb_find_devices();
 283     struct usb_bus *b;
 284     b = usb_busses;
 285
 286     while(b) {
 287         if(b->devices) {
 288             struct usb_device *u;
 289             u = b->devices;
 290             while(u) {
 291                 uint32_t id;
 292                 id = u->descriptor.idVendor << 16 | u->descriptor.idProduct;
 293                 // get identification strings
 294                 usb_dev_handle *dev;
 295                 QString name;
 296                 char string[256];
 297                 int res;
 298                 dev = usb_open(u);
 299                 if(dev) {
 300                     if(u->descriptor.iManufacturer) {
 301                         res = usb_get_string_simple(dev, u->descriptor.iManufacturer,
 302                                                     string, sizeof(string));
 303                         if(res > 0)
 304                             name += QString::fromAscii(string) + " ";
 305                     }
 306                     if(u->descriptor.iProduct) {
 307                         res = usb_get_string_simple(dev, u->descriptor.iProduct,
 308                                                     string, sizeof(string));
 309                         if(res > 0)
 310                             name += QString::fromAscii(string);
 311                     }
 312                     usb_close(dev);
 313                 }
 314                 if(name.isEmpty()) name = tr("(no description available)");
 315
 316                 if(id) {
 317                     usbids.insert(id, name);
 318                     qDebug() << "[System] USB:" << QString("0x%1").arg(id, 8, 16) << name;
 319                 }
 320                 u = u->next;
 321             }
 322         }
 323         b = b->next;
 324     }
 325 #endif
 326 #endif
 327
 328 #if defined(Q_OS_MACX)
 329     kern_return_t result = KERN_FAILURE;
 330     CFMutableDictionaryRef usb_matching_dictionary;
 331     io_iterator_t usb_iterator = IO_OBJECT_NULL;
 332     usb_matching_dictionary = IOServiceMatching(kIOUSBDeviceClassName);
 333     result = IOServiceGetMatchingServices(kIOMasterPortDefault, usb_matching_dictionary,
 334                                           &usb_iterator);
 335     if(result) {
 336         qDebug() << "[System] USB: IOKit: Could not get matching services.";
 337         return usbids;
 338     }
 339
 340     io_object_t usbCurrentObj;
 341     while((usbCurrentObj = IOIteratorNext(usb_iterator))) {
 342         uint32_t id;
 343         QString name;
 344         /* get vendor ID */
 345         CFTypeRef vidref = NULL;
 346         int vid = 0;
 347         vidref = IORegistryEntryCreateCFProperty(usbCurrentObj, CFSTR("idVendor"),
 348                                 kCFAllocatorDefault, 0);
 349         CFNumberGetValue((CFNumberRef)vidref, kCFNumberIntType, &vid);
 350         CFRelease(vidref);
 351
 352         /* get product ID */
 353         CFTypeRef pidref = NULL;
 354         int pid = 0;
 355         pidref = IORegistryEntryCreateCFProperty(usbCurrentObj, CFSTR("idProduct"),
 356                                 kCFAllocatorDefault, 0);
 357         CFNumberGetValue((CFNumberRef)pidref, kCFNumberIntType, &pid);
 358         CFRelease(pidref);
 359         id = vid << 16 | pid;
 360
 361         /* get product vendor */
 362         char vendor_buf[256];
 363         CFIndex vendor_buflen = 256;
 364         CFTypeRef vendor_name_ref = NULL;
 365
 366         vendor_name_ref = IORegistryEntrySearchCFProperty(usbCurrentObj,
 367                                  kIOServicePlane, CFSTR("USB Vendor Name"),
 368                                  kCFAllocatorDefault, 0);
 369         if(vendor_name_ref != NULL) {
 370             CFStringGetCString((CFStringRef)vendor_name_ref, vendor_buf, vendor_buflen,
 371                                kCFStringEncodingUTF8);
 372             name += QString::fromUtf8(vendor_buf) + " ";
 373             CFRelease(vendor_name_ref);
 374         }
 375         else {
 376             name += QObject::tr("(unknown vendor name) ");
 377         }
 378
 379         /* get product name */
 380         char product_buf[256];
 381         CFIndex product_buflen = 256;
 382         CFTypeRef product_name_ref = NULL;
 383
 384         product_name_ref = IORegistryEntrySearchCFProperty(usbCurrentObj,
 385                                 kIOServicePlane, CFSTR("USB Product Name"),
 386                                 kCFAllocatorDefault, 0);
 387         if(product_name_ref != NULL) {
 388             CFStringGetCString((CFStringRef)product_name_ref, product_buf, product_buflen,
 389                                kCFStringEncodingUTF8);
 390             name += QString::fromUtf8(product_buf);
 391             CFRelease(product_name_ref);
 392         }
 393         else {
 394             name += QObject::tr("(unknown product name)");
 395         }
 396
 397         if(id) {
 398             usbids.insert(id, name);
 399             qDebug() << "[System] USB:" << QString("0x%1").arg(id, 8, 16) << name;
 400         }
 401
 402     }
 403     IOObjectRelease(usb_iterator);
 404 #endif
 405
 406 #if defined(Q_OS_WIN32)
 407     HDEVINFO deviceInfo;
 408     SP_DEVINFO_DATA infoData;
 409     DWORD i;
 410
 411     // Iterate over all devices
 412     // by doing it this way it's unneccessary to use GUIDs which might be not
 413     // present in current MinGW. It also seemed to be more reliably than using
 414     // a GUID.
 415     // See KB259695 for an example.
 416     deviceInfo = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_ALLCLASSES | DIGCF_PRESENT);
 417
 418     infoData.cbSize = sizeof(SP_DEVINFO_DATA);
 419
 420     for(i = 0; SetupDiEnumDeviceInfo(deviceInfo, i, &infoData); i++) {
 421         DWORD data;
 422         LPTSTR buffer = NULL;
 423         DWORD buffersize = 0;
 424         QString description;
 425
 426         // get device desriptor first
 427         // for some reason not doing so results in bad things (tm)
 428         while(!SetupDiGetDeviceRegistryProperty(deviceInfo, &infoData,
 429             SPDRP_DEVICEDESC, &data, (PBYTE)buffer, buffersize, &buffersize)) {
 430             if(GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
 431                 if(buffer) free(buffer);
 432                 // double buffer size to avoid problems as per KB888609
 433                 buffer = (LPTSTR)malloc(buffersize * 2);
 434             }
 435             else {
 436                 break;
 437             }
 438         }
 439         description = QString::fromWCharArray(buffer);
 440
 441         // now get the hardware id, which contains PID and VID.
 442         while(!SetupDiGetDeviceRegistryProperty(deviceInfo, &infoData,
 443             SPDRP_HARDWAREID, &data, (PBYTE)buffer, buffersize, &buffersize)) {
 444             if(GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
 445                 if(buffer) free(buffer);
 446                 // double buffer size to avoid problems as per KB888609
 447                 buffer = (LPTSTR)malloc(buffersize * 2);
 448             }
 449             else {
 450                 break;
 451             }
 452         }
 453
 454         unsigned int vid, pid;
 455         // convert buffer text to upper case to avoid depending on the case of
 456         // the keys (W7 uses different casing than XP at least).
 457         int len = _tcslen(buffer);
 458         while(len--) buffer[len] = _totupper(buffer[len]);
 459         if(_stscanf(buffer, _TEXT("USB\\VID_%x&PID_%x"), &vid, &pid) == 2) {
 460             uint32_t id;
 461             id = vid << 16 | pid;
 462             usbids.insert(id, description);
 463             qDebug("[System] USB VID: %04x, PID: %04x", vid, pid);
 464         }
 465         if(buffer) free(buffer);
 466     }
 467     SetupDiDestroyDeviceInfoList(deviceInfo);
 468
 469 #endif
 470     return usbids;
 471 }
 472
 473
 474 /** @brief detects current system proxy
 475  *  @return QUrl with proxy or empty
 476  */
 477 QUrl System::systemProxy(void)
 478 {
 479 #if defined(Q_OS_LINUX)
 480     return QUrl(getenv("http_proxy"));
 481 #elif defined(Q_OS_WIN32)
 482     HKEY hk;
 483     wchar_t proxyval[80];
 484     DWORD buflen = 80;
 485     long ret;
 486     DWORD enable;
 487     DWORD enalen = sizeof(DWORD);
 488
 489     ret = RegOpenKeyEx(HKEY_CURRENT_USER,
 490         _TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"),
 491         0, KEY_QUERY_VALUE, &hk);
 492     if(ret != ERROR_SUCCESS) return QUrl("");
 493
 494     ret = RegQueryValueEx(hk, _TEXT("ProxyServer"), NULL, NULL, (LPBYTE)proxyval, &buflen);
 495     if(ret != ERROR_SUCCESS) return QUrl("");
 496
 497     ret = RegQueryValueEx(hk, _TEXT("ProxyEnable"), NULL, NULL, (LPBYTE)&enable, &enalen);
 498     if(ret != ERROR_SUCCESS) return QUrl("");
 499
 500     RegCloseKey(hk);
 501
 502     //qDebug() << QString::fromWCharArray(proxyval) << QString("%1").arg(enable);
 503     if(enable != 0)
 504         return QUrl("http://" + QString::fromWCharArray(proxyval));
 505     else
 506         return QUrl("");
 507 #elif defined(Q_OS_MACX)
 508
 509     CFDictionaryRef dictref;
 510     CFStringRef stringref;
 511     CFNumberRef numberref;
 512     int enable = 0;
 513     int port = 0;
 514     unsigned int bufsize = 0;
 515     char *buf;
 516     QUrl proxy;
 517
 518     dictref = SCDynamicStoreCopyProxies(NULL);
 519     if(dictref == NULL)
 520         return proxy;
 521     numberref = (CFNumberRef)CFDictionaryGetValue(dictref, kSCPropNetProxiesHTTPEnable);
 522     if(numberref != NULL)
 523         CFNumberGetValue(numberref, kCFNumberIntType, &enable);
 524     if(enable == 1) {
 525         // get proxy string
 526         stringref = (CFStringRef)CFDictionaryGetValue(dictref, kSCPropNetProxiesHTTPProxy);
 527         if(stringref != NULL) {
 528             // get number of characters. CFStringGetLength uses UTF-16 code pairs
 529             bufsize = CFStringGetLength(stringref) * 2 + 1;
 530             buf = (char*)malloc(sizeof(char) * bufsize);
 531             if(buf == NULL) {
 532                 qDebug() << "[System] can't allocate memory for proxy string!";
 533                 CFRelease(dictref);
 534                 return QUrl("");
 535             }
 536             CFStringGetCString(stringref, buf, bufsize, kCFStringEncodingUTF16);
 537             numberref = (CFNumberRef)CFDictionaryGetValue(dictref, kSCPropNetProxiesHTTPPort);
 538             if(numberref != NULL)
 539                 CFNumberGetValue(numberref, kCFNumberIntType, &port);
 540             proxy.setScheme("http");
 541             proxy.setHost(QString::fromUtf16((unsigned short*)buf));
 542             proxy.setPort(port);
 543
 544             free(buf);
 545             }
 546     }
 547     CFRelease(dictref);
 548
 549     return proxy;
 550 #else
 551     return QUrl("");
 552 #endif
 553 }
 554
 555