misc. opcmciasystem improvements

start implementing recursve dirlocks in ODirNotification

3 files changed, 123 insertions, 64 deletions

diff --git a/libopie2/opiecore/linux/ofilenotify.cpp b/libopie2/opiecore/linux/ofilenotify.cpp
index 36ec6bf..3096f7e 100644
--- a/libopie2/opiecore/linux/ofilenotify.cpp
+++ b/libopie2/opiecore/linux/ofilenotify.cpp
@@ -302,105 +302,116 @@ void OFileNotification::inotifyEventHandler()
 }
 
 
 bool OFileNotification::registerEventHandler()
 {
     OFileNotification::_fd = ::open( INOTIFY_DEVICE, O_RDONLY );
     if ( OFileNotification::_fd < 0 )
     {
         qWarning( "OFileNotification::registerEventHandler(): couldn't register event handler: %s", strerror( errno ) );
         return false;
     }
 
     OFileNotification::_sn = new QSocketNotifier( _fd, QSocketNotifier::Read, this, "inotify event" );
     connect( OFileNotification::_sn, SIGNAL( activated(int) ), this, SLOT( inotifyEventHandler() ) );
 
     qDebug( "OFileNotification::registerEventHandler(): done" );
     return true;
 }
 
 
 void OFileNotification::unregisterEventHandler()
 {
     if ( _sn ) delete _sn;
     if ( OFileNotification::_fd )
     ::close( OFileNotification::_fd );
     qDebug( "OFileNotification::unregisterEventHandler(): done" );
 }
 
 //=================================================================================================
 // ODirNotification
 //=================================================================================================
 ODirNotification::ODirNotification( QObject* parent, const char* name )
                   :QObject( parent, name )
 {
     qDebug( "ODirNotification::ODirNotification()" );
 }
 
 
 ODirNotification::~ODirNotification()
 {
     qDebug( "ODirNotification::~ODirNotification()" );
 }
 
 
 int ODirNotification::watch( const QString& path, bool sshot, OFileNotificationType type, int recurse )
 {
     qDebug( "ODirNotification::watch( %s, %d, 0x%08x, %d )", (const char*) path, sshot, type, recurse );
 
-    if ( recurse == 0 )
-    {
         OFileNotification* fn = new OFileNotification( this, "ODirNotification delegate" );
         int result = fn->startWatching( path, sshot, type );
         if ( result != -1 )
         {
             connect( fn, SIGNAL( triggered( const QString&, unsigned int, const QString& ) ), this, SIGNAL( triggered( const QString&, unsigned int, const QString& ) ) );
             connect( fn, SIGNAL( accessed( const QString& ) ), this, SIGNAL( accessed( const QString& ) ) );
             connect( fn, SIGNAL( modified( const QString& ) ), this, SIGNAL( modified( const QString& ) ) );
             connect( fn, SIGNAL( attributed( const QString& ) ), this, SIGNAL( attributed( const QString& ) ) );
             connect( fn, SIGNAL( closed( const QString&, bool ) ), this, SIGNAL( closed( const QString&, bool ) ) );
             connect( fn, SIGNAL( opened( const QString& ) ), this, SIGNAL( opened( const QString& ) ) );
             connect( fn, SIGNAL( movedTo( const QString&, const QString& ) ), this, SIGNAL( movedTo( const QString&, const QString& ) ) );
             connect( fn, SIGNAL( movedFrom( const QString&, const QString& ) ), this, SIGNAL( movedFrom( const QString&, const QString& ) ) );
             connect( fn, SIGNAL( deletedSubdir( const QString&, const QString& ) ), this, SIGNAL( deletedSubdir( const QString&, const QString& ) ) );
             connect( fn, SIGNAL( deletedFile( const QString&, const QString& ) ), this, SIGNAL( deletedFile( const QString&, const QString& ) ) );;
             connect( fn, SIGNAL( createdSubdir( const QString&, const QString& ) ), this, SIGNAL( createdSubdir( const QString&, const QString& ) ) );
             connect( fn, SIGNAL( createdFile( const QString&, const QString& ) ), this, SIGNAL( createdFile( const QString&, const QString& ) ) );
             connect( fn, SIGNAL( deleted( const QString& ) ), this, SIGNAL( deleted( const QString& ) ) );
             connect( fn, SIGNAL( unmounted( const QString& ) ), this, SIGNAL( unmounted( const QString& ) ) );
-        }
-        return result;
-    }
-    else
+
+        if ( recurse )
     {
+            QDir directory( path );
+            QStringList subdirs = directory.entryList( QDir::Dirs );
 
-        return 1;
+            for ( QStringList::Iterator it = subdirs.begin(); it != subdirs.end(); ++it )
+            {
+                if ( (*it) == "." || (*it) == ".." ) continue;
+                QString subpath = QString( "%1/%2" ).arg( path ).arg( *it );
+                int subresult = watch( subpath, sshot, type, recurse-1 );
+                if ( subresult == -1 )
+                {
+                    qDebug( "ODirNotification::watch(): subresult for '%s' was -1. Interrupting", (const char*) (*it) );
+                    return -1;
+                }
+            }
+        }
+//connect( fn, SIGNAL( triggered( const QString&, unsigned int, const QString& ) ), this, SIGNAL( triggered( const QString&, unsigned int, const QString& ) ) );
     }
