socket.cpp

/*- A Graphic Remote Control Utility for Klaus Schidinger's vdr (www.cadsoft.de/vdr)

                Copyright (C)2006 Peter Marquardt p_marquardt@users.sourceforge.net
 */
/*
                This program is free software; you can redistribute it and/or modify
                it under the terms of the GNU General Public License as published by
                the Free Software Foundation; either version 2 of the License, or
                (at your option) any later version.

                This program is distributed in the hope that it will be useful,
                but WITHOUT ANY WARRANTY; without even the implied warranty of
                MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                GNU General Public License for more details.

                You should have received a copy of the GNU General Public License
                along with this program; if not, write to the Free Software
                Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
                
                
#include <wx/tokenzr.h>
#include "vdr_remote.h"


void vdr_remoteFrame::OnSocketEvent(wxSocketEvent& event)
{
        
        switch (event.GetSocketEvent())
        {
                case wxSOCKET_LOST:
                        wxMessageBox( wxT( "Lost Socket connection." ), wxT( "Socket error" ), wxOK | wxICON_INFORMATION, this );
                        connection_is_alive = false;

                
                        break;
                case wxSOCKET_INPUT:
                {
                        if (socket_data_needed) 
                        {
                                socket_data_available = false;
                                if (my_socket_buffer) delete[] my_socket_buffer;
                                my_socket_buffer = new char[1024];
                                vdr_client->Read(my_socket_buffer, 1024);
                                if (vdr_client->LastCount()) 
                                {       
                                        socket_data_available = true;
                                        my_socket_buffer[vdr_client->LastCount()] = '\0';
                                                                                
                                }
                        }
                        else if (show_socket_viewer)
                        {
                                char temp_buffer[1024];
                                vdr_client->Read(temp_buffer, 1024);
                                if (vdr_client->LastCount()) 
                                {
                                        wxString returned_data;
                                        temp_buffer[vdr_client->LastCount()] = '\0';
                                        returned_data.Append(wxString(temp_buffer, wxConvLocal)); 
                                        socket_viewer->AppendText(returned_data);
                                }
                                socket_data_available = false;
                        }
                }
                        break;
                case wxSOCKET_CONNECTION:
                        connection_is_alive = true;
                        break;
                default:
                        break;
        }
}

void vdr_remoteFrame::Connect()
{

        
        if (connection_is_alive && vdr_client->IsConnected()) return;
        if (num_connection_failures > 5)
        {
                wxMessageBox( wxT( "Connecting failed too often, please check the preferences." ), wxT( "Socket error" ), wxOK | wxICON_INFORMATION, this );
                num_connection_failures = 0;
                SetStatusText(wxT("Connection failed."));
                return; 
        }

        
        vdr_adress.Hostname(vdr_host);
        vdr_adress.Service( vdr_port);
        SetStatusText(wxT("Connecting... timeout 5 secs "));
        vdr_client->Connect(vdr_adress,false);
        vdr_client->WaitOnConnect(5);
        if (vdr_client->IsConnected()) 
        {
                connection_is_alive = true;
                num_connection_failures = 0;
        }
        else
        {
                vdr_client->Close();
                SetStatusText(wxT("Connection failed."));
                connection_is_alive = false;
                num_connection_failures++;
        }
}
void vdr_remoteFrame::Disconnect()
{

        if ( vdr_client->IsConnected() && vdr_client->Ok()) 
        {
                SendMessage( "QUIT");
                
        }
        vdr_client->Close();
        connection_is_alive = false;
        socket_data_available = false;
        socket_data_needed = false;
        SetStatusText(wxT("Ready."));
}

void vdr_remoteFrame::GetDiskStat(wxCommandEvent& event)
{
        Connect();
        if (!vdr_client->IsConnected()) return; //Disconnected means serious trouble we can't fix here so we step out early
        const char* the_msg = "stat disk";
        unsigned char len = (unsigned char)((strlen(the_msg) + 1) * sizeof(char));
        socket_data_needed = true;
        vdr_client->Write(the_msg,len );
        SetStatusText(wxT("Gettin Disk status."));
        vdr_client->WaitForRead(0,disk_status_timeout);
        if (socket_data_available ) //checking my_socket_buffer seems superfluous (sp?)  my_socket_buffer && 
        {
                wxString returned_message,input_string;
                input_string = wxString(my_socket_buffer, wxConvLocal);
                if (!input_string ) return;
                wxStringTokenizer tkz(input_string, wxT("\r\n"));
                while ( tkz.HasMoreTokens() )
                {
                        wxString token = tkz.GetNextToken();
                        wxString temp_message;
                        if (token.StartsWith(wxT("250 "),&temp_message) )
                        {
                                wxStringTokenizer mtkz(temp_message, wxT(" "));
                                int i = 0;
                                while (mtkz.HasMoreTokens())
                                {
                                        wxString data_entry = mtkz.GetNextToken();
                                        switch (i)  
                                        {
                                                case 0:
                                                {
                                                        long size_in_mb;
                                                        data_entry.ToLong(&size_in_mb);
                                                        data_entry = wxT("Total size: ");
                                                        data_entry << (size_in_mb/1024);
                                                        data_entry.Append(wxT(" GB\n"));
                                                }
                                                        break;
                                                case 1:
                                                {
                                                        long size_in_mb;
                                                        data_entry.ToLong(&size_in_mb);
                                                        data_entry = wxT("Free Space: ");
                                                        data_entry << (size_in_mb/1024);
                                                        data_entry.Append(wxT(" GB\n"));
                                                }
                                                        break;
                                                case 2:
                                                        data_entry.Append(wxT(" used\n"));
                                                        break;
                                                default:
                                                        data_entry = wxT("");
                                                        break;
                                        }
                                        i++;
                                        returned_message.Append(data_entry);
                                }                                       
                        }
                }
                wxMessageBox( returned_message, wxT( "Disk status" ), wxOK | wxICON_INFORMATION, this );
        }
        socket_data_needed = false;
        Disconnect();
}


void vdr_remoteFrame::SendMessage(const char * the_msg) 
{

        unsigned char len;
        bool get_data = socket_data_needed;
        socket_data_needed = false;
        len  = (unsigned char)((strlen(the_msg) + 1) * sizeof(char));
        if (!vdr_client->IsConnected())
        {
                Disconnect();
                Connect();
        }
        if (vdr_client->IsConnected()) 
        {
                socket_data_needed = get_data;
                vdr_client->Write(the_msg, len);
                if (vdr_client->Error()) 
                {
                        SetStatusText(wxT("Writing to Socket failed"));
                }
                socket_data_needed = false;
        }
}

---