Glenn Maynard
39604143f6
not drivers; use timeout FS; don't pass mountpoints to drivers since they never need to know them
585 lines
17 KiB
C++
585 lines
17 KiB
C++
#include "global.h"
|
|
#include "MemoryCardDriverThreaded_Linux.h"
|
|
#include "RageLog.h"
|
|
#include "RageUtil.h"
|
|
#include "RageFileManager.h"
|
|
#include "Profile.h"
|
|
#include "PrefsManager.h"
|
|
#include "Foreach.h"
|
|
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <cerrno>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <fstream>
|
|
#include <dirent.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/poll.h>
|
|
|
|
const CString TEMP_MOUNT_POINT = "@mctemp/";
|
|
|
|
void GetNewStorageDevices( vector<UsbStorageDevice>& vDevicesOut );
|
|
|
|
template<class T>
|
|
bool VectorsAreEqual( const T &a, const T &b )
|
|
{
|
|
if( a.size() != b.size() )
|
|
return false;
|
|
|
|
for( unsigned i=0; i<a.size(); i++ )
|
|
{
|
|
if( a[i] != b[i] )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool TestWrite( CCStringRef sDir )
|
|
{
|
|
// Try to write a file.
|
|
// TODO: Can we use RageFile for this?
|
|
CString sFile = sDir + "/temp";
|
|
FILE* fp = fopen( sFile, "w" );
|
|
if( fp == NULL )
|
|
return false;
|
|
fclose( fp );
|
|
remove( sFile );
|
|
return true;
|
|
}
|
|
|
|
static bool ExecuteCommand( CCStringRef sCommand )
|
|
{
|
|
LOG->Trace( "executing '%s'", sCommand.c_str() );
|
|
int ret = system(sCommand);
|
|
LOG->Trace( "done executing '%s'", sCommand.c_str() );
|
|
if( ret != 0 )
|
|
LOG->Warn( "failed to execute '%s' with error %d.", sCommand.c_str(), ret );
|
|
return ret == 0;
|
|
}
|
|
|
|
MemoryCardDriverThreaded_Linux::MemoryCardDriverThreaded_Linux()
|
|
{
|
|
this->StartThread();
|
|
}
|
|
|
|
MemoryCardDriverThreaded_Linux::~MemoryCardDriverThreaded_Linux()
|
|
{
|
|
this->StopThread();
|
|
}
|
|
|
|
void MemoryCardDriverThreaded_Linux::ResetUsbStorage()
|
|
{
|
|
}
|
|
|
|
static bool ReadFile( const CString &sPath, CString &sBuf )
|
|
{
|
|
sBuf.clear();
|
|
|
|
int fd = open( sPath, O_RDONLY );
|
|
if( fd == -1 )
|
|
{
|
|
LOG->Warn( "Error opening \"%s\": %s", sPath.c_str(), strerror(errno) );
|
|
return false;
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
char buf[1024];
|
|
int iGot = read( fd, buf, sizeof(buf) );
|
|
if( iGot == -1 )
|
|
{
|
|
close(fd);
|
|
LOG->Warn( "Error reading \"%s\": %s", sPath.c_str(), strerror(errno) );
|
|
return false;
|
|
}
|
|
|
|
sBuf.append( buf, iGot );
|
|
if( iGot < (int) sizeof(buf) )
|
|
break;
|
|
}
|
|
|
|
close(fd);
|
|
return true;
|
|
}
|
|
|
|
static void GetFileList( const CString &sPath, vector<CString> &out )
|
|
{
|
|
out.clear();
|
|
|
|
DIR *dp = opendir( sPath );
|
|
if( dp == NULL )
|
|
return; // false; // XXX warn
|
|
|
|
while( const struct dirent *ent = readdir(dp) )
|
|
out.push_back( ent->d_name );
|
|
|
|
closedir( dp );
|
|
}
|
|
|
|
static bool BlockDevicesChanged()
|
|
{
|
|
LOG->Trace("StorageDevicesChanged");
|
|
static CString sLastDevices = "";
|
|
CString sThisDevices;
|
|
|
|
/* If a device is removed and reinserted, the inode of the /sys/block entry
|
|
* will change. */
|
|
CString sDevicePath = "/sys/block/";
|
|
|
|
vector<CString> asDevices;
|
|
GetFileList( sDevicePath, asDevices );
|
|
|
|
for( unsigned i = 0; i < asDevices.size(); ++i )
|
|
{
|
|
struct stat buf;
|
|
if( stat( sDevicePath + asDevices[i], &buf ) == -1 )
|
|
continue; // XXX warn
|
|
|
|
sThisDevices += ssprintf( "%i,", (int) buf.st_ino );
|
|
}
|
|
|
|
bool bChanged = sThisDevices != sLastDevices;
|
|
sLastDevices = sThisDevices;
|
|
if( bChanged )
|
|
LOG->Trace( "Change in USB storage devices detected." );
|
|
return bChanged;
|
|
}
|
|
|
|
bool MemoryCardDriverThreaded_Linux::MountThreadWaitForUpdate()
|
|
{
|
|
/* Check if any devices need a write test. */
|
|
for( unsigned i=0; i<m_vDevicesLastSeen.size(); i++ )
|
|
{
|
|
UsbStorageDevice &d = m_vDevicesLastSeen[i];
|
|
if( d.bNeedsWriteTest )
|
|
return true;
|
|
}
|
|
|
|
/* Nothing needs a write test. If no devices have changed, either,
|
|
* delay. */
|
|
if( BlockDevicesChanged() )
|
|
return true;
|
|
|
|
/* Nothing to do. Delay, so we don't busy loop. */
|
|
usleep(1000*300); // 300 ms
|
|
return false;
|
|
}
|
|
|
|
void MemoryCardDriverThreaded_Linux::MountThreadDoOneUpdate()
|
|
{
|
|
vector<UsbStorageDevice> vNew;
|
|
GetNewStorageDevices( vNew );
|
|
vector<UsbStorageDevice> vOld = m_vDevicesLastSeen; // copy
|
|
|
|
// check for disconnects
|
|
vector<UsbStorageDevice> vDisconnects;
|
|
FOREACH( UsbStorageDevice, vOld, old )
|
|
{
|
|
vector<UsbStorageDevice>::iterator iter = find( vNew.begin(), vNew.end(), *old );
|
|
if( iter == vNew.end() ) // didn't find
|
|
{
|
|
LOG->Trace( "Disconnected bus %d port %d level %d path %s", old->iBus, old->iPort, old->iLevel, old->sOsMountDir.c_str() );
|
|
vDisconnects.push_back( *old );
|
|
|
|
vector<UsbStorageDevice>::iterator iter = find( m_vDevicesLastSeen.begin(), m_vDevicesLastSeen.end(), *old );
|
|
ASSERT( iter != m_vDevicesLastSeen.end() );
|
|
m_vDevicesLastSeen.erase( iter );
|
|
}
|
|
}
|
|
|
|
|
|
// check for connects
|
|
vector<UsbStorageDevice> vConnects;
|
|
FOREACH( UsbStorageDevice, vNew, newd )
|
|
{
|
|
vector<UsbStorageDevice>::iterator iter = find( vOld.begin(), vOld.end(), *newd );
|
|
if( iter == vOld.end() ) // didn't find
|
|
{
|
|
LOG->Trace( "Connected bus %d port %d level %d path %s", newd->iBus, newd->iPort, newd->iLevel, newd->sOsMountDir.c_str() );
|
|
vConnects.push_back( *newd );
|
|
|
|
m_vDevicesLastSeen.push_back( *newd );
|
|
}
|
|
}
|
|
|
|
bool bDidAnyMounts = false;
|
|
|
|
// unmount all disconnects
|
|
//if( ShouldDoOsMount() )
|
|
for( unsigned i=0; i<m_vDevicesLastSeen.size(); i++ )
|
|
{
|
|
UsbStorageDevice &d = m_vDevicesLastSeen[i];
|
|
d.bNeedsWriteTest = false;
|
|
d.bWriteTestSucceeded = true;
|
|
}
|
|
|
|
if( false )
|
|
{
|
|
for( unsigned i=0; i<vDisconnects.size(); i++ )
|
|
{
|
|
UsbStorageDevice &d = vDisconnects[i];
|
|
CString sCommand = "umount " + d.sOsMountDir;
|
|
LOG->Trace( "unmount disconnects %i/%i (%s)", i, vDisconnects.size(), sCommand.c_str() );
|
|
ExecuteCommand( sCommand );
|
|
LOG->Trace( "unmount disconnects %i/%i done", i, vDisconnects.size() );
|
|
}
|
|
|
|
// mount all devices that need a write test
|
|
for( unsigned i=0; i<m_vDevicesLastSeen.size(); i++ )
|
|
{
|
|
UsbStorageDevice &d = m_vDevicesLastSeen[i];
|
|
if( !d.bNeedsWriteTest )
|
|
continue; // skip
|
|
|
|
bDidAnyMounts = true;
|
|
|
|
d.bNeedsWriteTest = false;
|
|
|
|
d.bWriteTestSucceeded = true;
|
|
|
|
CString sCommand;
|
|
|
|
// unmount this device before trying to mount it. If this device
|
|
// wasn't unmounted before, then our mount call will fail and the
|
|
// mount may contain an out-of-date view of the files on the device.
|
|
sCommand = "umount " + d.sOsMountDir;
|
|
LOG->Trace( "unmount old connect %i/%i (%s)", i, vConnects.size(), sCommand.c_str() );
|
|
ExecuteCommand( sCommand ); // don't care if this fails
|
|
LOG->Trace( "unmount old connect %i/%i done", i, vConnects.size() );
|
|
|
|
sCommand = "mount " + d.sOsMountDir;
|
|
LOG->Trace( "mount new connect %i/%i (%s)", i, vConnects.size(), sCommand.c_str() );
|
|
bool bMountedSuccessfully = ExecuteCommand( sCommand );
|
|
LOG->Trace( "mount new connect %i/%i done", i, vConnects.size() );
|
|
|
|
d.bWriteTestSucceeded = bMountedSuccessfully && TestWrite( d.sOsMountDir );
|
|
|
|
// read name
|
|
this->Mount( &d, TEMP_MOUNT_POINT );
|
|
FILEMAN->FlushDirCache( TEMP_MOUNT_POINT );
|
|
|
|
Profile profile;
|
|
CString sProfileDir = TEMP_MOUNT_POINT + PREFSMAN->m_sMemoryCardProfileSubdir + '/';
|
|
profile.LoadEditableDataFromDir( sProfileDir );
|
|
d.sName = profile.GetDisplayName();
|
|
|
|
UnmountMountPoint( TEMP_MOUNT_POINT );
|
|
|
|
LOG->Trace( "WriteTest: %s, Name: %s", d.bWriteTestSucceeded ? "succeeded" : "failed", d.sName.c_str() );
|
|
}
|
|
}
|
|
|
|
if( bDidAnyMounts || !vDisconnects.empty() || !vConnects.empty() )
|
|
{
|
|
LockMut( m_mutexStorageDevices );
|
|
m_bStorageDevicesChanged = true;
|
|
m_vStorageDevices = m_vDevicesLastSeen;
|
|
}
|
|
|
|
CHECKPOINT;
|
|
}
|
|
|
|
struct WhiteListEntry
|
|
{
|
|
int idVendor; // -1 = "always match"
|
|
int idProduct; // -1 = "always match"
|
|
const char *szVendorRegex; // empty string matches all
|
|
const char *szProductRegex; // empty string matches all
|
|
};
|
|
static const WhiteListEntry g_AllowedEntries[] =
|
|
{
|
|
{ 0x0781, -1, "", "Cruzer" }, // SanDisk Cruzer* drives
|
|
// Disallow the Rio Carbon. After several mounts, usb-storage gets into a state where mounting will fail.
|
|
// { 0x045a, -1, "", "" }, // Diamond Multimedia Systems (Rio)
|
|
{ 0x04e8, -1, "Kingston|KINGSTON", "" }, // Kingston pen drives manufactured by Samsung
|
|
{ 0x041e, -1, "", "^NOMAD MuVo$|^NOMAD MuVo .X" }, // Creative Labs Nomad MuVo flash drives (hard drive players excluded)
|
|
// Some Iomega Micro Mini drives cause mount to hang
|
|
// { 0x4146, -1, "", "Flash" }, // Iomega Micro Mini drive
|
|
{ 0x05dc, -1, "", "JUMP|Jump" }, // All Lexar Jump* drives
|
|
{ 0x1915, 0x2220, "", "" }, // Linksys USB 2.0 Disk 128MB
|
|
{ 0x0d7d, -1, "", "USB DISK" }, // PNY Attache pen drives
|
|
{ 0x0ea0, -1, "", "Flash Disk" }, // other PNY Attache pen drives
|
|
{ 0x0ef5, -1, "", "Intelligent|Traveling" }, // PQI Intelligent Stick and Traveling Disk
|
|
{ 0x08ec, -1, "", "M-Disk" }, // M-Systems flash drive
|
|
};
|
|
bool IsDeviceAllowed( int idVendor, int idProduct, CString sVendor, CString sProduct )
|
|
{
|
|
bool bAllowed = false;
|
|
|
|
for( unsigned i=0; i<ARRAYSIZE(g_AllowedEntries); i++ )
|
|
{
|
|
const WhiteListEntry &entry = g_AllowedEntries[i];
|
|
if( entry.idVendor != -1 && entry.idVendor != idVendor )
|
|
continue;
|
|
if( entry.idProduct != -1 && entry.idProduct != idProduct )
|
|
continue;
|
|
Regex regexVendor( entry.szVendorRegex );
|
|
if( !regexVendor.Compare(sVendor) )
|
|
continue;
|
|
Regex regexProduct( entry.szProductRegex );
|
|
if( !regexProduct.Compare(sProduct) )
|
|
continue;
|
|
|
|
bAllowed = true;
|
|
break;
|
|
}
|
|
|
|
LOG->Trace( "idVendor 0x%04X, idDevice 0x%04X, Vendor '%s', Product '%s' is %sallowed.", idVendor, idProduct, sVendor.c_str(), sProduct.c_str(), bAllowed?"":"not " );
|
|
return bAllowed;
|
|
}
|
|
|
|
void GetNewStorageDevices( vector<UsbStorageDevice>& vDevicesOut )
|
|
{
|
|
LOG->Trace( "GetNewStorageDevices" );
|
|
|
|
vDevicesOut.clear();
|
|
|
|
{
|
|
vector<CString> asDevices;
|
|
CString sBlockDevicePath = "/sys/block/";
|
|
GetFileList( sBlockDevicePath, asDevices );
|
|
|
|
for( unsigned i = 0; i < asDevices.size(); ++i )
|
|
{
|
|
if( asDevices[i] == "." || asDevices[i] == ".." )
|
|
continue;
|
|
|
|
UsbStorageDevice usbd;
|
|
|
|
CString sPath = sBlockDevicePath + asDevices[i] + "/";
|
|
LOG->Trace("'%s'", sPath.c_str());
|
|
|
|
/* Ignore non-removable devices. */
|
|
CString sBuf;
|
|
if( !ReadFile( sPath + "removable", sBuf ) )
|
|
continue; // already warned
|
|
if( atoi(sBuf) != 1 )
|
|
continue;
|
|
|
|
|
|
usbd.sScsiDevice = "/dev/" + asDevices[i];
|
|
|
|
/*
|
|
* sPath/device should be a symlink to the actual device. For USB
|
|
* devices, it looks like this:
|
|
*
|
|
* device -> ../../devices/pci0000:00/0000:00:02.1/usb2/2-1/2-1:1.0
|
|
*
|
|
* "2-1" is "bus-port".
|
|
*/
|
|
char szLink[256];
|
|
int iRet = readlink( sPath + "device", szLink, sizeof(szLink) );
|
|
if( iRet == -1 )
|
|
{
|
|
LOG->Warn( "readlink(\"%s\"): %s", (sPath + "device").c_str(), strerror(errno) );
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* The full path looks like
|
|
*
|
|
* ../../devices/pci0000:00/0000:00:02.1/usb2/2-2/2-2.1/2-2.1:1.0
|
|
*
|
|
* Each path element refers to a new hop in the chain.
|
|
* "usb2" = second USB host
|
|
* 2- second USB host,
|
|
* -2 port 1 on the host,
|
|
* .1 port 1 on an attached hub
|
|
* .2 ... port 2 on the next hub ...
|
|
*
|
|
* We want the bus number and the port of the last hop. The level is
|
|
* the number of hops.
|
|
*/
|
|
szLink[iRet] = 0;
|
|
vector<CString> asBits;
|
|
split( szLink, "/", asBits );
|
|
|
|
if( strstr( szLink, "usb" ) != NULL )
|
|
{
|
|
CString sHostPort = asBits[asBits.size()-2];
|
|
sHostPort.Replace( "-", "." );
|
|
asBits.clear();
|
|
split( sHostPort, ".", asBits );
|
|
if( asBits.size() > 1 )
|
|
{
|
|
usbd.iBus = atoi( asBits[0] );
|
|
usbd.iPort = atoi( asBits[asBits.size()-1] );
|
|
usbd.iLevel = asBits.size() - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( ReadFile( sPath + "device/../idVendor", sBuf ) )
|
|
sscanf( sBuf, "%x", &usbd.idVendor );
|
|
|
|
if( ReadFile( sPath + "device/../idProduct", sBuf ) )
|
|
sscanf( sBuf, "%x", &usbd.idProduct );
|
|
|
|
/* These queries cause communication with the USB device. Disabling
|
|
* them may result in higher reliability. */
|
|
if( ReadFile( sPath + "device/../serial", sBuf ) )
|
|
{
|
|
usbd.sSerial = sBuf;
|
|
TrimRight( usbd.sSerial );
|
|
}
|
|
if( ReadFile( sPath + "device/../product", sBuf ) )
|
|
{
|
|
usbd.sProduct = sBuf;
|
|
TrimRight( usbd.sVendor );
|
|
}
|
|
if( ReadFile( sPath + "device/../manufacturer", sBuf ) )
|
|
{
|
|
usbd.sVendor = sBuf;
|
|
TrimRight( usbd.sVendor );
|
|
}
|
|
|
|
if( IsDeviceAllowed( usbd.idVendor, usbd.idProduct, usbd.sVendor, usbd.sProduct ) )
|
|
{
|
|
vDevicesOut.push_back( usbd );
|
|
|
|
LOG->Trace( "iBus: %d, iLevel: %d, iPort: %d, sSerial = %s",
|
|
usbd.iBus, usbd.iLevel, usbd.iPort, usbd.sSerial.c_str() );
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
// Find where each device is mounted. Output looks like:
|
|
|
|
// /dev/sda1 /mnt/flash1 auto noauto,owner 0 0
|
|
// /dev/sdb1 /mnt/flash2 auto noauto,owner 0 0
|
|
// /dev/sdc1 /mnt/flash3 auto noauto,owner 0 0
|
|
|
|
CString fn = "/etc/fstab";
|
|
LOG->Trace( "Reading %s", fn.c_str() );
|
|
RageFile f;
|
|
if( !f.Open(fn) )
|
|
{
|
|
LOG->Warn( "can't open '%s': %s", fn.c_str(), f.GetError().c_str() );
|
|
return;
|
|
}
|
|
|
|
CString sLine;
|
|
while( !f.AtEOF() )
|
|
{
|
|
switch( f.GetLine(sLine) )
|
|
{
|
|
case 0: continue; /* eof */
|
|
case -1:
|
|
LOG->Warn( "error reading '%s': %s", fn.c_str(), f.GetError().c_str() );
|
|
return;
|
|
}
|
|
|
|
char szScsiDevice[1024];
|
|
char szMountPoint[1024];
|
|
int iRet = sscanf( sLine, "%s %s", szScsiDevice, szMountPoint );
|
|
if( iRet != 2 )
|
|
continue; // don't process this line
|
|
|
|
|
|
CString sMountPoint = szMountPoint;
|
|
TrimLeft( sMountPoint );
|
|
TrimRight( sMountPoint );
|
|
|
|
// search for the usb-storage device corresponding to the SCSI device
|
|
for( unsigned i=0; i<vDevicesOut.size(); i++ )
|
|
{
|
|
UsbStorageDevice& usbd = vDevicesOut[i];
|
|
if( usbd.sScsiDevice+"1" == szScsiDevice ) // found our match
|
|
{
|
|
usbd.sOsMountDir = sMountPoint;
|
|
|
|
LOG->Trace( "iScsiIndex: %d, sScsiDevice: %s, iBus: %d, iLevel: %d, iPort: %d, sOsMountDir: %s",
|
|
usbd.iScsiIndex, usbd.sScsiDevice.c_str(), usbd.iBus, usbd.iLevel, usbd.iPort, usbd.sOsMountDir.c_str() );
|
|
|
|
break; // stop looking for a match
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Remove any devices that we couldn't find a mountpoint for. */
|
|
for( unsigned i=0; i<vDevicesOut.size(); i++ )
|
|
{
|
|
UsbStorageDevice& usbd = vDevicesOut[i];
|
|
if( usbd.sOsMountDir.empty() )
|
|
{
|
|
LOG->Trace( "Ignoring %s (couldn't find in /etc/fstab)", usbd.sSerial.c_str() );
|
|
|
|
vDevicesOut.erase( vDevicesOut.begin()+i );
|
|
--i;
|
|
}
|
|
}
|
|
|
|
LOG->Trace( "Done with GetNewStorageDevices" );
|
|
}
|
|
|
|
|
|
void MemoryCardDriverThreaded_Linux::Mount( UsbStorageDevice* pDevice )
|
|
{
|
|
ASSERT( !pDevice->sOsMountDir.empty() );
|
|
|
|
// HACK: Do OS mount for m_bMemoryCardsMountOnlyWhenNecessary
|
|
CString sCommand = "mount " + pDevice->sOsMountDir;
|
|
LOG->Trace( "hack mount (%s)", sCommand.c_str() );
|
|
bool bMountedSuccessfully = ExecuteCommand( sCommand );
|
|
|
|
pDevice->bWriteTestSucceeded = bMountedSuccessfully && TestWrite( pDevice->sOsMountDir );
|
|
|
|
LOG->Trace( "WriteTest: %s, Name: %s", pDevice->bWriteTestSucceeded ? "succeeded" : "failed", pDevice->sName.c_str() );
|
|
}
|
|
|
|
void MemoryCardDriverThreaded_Linux::Unmount( UsbStorageDevice* pDevice )
|
|
{
|
|
if( pDevice->sOsMountDir.empty() )
|
|
return;
|
|
|
|
// already unmounted by the mounting thread
|
|
|
|
// HACK: Do OS unmount for m_bMemoryCardsMountOnlyWhenNecessary
|
|
CString sCommand = "umount " + pDevice->sOsMountDir;
|
|
LOG->Trace( "hack unmount (%s)", sCommand.c_str() );
|
|
ExecuteCommand( sCommand );
|
|
}
|
|
|
|
void MemoryCardDriverThreaded_Linux::Flush( UsbStorageDevice* pDevice )
|
|
{
|
|
if( pDevice->sOsMountDir.empty() )
|
|
return;
|
|
|
|
// "sync" will only flush all file systems at the same time. -Chris
|
|
// I don't think so. Also, sync() merely queues a flush; it doesn't guarantee
|
|
// that the flush is completed on return. However, we can mount the filesystem
|
|
// with the flag "-o sync", which forces synchronous access (but that's probably
|
|
// very slow.) -glenn
|
|
ExecuteCommand( "mount -o remount " + pDevice->sOsMountDir );
|
|
}
|
|
|
|
/*
|
|
* (c) 2003-2004 Chris Danford, Glenn Maynard
|
|
* All rights reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, and/or sell copies of the Software, and to permit persons to
|
|
* whom the Software is furnished to do so, provided that the above
|
|
* copyright notice(s) and this permission notice appear in all copies of
|
|
* the Software and that both the above copyright notice(s) and this
|
|
* permission notice appear in supporting documentation.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
|
|
* THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
|
|
* INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
|
|
* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
|
|
* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
|
* OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|