+    else return -1;
 }
 
 
 // void ODirNotification::subdirCreated( const QString& name )
 
 
 /*
   Love-Trowbridge recursive directory scanning algorithm:
 
         Step 1.  Start at initial directory foo.  Add watch.
 
         Step 2.  Setup handlers for watch created in Step 1.
                  Specifically, ensure that a directory created
                  in foo will result in a handled CREATE_SUBDIR
                  event.
 
         Step 3.  Read the contents of foo.
 
         Step 4.  For each subdirectory of foo read in step 3, repeat
                  step 1.
 
         Step 5.  For any CREATE_SUBDIR event on bar, if a watch is
                  not yet created on bar, repeat step 1 on bar.
 */
 
 
 } // namespace Ui
 
 } // namespace Opie
diff --git a/libopie2/opiecore/linux/opcmciasystem.cpp b/libopie2/opiecore/linux/opcmciasystem.cpp
index 0f7ff46..929e289 100644
--- a/libopie2/opiecore/linux/opcmciasystem.cpp
+++ b/libopie2/opiecore/linux/opcmciasystem.cpp
@@ -127,226 +127,253 @@ void OPcmciaSystem::synchronize()
 
 
 int OPcmciaSystem::count() const
 {
     return _interfaces.count();
 }
 
 
 int OPcmciaSystem::cardCount() const
 {
     int nonEmpty = 0;
     OPcmciaSystem::CardIterator it = iterator();
     while ( it.current() )
     {
         if ( !it.current()->isEmpty() ) nonEmpty++;
         ++it;
     }
     return nonEmpty;
 }
 
 
 OPcmciaSocket* OPcmciaSystem::socket( unsigned int number )
 {
     return _interfaces.at( number );
 }
 
 
 OPcmciaSystem* OPcmciaSystem::instance()
 {
     if ( !_instance ) _instance = new OPcmciaSystem();
     return _instance;
 }
 
 
 OPcmciaSystem::CardIterator OPcmciaSystem::iterator() const
 {
     return OPcmciaSystem::CardIterator( _interfaces );
 }
 
 
 /*======================================================================================
  * OPcmciaSocket
  *======================================================================================*/
 
 OPcmciaSocket::OPcmciaSocket( int major, int socket, QObject* parent, const char* name )
                  :QObject( parent, name ), _major( major ), _socket( socket )
 {
     qDebug( "OPcmciaSocket::OPcmciaSocket()" );
-
     init();
-    buildInformation();
 }
 
 
 OPcmciaSocket::~OPcmciaSocket()
 {
     qDebug( "OPcmciaSocket::~OPcmciaSocket()" );
     cleanup();
 }
 
 
 /* internal */ void OPcmciaSocket::init()
 {
     // open control socket and gather file descriptor
     if ( _major )
     {
         dev_t dev = makedev( _major, _socket );
         QString filename = QString().sprintf( "/tmp/opcmciasystem-%d", ::getpid() );
         if ( ::mknod( (const char*) filename, ( S_IFCHR|S_IREAD|S_IWRITE ), dev ) == 0 )
         {
             _fd = ::open( (const char*) filename, O_RDONLY);
             if ( !_fd )
             {
                 qWarning( "OPcmciaSocket::init() - can't open control socket (%s)", strerror( errno ) );
             }
             else
             {
                 ::unlink( (const char*) filename );
             }
         }
         else
         {
             qWarning( "OPcmciaSocket::init() - can't create device node (%s)", strerror( errno ) );
         }
     }
 }
 
