src/ecore_con/rb_server.c

   1 /*
   2  * $Id: rb_server.c 366 2006-02-14 21:53:15Z tilman $
   3  *
   4  * Copyright (C) 2005 ruby-ecore team (see AUTHORS)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <ruby.h>
  22
  23 #include <Ecore.h>
  24 #include <Ecore_Con.h>
  25 #include <stdbool.h>
  26
  27 #include "../ecore/rb_event_handler.h"
  28
  29 #define CHECK_DELETED(s) \
  30         if (s->deleted) \
  31                 rb_raise (rb_eIOError, "server deleted");
  32
  33 typedef struct {
  34         Ecore_Con_Server *real;
  35         bool deleted;
  36 } RbServer;
  37
  38 static void c_free (RbServer *svr)
  39 {
  40         if (svr->real && !svr->deleted)
  41                 ecore_con_server_del (svr->real);
  42
  43         ecore_con_shutdown ();
  44
  45         free (svr);
  46 }
  47
  48 static VALUE c_alloc (VALUE klass)
  49 {
  50         RbServer *svr = NULL;
  51
  52         return Data_Make_Struct (klass, RbServer, NULL, c_free, svr);
  53 }
  54
  55 static VALUE c_init (VALUE self, VALUE type, VALUE host, VALUE port)
  56 {
  57         RbServer *svr = NULL;
  58
  59         Check_Type (type, T_FIXNUM);
  60         StringValue (host);
  61         Check_Type (port, T_FIXNUM);
  62
  63         Data_Get_Struct (self, RbServer, svr);
  64
  65         ecore_con_init ();
  66
  67         svr->deleted = false;
  68         svr->real = ecore_con_server_connect (FIX2INT (type),
  69                                               StringValuePtr (host),
  70                                               FIX2INT (port), (void *) self);
  71         if (!svr->real)
  72                 rb_raise (rb_eIOError, "cannot create Server");
  73
  74         return self;
  75 }
  76
  77 static VALUE c_write (VALUE self, VALUE data)
  78 {
  79         RbServer *svr;
  80         int n;
  81
  82         StringValue (data);
  83
  84         Data_Get_Struct (self, RbServer, svr);
  85         CHECK_DELETED (svr);
  86
  87         n = ecore_con_server_send (svr->real,
  88                                    StringValuePtr (data),
  89                                    RSTRING (data)->len);
  90         if (!n)
  91                 rb_raise (rb_eIOError, "couldn't write data");
  92         else
  93                 return INT2FIX (n);
  94 }
  95
  96 /*
  97  * call-seq:
  98  *  server.delete => nil
  99  *
 100  * Deletes <i>server</i>.
 101  */
 102 static VALUE c_delete (VALUE self)
 103 {
 104         RbServer *svr = NULL;
 105
 106         Data_Get_Struct (self, RbServer, svr);
 107         CHECK_DELETED (svr);
 108
 109         ecore_con_server_del (svr->real);
 110         svr->deleted = true;
 111         svr->real = NULL;
 112
 113         return self;
 114 }
 115
 116 static VALUE find_server (Ecore_Con_Server *c)
 117 {
 118         /* FIXME what if the Ruby object has been destroyed already? */
 119         return (VALUE) ecore_con_server_data_get (c);
 120 }
 121
 122 static VALUE c_ev_server_add_init (VALUE self, VALUE event)
 123 {
 124         VALUE c = CLASS_OF (self), server;
 125         Ecore_Con_Event_Server_Add *e = (void *) event;
 126
 127         server = find_server (e->server);
 128         if (NIL_P (server))
 129                 rb_bug ("cannot find server");
 130
 131         rb_define_attr (c, "server", 1, 0);
 132
 133         rb_iv_set (self, "@server", server);
 134
 135         return self;
 136 }
 137
 138 static VALUE c_ev_server_del_init (VALUE self, VALUE event)
 139 {
 140         VALUE c = CLASS_OF (self), server;
 141         Ecore_Con_Event_Server_Del *e = (void *) event;
 142
 143         server = find_server (e->server);
 144         if (NIL_P (server))
 145                 rb_bug ("cannot find server");
 146
 147         rb_define_attr (c, "server", 1, 0);
 148
 149         rb_iv_set (self, "@server", server);
 150
 151         return self;
 152 }
 153
 154 static VALUE c_ev_server_data_init (VALUE self, VALUE event)
 155 {
 156         VALUE c = CLASS_OF (self), server;
 157         Ecore_Con_Event_Server_Data *e = (void *) event;
 158
 159         server = find_server (e->server);
 160         if (NIL_P (server))
 161                 rb_bug ("cannot find server");
 162
 163         rb_define_attr (c, "server", 1, 0);
 164         rb_define_attr (c, "data", 1, 0);
 165
 166         rb_iv_set (self, "@server", server);
 167         rb_iv_set (self, "@data", rb_str_new (e->data, e->size));
 168
 169         return self;
 170 }
 171
 172 void Init_Server (VALUE m)
 173 {
 174         VALUE c = rb_define_class_under (m, "Server", rb_cObject);
 175
 176         rb_define_alloc_func (c, c_alloc);
 177         rb_define_method (c, "initialize", c_init, 3);
 178         rb_define_method (c, "write", c_write, 1);
 179         rb_define_alias (c, "<<", "write");
 180         rb_define_method (c, "delete", c_delete, 0);
 181
 182         ADD_EVENT (m, ECORE_CON_EVENT_SERVER_ADD, "ServerAddEvent", c);
 183         rb_define_private_method (c, "initialize",
 184                                   c_ev_server_add_init, 1);
 185
 186         ADD_EVENT (m, ECORE_CON_EVENT_SERVER_DATA, "ServerDataEvent", c);
 187         rb_define_private_method (c, "initialize",
 188                                   c_ev_server_data_init, 1);
 189
 190         ADD_EVENT (m, ECORE_CON_EVENT_SERVER_DEL, "ServerDelEvent", c);
 191         rb_define_private_method (c, "initialize",
 192                                   c_ev_server_del_init, 1);
 193 }