src/miranda/miranda-input.c

   1 /**
   2  * @file miranda-input.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-11 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22 #include <windows.h>
  23 #include <stdio.h>
  24
  25 #include <glib.h>
  26
  27 #include "sipe-backend.h"
  28
  29 #include "newpluginapi.h"
  30 #include "m_protosvc.h"
  31 #include "m_protoint.h"
  32 #include "m_netlib.h"
  33 #include "miranda-private.h"
  34
  35 #define ENTRY_SIG 0x88442211
  36
  37 static NETLIBSELECTEX m_select = {0};
  38 static GHashTable *m_readhash = NULL;
  39 static GHashTable *m_writehash = NULL;
  40 static GList *m_entries = NULL;
  41
  42 typedef struct sipe_miranda_sel_entry
  43 {
  44         int sig;
  45         HANDLE fd;
  46         sipe_miranda_input_function func;
  47         gpointer user_data;
  48
  49         /* Private. For locking only */
  50         HANDLE hDoneEvent;
  51         gint source;
  52         sipe_miranda_input_condition cond;
  53 };
  54
  55 static void __stdcall
  56 input_cb_async(void *data)
  57 {
  58         struct sipe_miranda_sel_entry *entry = (struct sipe_miranda_sel_entry*)data;
  59         if (entry->fd == NULL)
  60         {
  61                 SIPE_DEBUG_INFO("Entry <%08x> already removed. Not calling read/write function", entry);
  62         } else {
  63                 SIPE_DEBUG_INFO("Calling real read/write function for entry <%08x>", entry);
  64                 entry->func(entry->user_data, entry->source, entry->cond);
  65         }
  66         SetEvent(entry->hDoneEvent);
  67 }
  68
  69 static unsigned __stdcall
  70 inputloop(void* data)
  71 {
  72         int cnt;
  73         struct sipe_miranda_sel_entry *entry;
  74         INT_PTR lstRes;
  75
  76         m_select.cbSize = sizeof(m_select);
  77         m_select.dwTimeout = 6000;
  78
  79         while( m_select.hReadConns[0] || m_select.hWriteConns[0])
  80         {
  81
  82                 SIPE_DEBUG_INFO_NOFORMAT("About to run select");
  83                 lstRes = CallService(MS_NETLIB_SELECTEX, 0, (LPARAM)&m_select);
  84                 if (lstRes < 0)
  85                 {
  86                         SIPE_DEBUG_INFO_NOFORMAT("Connection failed while waiting.");
  87                         break;
  88                 }
  89                 else if (lstRes == 0)
  90                 {
  91                         SIPE_DEBUG_INFO_NOFORMAT("Select Timeout.");
  92                 }
  93                 else
  94                 {
  95                         SIPE_DEBUG_INFO_NOFORMAT("Back from select");
  96
  97                         for ( cnt=0 ; m_select.hReadConns[cnt] ; cnt++ )
  98                         {
  99                                 if (!m_select.hReadStatus[cnt]) continue;
 100                                 SIPE_DEBUG_INFO("FD at position <%d> ready to read.", cnt);
 101                                 entry = (struct sipe_miranda_sel_entry*)g_hash_table_lookup(m_readhash, (gconstpointer)m_select.hReadConns[cnt]);
 102                                 if (!entry)
 103                                 {
 104                                         SIPE_DEBUG_INFO_NOFORMAT("ERROR: no read handler found.");
 105                                         continue;
 106                                 }
 107                                 SIPE_DEBUG_INFO_NOFORMAT("About to call read function.");
 108                                 entry->source = (gint)m_select.hReadConns[cnt];
 109                                 entry->cond = SIPE_MIRANDA_INPUT_READ;
 110                                 entry->hDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 111                                 CallFunctionAsync(input_cb_async, entry);
 112                                 WaitForSingleObject(entry->hDoneEvent, INFINITE);
 113                                 CloseHandle(entry->hDoneEvent);
 114                                 SIPE_DEBUG_INFO_NOFORMAT("read function returned.");
 115                         }
 116
 117                         for ( cnt=0 ; m_select.hWriteConns[cnt] ; cnt++ )
 118                         {
 119                                 if (!m_select.hWriteStatus[cnt]) continue;
 120                                 SIPE_DEBUG_INFO("FD at position <%d> ready to write.", cnt);
 121                                 entry = (struct sipe_miranda_sel_entry*)g_hash_table_lookup(m_writehash, (gconstpointer)m_select.hWriteConns[cnt]);
 122                                 if (!entry)
 123                                 {
 124                                         SIPE_DEBUG_INFO_NOFORMAT("ERROR: no write handler found.");
 125                                         continue;
 126                                 }
 127                                 SIPE_DEBUG_INFO_NOFORMAT("About to call write function.");
 128                                 entry->source = (gint)m_select.hWriteConns[cnt];
 129                                 entry->cond = SIPE_MIRANDA_INPUT_WRITE;
 130                                 entry->hDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 131                                 CallFunctionAsync(input_cb_async, entry);
 132                                 WaitForSingleObject(entry->hDoneEvent, INFINITE);
 133                                 CloseHandle(entry->hDoneEvent);
 134                                 SIPE_DEBUG_INFO_NOFORMAT("write function returned.");
 135                         }
 136                 }
 137
 138                 /* Free all removed entries */
 139                 while (m_entries) g_list_delete_link(m_entries, g_list_last(m_entries));
 140         }
 141
 142         return 0;
 143 }
 144
 145 struct sipe_miranda_sel_entry*
 146 sipe_miranda_input_add(HANDLE fd, sipe_miranda_input_condition cond, sipe_miranda_input_function func, gpointer user_data)
 147 {
 148         int rcnt = 0;
 149         int wcnt = 0;
 150         struct sipe_miranda_sel_entry *entry;
 151
 152         if (!m_readhash)
 153                 m_readhash = g_hash_table_new(NULL, NULL);
 154
 155         if (!m_writehash)
 156                 m_writehash = g_hash_table_new(NULL, NULL);
 157
 158         if ((cond != SIPE_MIRANDA_INPUT_READ) && (cond != SIPE_MIRANDA_INPUT_WRITE))
 159         {
 160                 SIPE_DEBUG_INFO("Invalid input condition <%d> cond.", cond);
 161                 return 0;
 162         }
 163
 164         entry = g_new0(struct sipe_miranda_sel_entry,1);
 165         entry->sig = ENTRY_SIG;
 166         entry->func = func;
 167         entry->user_data = user_data;
 168         entry->fd = fd;
 169
 170         if (cond == SIPE_MIRANDA_INPUT_READ)
 171         {
 172                 for ( rcnt=0 ; m_select.hReadConns[rcnt] && m_select.hReadConns[rcnt]!=(HANDLE)fd ; rcnt++ );
 173                 m_select.hReadConns[rcnt] = (HANDLE)fd;
 174                 g_hash_table_replace( m_readhash, (gpointer)fd, entry );
 175         }
 176         else if (cond == SIPE_MIRANDA_INPUT_WRITE)
 177         {
 178                 for ( wcnt=0 ; m_select.hWriteConns[wcnt] && m_select.hWriteConns[wcnt]!=(HANDLE)fd ; wcnt++ );
 179                 m_select.hWriteConns[rcnt] = (HANDLE)fd;
 180                 g_hash_table_replace( m_writehash, (gpointer)fd, entry );
 181         }
 182
 183         if (!(rcnt+wcnt))
 184                 CloseHandle((HANDLE) mir_forkthreadex( inputloop, NULL, 8192, NULL ));
 185
 186         SIPE_DEBUG_INFO_NOFORMAT("Added input handler.");
 187         return entry;
 188 }
 189
 190 gboolean
 191 sipe_miranda_input_remove(struct sipe_miranda_sel_entry *entry)
 192 {
 193         int cnt;
 194
 195         if (!entry)
 196         {
 197                 SIPE_DEBUG_INFO_NOFORMAT("Not a valid entry. NULL.");
 198                 return FALSE;
 199         }
 200
 201         if (entry->sig != ENTRY_SIG)
 202         {
 203                 SIPE_DEBUG_INFO("Not a valid entry. Sig is <%08x>.", entry->sig);
 204                 return FALSE;
 205         }
 206
 207         if (g_hash_table_lookup(m_readhash, (gconstpointer)entry->fd) == entry)
 208         {
 209                 for ( cnt=0 ; m_select.hReadConns[cnt] && m_select.hReadConns[cnt]!=(HANDLE)entry->fd ; cnt++ );
 210                 for ( ; m_select.hReadConns[cnt] ; cnt++ ) m_select.hReadConns[cnt] = m_select.hReadConns[cnt+1];
 211                 g_hash_table_remove(m_readhash, (gconstpointer)entry->fd);
 212         }
 213
 214         if (g_hash_table_lookup(m_writehash, (gconstpointer)entry->fd) == entry)
 215         {
 216                 for ( cnt=0 ; m_select.hWriteConns[cnt] && m_select.hWriteConns[cnt]!=(HANDLE)entry->fd ; cnt++ );
 217                 for ( ; m_select.hWriteConns[cnt] ; cnt++ ) m_select.hWriteConns[cnt] = m_select.hWriteConns[cnt+1];
 218                 g_hash_table_remove(m_writehash, (gconstpointer)entry->fd);
 219         }
 220
 221         /* Set fd to NULL so we won't try to call the callback if we're
 222            currently waiting to get back to the main thread */
 223         entry->fd = NULL;
 224
 225         /* Add it to the list of entries that can be freed after the next select
 226          * loop in the thread that's handling the actual select
 227          */
 228         g_list_append( m_entries, entry );
 229
 230         return TRUE;
 231 }
 232
 233
 234
 235 /*
 236   Local Variables:
 237   mode: c
 238   c-file-style: "bsd"
 239   indent-tabs-mode: t
 240   tab-width: 8
 241   End:
 242 */