-/* internal */ void OPcmciaSocket::buildInformation()
-{
-    cistpl_vers_1_t *vers = &_ioctlarg.tuple_parse.parse.version_1;
-    cistpl_manfid_t *manfid = &_ioctlarg.tuple_parse.parse.manfid;
-    cistpl_funcid_t *funcid = &_ioctlarg.tuple_parse.parse.funcid;
-    config_info_t config;
-
-    if ( getTuple( CISTPL_VERS_1 ) )
-    {
-        for ( int i = 0; i < CISTPL_VERS_1_MAX_PROD_STRINGS; ++i )
-        {
-            qDebug( " PRODID = '%s'", vers->str+vers->ofs[i] );
-            _productId += vers->str+vers->ofs[i];
-        }
-    }
-        /*
-        for (i = 0; i < 4; i++)
-            printf("PRODID_%d=\"%s\"\n", i+1,
-                (i < vers->ns) ? vers->str+vers->ofs[i] : "");
-        *manfid = (cistpl_manfid_t) { 0, 0 };
-        get_tuple(fd, CISTPL_MANFID, &arg);
-        printf("MANFID=%04x,%04x\n", manfid->manf, manfid->card);
-        *funcid = (cistpl_funcid_t) { 0xff, 0xff };
-        get_tuple(fd, CISTPL_FUNCID, &arg);
-        printf("FUNCID=%d\n", funcid->func);
-        config.Function = config.ConfigBase = 0;
-        */
-}
-
 /* internal */ void OPcmciaSocket::cleanup()
 {
     // close control socket
 }
 
-/* internal */ bool OPcmciaSocket::getTuple( cisdata_t tuple )
+/* internal */ bool OPcmciaSocket::getTuple( cisdata_t tuple ) const
 {
     _ioctlarg.tuple.DesiredTuple = tuple;
     _ioctlarg.tuple.Attributes = TUPLE_RETURN_COMMON;
     _ioctlarg.tuple.TupleOffset = 0;
 
     int result;
     result = ::ioctl(_fd, DS_GET_FIRST_TUPLE, &_ioctlarg);
     if ( result != 0 )
     {
         qWarning( "OPcmciaSocket::getTuple() - DS_GET_FIRST_TUPLE failed (%s)", strerror( errno ) );
         return false;
     }
 
     result = ::ioctl(_fd, DS_GET_TUPLE_DATA, &_ioctlarg);
     if ( result != 0 )
     {
         qWarning( "OPcmciaSocket::getTuple() - DS_GET_TUPLE_DATA failed (%s)", strerror( errno ) );
         return false;
     }
 
     result = ::ioctl(_fd, DS_PARSE_TUPLE, &_ioctlarg);
     if ( result != 0 )
     {
         qWarning( "OPcmciaSocket::getTuple() - DS_PARSE_TUPLE failed (%s)", strerror( errno ) );
         return false;
     }
 
     return true;
 }
 
 
-/* internal */ bool OPcmciaSocket::command( const QString& cmd )
-{
-    QString cmdline = QString().sprintf( "cardctl %s %d &", (const char*) cmd, _socket );
-    ::system( (const char*) cmdline );
-}
-
 int OPcmciaSocket::number() const
 {
     return _socket;
 }
 
 
 QString OPcmciaSocket::identity() const
 {
     return ( strcmp( name(), "empty" ) == 0 ) ? "<Empty Socket>" : name();
 }
 
 
