3 files changed, 64 insertions, 14 deletions

diff --git a/noncore/apps/opie-console/dialer.cpp b/noncore/apps/opie-console/dialer.cpp
index 89a0e8d..10c16ef 100644
--- a/noncore/apps/opie-console/dialer.cpp
+++ b/noncore/apps/opie-console/dialer.cpp
@@ -1,27 +1,30 @@
 #include "dialer.h"
 
 #include <qlayout.h>
 #include <qprogressbar.h>
 #include <qlabel.h>
 #include <qpushbutton.h>
 #include <qapp.h>
 #include <qtimer.h>
+#include <qmessagebox.h>
 
 #include <unistd.h>
 #include <string.h>
+#include <fcntl.h>
+#include <errno.h>
 
 // State machine:          | When an error occurs, we don't have to
 //                         | reset everything.
 // (init) <------+         | But if the user wants to reset,
 //   |           |         | we stop dialing immediately.
 //   v           |         |
 // (options) ----+         | Following the state machine is necessary
 //   |       \             | to get determinable results.
 //   v        ^            |
 // (dial) ----+            |
 //   |        ^            |
 //   v        |            |
 // (online) --+            |
 //   |                     |
 //   v                     |
 
@@ -31,40 +34,46 @@
 //resetStringLine->setText( config.readEntry("ResetString", MODEM_DEFAULT_RESET_STRING ) );
 //dialPref1Line->setText( config.readEntry("DialPrefix1", MODEM_DEFAULT_DIAL_PREFIX1 ) );
 //dialSuf1Line->setText( config.readEntry("DialSuffix1", MODEM_DEFAULT_DIAL_SUFFIX1 ) );
 //dialPref2Line->setText( config.readEntry("DialPrefix2", MODEM_DEFAULT_DIAL_PREFIX1 ) );
 //dialSuf2Line->setText( config.readEntry("DialSuffix2", MODEM_DEFAULT_DIAL_SUFFIX1 ) );
 //dialPref3Line->setText( config.readEntry("DialPrefix3", MODEM_DEFAULT_DIAL_PREFIX1 ) );
 //dialSuf3Line->setText( config.readEntry("DialSuffix3", MODEM_DEFAULT_DIAL_SUFFIX1 ) );
 //connectLine->setText( config.readEntry("DefaultConnect" MODEM_DEFAULT_CONNECT_STRING ) );
 //hangupLine->setText( config.readEntry("HangupString", MODEM_DEFAULT_HANGUP_STRING ) );
 
 // from modemconfigwidget
 //int rad_flow = prof.readNumEntry("Flow");
 //int rad_parity = prof.readNumEntry("Parity");
 //int speed = prof.readNumEntry("Speed");
 //QString number = prof.readEntry("Number");
 