+const OPcmciaSocket::OPcmciaSocketCardStatus OPcmciaSocket::status() const
+{
+    cs_status_t cs_status;
+    cs_status.Function = 0;
+    int result = ::ioctl( _fd, DS_GET_STATUS, &cs_status );
+    if ( result != 0 )
+    {
+        qWarning( "OPcmciaSocket::status() - DS_GET_STATUS failed (%s)", strerror( errno ) );
+        return Unknown;
+    }
+    else
+    {
+        qDebug( " card   status = 0x%08x", cs_status.CardState );
+        qDebug( " socket status = 0x%08x", cs_status.SocketState );
+        return (OPcmciaSocket::OPcmciaSocketCardStatus) (cs_status.CardState + cs_status.SocketState);
+    }
+}
+
+
 bool OPcmciaSocket::isUnsupported() const
 {
     return ( strcmp( name(), "unsupported card" ) == 0 );
 }
 
 
 bool OPcmciaSocket::isEmpty() const
 {
-    return ( strcmp( name(), "empty" ) == 0 );
+    return ! status() && ( Occupied || OccupiedCardBus );
 }
 
 
 bool OPcmciaSocket::isSuspended() const
 {
-    //FIXME
-    return false;
+    return status() && Suspended;    
 }
 
+
 bool OPcmciaSocket::eject()
 {
-    return command( "eject" );
+    return ::ioctl( _fd, DS_EJECT_CARD );
 }
 
+
 bool OPcmciaSocket::insert()
 {
-    return command( "insert" );
+    return ::ioctl( _fd, DS_INSERT_CARD );
 }
 
+
 bool OPcmciaSocket::suspend()
 {
-    return command( "suspend" );
+    return ::ioctl( _fd, DS_SUSPEND_CARD );
 }
 
+
 bool OPcmciaSocket::resume()
 {
-    return command( "resume");
+    return ::ioctl( _fd, DS_RESUME_CARD );
 }
 
+
 bool OPcmciaSocket::reset()
 {
-    return command( "reset");
+    return ::ioctl( _fd, DS_RESET_CARD );
 }
 
-const QStringList& OPcmciaSocket::productIdentity() const
+
+QStringList OPcmciaSocket::productIdentity() const
 {
-    return _productId;
+    QStringList list;
+    cistpl_vers_1_t *vers = &_ioctlarg.tuple_parse.parse.version_1;
+    if ( getTuple( CISTPL_VERS_1 ) )
+    {
+        for ( int i = 0; i < CISTPL_VERS_1_MAX_PROD_STRINGS; ++i )
+        {
+            qDebug( " PRODID = '%s'", vers->str+vers->ofs[i] );
+            list += vers->str+vers->ofs[i];
+        }
+    }
+    else
+    {
+        list += "<unknown>";
+    }
+    return list;
 }
 
+
 #if 0
 const QPair& OPcmciaSocket::manufacturerIdentity() const
 {
     return _manufId;
 }
 #endif
 
+
+QString OPcmciaSocket::function() const
+{
+    cistpl_funcid_t *funcid = &_ioctlarg.tuple_parse.parse.funcid;
+    if ( getTuple( CISTPL_FUNCID ) )
+    {
+        switch ( funcid->func )
+        {
+            case 0: return "Multifunction"; break;
+            case 1: return "Memory"; break;
+            case 2: return "Serial"; break;
+            case 3: return "Parallel"; break;
+            case 4: return "Fixed Disk"; break;
+            case 5: return "Video"; break;
+            case 6: return "Network"; break;
+            case 7: return "AIMS"; break;
+            case 8: return "SCSI"; break;
+            default: return "<unknown>"; break;
+        }
+    }
+    else
+    {
+        return "<unknown>";
+    }
+}
diff --git a/libopie2/opiecore/linux/opcmciasystem.h b/libopie2/opiecore/linux/opcmciasystem.h
index ef34964..ac6c1de 100644
--- a/libopie2/opiecore/linux/opcmciasystem.h
+++ b/libopie2/opiecore/linux/opcmciasystem.h
@@ -64,139 +64,160 @@ class OPcmciaSystem : public QObject
      * @returns the number of available sockets
      */
     int count() const;
     /**
      * @returns the number of populated sockets
      */
     int cardCount() const;
     /**
      * @returns a pointer to the (one and only) @ref OSystem instance.
      */
     static OPcmciaSystem* instance();
     /**
      * @returns an iterator usable for iterating through all sound cards.
      */
     CardIterator iterator() const;
     /**
      * @returns a pointer to the @ref OPcmciaSocket object correspinding to socket number n, or 0, if not found
      * @see OPcmciaSocket
      */
     OPcmciaSocket* socket( unsigned int number );
     /**
      * @internal Rebuild the internal database
      * @note Sometimes it might be useful to call this from client code,
      * e.g. after issuing a cardctl insert
      */
     void synchronize();
 
   protected:
     OPcmciaSystem();
 
   private:
     static OPcmciaSystem* _instance;
     CardList _interfaces;
     int _major;
 
   private:
     class Private;
     Private *d;
 };
 
 
 /*======================================================================================
  * OPcmciaSocket
  *======================================================================================*/
 
 class OPcmciaSocket : public QObject
 {
   Q_OBJECT
+  public:
+
+    enum OPcmciaSocketCardStatus
+    {
+        Unknown             = 0,
+        Occupied            = CS_EVENT_CARD_DETECT,
+        OccupiedCardBus     = CS_EVENT_CB_DETECT,
+        WriteProtected      = CS_EVENT_WRITE_PROTECT,
+        BatteryLow          = CS_EVENT_BATTERY_LOW,
+        BatteryDead         = CS_EVENT_BATTERY_DEAD,
+        Ready               = CS_EVENT_READY_CHANGE,
+        Suspended           = CS_EVENT_PM_SUSPEND,
+        Attention           = CS_EVENT_REQUEST_ATTENTION,
+        InsertionInProgress = CS_EVENT_CARD_INSERTION,
+        RemovalInProgress   = CS_EVENT_CARD_REMOVAL,
+        ThreeVolts          = CS_EVENT_3VCARD,
+        SupportsVoltage     = CS_EVENT_XVCARD,
+    };
 
   public:
     /**
      * Constructor. Normally you don't create @ref OPcmciaSocket objects yourself,
      * but access them via @ref OPcmciaSystem::socket().
      */
     OPcmciaSocket( int major, int socket, QObject* parent, const char* name );
     /**
      * Destructor.
      */
     virtual ~OPcmciaSocket();
     /**
      * @returns the corresponding socket number
      */
     int number() const;
     /**
-     * @returns the identification string of the card in this socket, or "<Empty Socket>"
+     * @returns the card managers idea of the cards' identy, or "<Empty Socket>"
      */
     QString identity() const;
     /**
+      * @returns the socket status
+      */
+    const OPcmciaSocketCardStatus status() const;
+    /**
      * @returns true, if the card is unsupported by the cardmgr
      */
     bool isUnsupported() const;
     /**
      * @returns true, if the socket is empty
      */
     bool isEmpty() const;
     /**
      * @returns true, if the socket is suspended
      */
     bool isSuspended() const;
     /**
      * Eject card. @returns true, if operation succeeded
      * @note: This operation needs root privileges
      */
     bool eject();
     /**
      * Insert card. @returns true, if operation succeeded
      * @note: This operation needs root privileges
      */
     bool insert();
     /**
      * Suspend card. @returns true, if operation succeeded
      * @note: This operation needs root privileges
      */
     bool suspend();
     /**
      * Resume card. @returns true, if operation succeeded
      * @note: This operation needs root privileges
      */
     bool resume();
     /**
      * Reset card. @returns true, if operation succeeded
      * @note: This operation needs root privileges
      */
     bool reset();
     /**
       * @returns a list of product IDs
       */
-    const QStringList& productIdentity() const;
+    QStringList productIdentity() const;
     /**
       * @returns the manufacturer ID pair
       */
 #if 0
     const QPair& manufacturerIdentity() const;
 #endif
-
-  private:
-    QStringList _productId;
+    /**
+      * @returns the function string
+      */
+    QString function() const;
 
   private:
     void init();
-    void buildInformation();
     void cleanup();
-    bool command( const QString& cmd );
-    bool getTuple( cisdata_t tuple );
+    bool getTuple( cisdata_t tuple ) const;
     int _major;
     int _socket;
     int _fd;
-    ds_ioctl_arg_t _ioctlarg;
+    mutable ds_ioctl_arg_t _ioctlarg;
 
   private:
     class Private;
     Private *d;
 };
 
 
 }
 }
 
 #endif // OPCMCIASYSTEM_H