-Dialer::Dialer(const Profile& profile, QWidget *parent, const char *name)
-: QDialog(parent, name, true), m_profile(profile)
+Dialer::Dialer(const Profile& profile, int fd, QWidget *parent, const char *name)
+: QDialog(parent, name, true), m_fd(fd), m_profile(profile)
 {
         QVBoxLayout *vbox;
         QLabel *desc;
 
+        //m_profile.writeEntry("InitString", "ATZ");
+        //m_profile.writeEntry("DialPrefix1", "ATDT");
+        //m_profile.writeEntry("Termination", "\n");
+
         usercancel = 0;
 
+        fcntl(m_fd, F_SETFL, O_NONBLOCK);
+
         desc = new QLabel(QObject::tr("Dialing number: %1").arg(m_profile.readEntry("Number")), this);
         progress = new QProgressBar(this);
         status = new QLabel("", this);
         status->setFrameStyle(QFrame::Panel | QFrame::Sunken);
         cancel = new QPushButton(QObject::tr("Cancel"), this);
 
         vbox = new QVBoxLayout(this, 2);
         vbox->add(desc);
         vbox->add(progress);
         vbox->add(status);
         vbox->add(cancel);
 
         connect(cancel, SIGNAL(clicked()), SLOT(slotCancel()));
 
         show();
 
@@ -79,122 +88,162 @@ void Dialer::slotCancel()
 {
         if(state != state_online)
         {
                 usercancel = 1;
                 reset();
         }
         else accept();
 }
 
 void Dialer::reset()
 {
         switchState(state_cancel);
 }
 
 void Dialer::slotAutostart()
 {
-        state = state_preinit;
+        //state = state_preinit;
         dial(m_profile.readEntry("Number"));
 }
 
 void Dialer::dial(const QString& number)
 {
         while(state != state_online)
         {
                 if(!usercancel)
                 {
+                        state = state_preinit;
                         trydial(number);
                 }
                 else break;
         }
 
         if(usercancel)
         {
                 reject();
         }
 }
 
 void Dialer::trydial(const QString& number)
 {
         if(state != state_cancel)
         {
                 switchState(state_preinit);
-                // ...
-                QString response = receive();
+                send("+++ATH");
+                send("");
+                //QString response = receive();
         }
 
         if(state != state_cancel)
         {
                 switchState(state_init);
-                //send("ATZ");
-                send(m_profile.readEntry("InitString"));
+                send("ATZ");
+                //send(m_profile.readEntry("InitString"));
                 QString response2 = receive();
+                if(!response2.contains("\nOK\r"))
+                        reset();
         }
 
         if(state != state_cancel)
         {
                 switchState(state_options);
 
                 send("ATM0L0");
                 QString response3 = receive();
+                if(!response3.contains("\nOK\r"))
+                        reset();
         }
 
         if(state != state_cancel)
         {
                 switchState(state_dialtone);
 
                 send("ATX1");
                 QString response4 = receive();
+                if(!response4.contains("\nOK\r"))
+                        reset();
         }
 
         if(state != state_cancel)
         {
                 switchState(state_dialing);
 
-                send(QString("%1 %2").arg(m_profile.readEntry("DialPrefix1")).arg(number));
+                send(QString("ATDT %1").arg(number));
+                //send(QString("%1 %2").arg(m_profile.readEntry("DialPrefix1")).arg(number));
                 QString response5 = receive();
+                if(!response5.contains("\nOK\r"))
+                {
+                        QMessageBox::warning(this,
+                                QObject::tr("Failure"),
+                                QObject::tr("Dialing the number failed."));
+                        slotCancel();
+                }
         }
         
         if(state != state_cancel)
         {
                 switchState(state_online);
         }
 }
 
 void Dialer::send(const QString& msg)
 {
         QString m = msg;
         int bytes;
         QString termination;
 
-        termination = m_profile.readEntry("Termination");
+qWarning("Sending: '%s'", m.latin1());
+
+        termination = "\r";
+        //termination = m_profile.readEntry("Termination");
         if(termination == "\n") m = m + "\n";
         else if(termination == "\r") m = m + "\r";
         else m = m + "\r\n";
 
-        bytes = write(0, m.local8Bit(), strlen(m.local8Bit()));
+        bytes = ::write(m_fd, m.local8Bit(), strlen(m.local8Bit()));
         if(bytes < 0)
         {
                 reset();
         }
 }
 
 QString Dialer::receive()
 {
-        for(int i = 0; i < 200000;i++)
-                qApp->processEvents();
+        char buffer[1024];
+        int ret;
+
+        while(1)
+        {
+                ret = ::read(m_fd, buffer, sizeof(buffer));
+
+                if(ret > 0)
+                {
+                        for(int i = 0; i < ret; i++)
+                                buffer[i] = buffer[i] & 0x7F;
+                        buffer[ret] = 0;
+                        qWarning("Receiving: '%s'", buffer);
+                        return QString(buffer);
+                }
+                else if(ret < 0)
+                {
+                        if(errno != EAGAIN) reset();
+                }
+        }
+
+        //for(int i = 0; i < 200000;i++)
+                //qApp->processEvents();
         return QString::null;
 }
 
 void Dialer::switchState(int newstate)
 {
         int oldstate = state;
         state = newstate;
 
         switch(state)
         {
                 case state_cancel:
                         status->setText(QObject::tr("Cancelling..."));
                         progress->setProgress(0);
                         break;
                 case state_preinit:
                         status->setText(QObject::tr("Searching modem"));
diff --git a/noncore/apps/opie-console/dialer.h b/noncore/apps/opie-console/dialer.h
index 09cc5ca..4011880 100644
--- a/noncore/apps/opie-console/dialer.h
+++ b/noncore/apps/opie-console/dialer.h
@@ -1,51 +1,52 @@
 #ifndef DIALER_H
 #define DIALER_H
 
 #include <qdialog.h>
 
 #include "profile.h"
 
 class QLabel;
 class QProgressBar;
 
 class Dialer : public QDialog
 {
         Q_OBJECT
         public:
-                Dialer(const Profile& profile, QWidget *parent = NULL, const char *name = NULL);
+                Dialer(const Profile& profile, int fd, QWidget *parent = NULL, const char *name = NULL);
                 ~Dialer();
 
         public slots:
                 void slotCancel();
                 void slotAutostart();
 
         private:
                 void switchState(int newstate);
                 void reset();
                 void dial(const QString& number);
                 void trydial(const QString& number);
 
                 void send(const QString& msg);
                 QString receive();
 
                 enum States
                 {
                         state_cancel,
                         state_preinit,
                         state_init,
                         state_options,
                         state_dialtone,
                         state_dialing,
                         state_online
                 };
 
                 QLabel *status;
                 QProgressBar *progress;
                 QPushButton *cancel;
                 int state;
                 int usercancel;
                 const Profile& m_profile;
+                int m_fd;
 };
 
 #endif
 
diff --git a/noncore/apps/opie-console/io_modem.cpp b/noncore/apps/opie-console/io_modem.cpp
index 41f553b..c04aad1 100644
--- a/noncore/apps/opie-console/io_modem.cpp
+++ b/noncore/apps/opie-console/io_modem.cpp
@@ -11,33 +11,33 @@ IOModem::IOModem( const Profile &profile )
 
 IOModem::~IOModem() {
 
 }
 
 
 void IOModem::close() {
         // maybe do a hangup here just in case...?
 
     IOSerial::close();
 }
 
 bool IOModem::open() {
     bool ret = IOSerial::open();
         if(!ret) return false;
 
-        Dialer d(m_profile);
+        Dialer d(m_profile, rawIO());
 
         int result = d.exec();
         if(result == QDialog::Accepted)
         {
                 return true;
         }
         else
         {
                 close();
                 return false;
         }
 }
 
 void IOModem::reload( const Profile &config ) {
 
     m_device = config.readEntry("Device", MODEM_DEFAULT_DEVICE);