src/gras/Transport/transport.c

   1 /* $Id$ */
   2
   3 /* transport - low level communication                                      */
   4
   5 /* Authors: Martin Quinson                                                  */
   6 /* Copyright (C) 2004 Martin Quinson.                                       */
   7
   8 /* This program is free software; you can redistribute it and/or modify it
   9    under the terms of the license (GNU LGPL) which comes with this package. */
  10
  11 #include <time.h>       /* time() */
  12
  13 #include "Transport/transport_private.h"
  14
  15 GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(transport,GRAS);
  16
  17 static gras_dict_t  *_gras_trp_plugins;     /* All registered plugins */
  18 static void gras_trp_plugin_free(void *p); /* free one of the plugins */
  19
  20 static void gras_trp_socket_free(void *s); /* free one socket */
  21
  22 gras_error_t
  23 gras_trp_plugin_new(const char *name, gras_trp_setup_t setup);
  24
  25 gras_error_t
  26 gras_trp_plugin_new(const char *name, gras_trp_setup_t setup) {
  27   gras_error_t errcode;
  28
  29   gras_trp_plugin_t *plug = malloc(sizeof(gras_trp_plugin_t));
  30
  31   DEBUG1("Create plugin %s",name);
  32
  33   if (!plug)
  34     RAISE_MALLOC;
  35
  36   memset(plug,0,sizeof(gras_trp_plugin_t));
  37
  38   plug->name=strdup(name);
  39   if (!plug->name)
  40     RAISE_MALLOC;
  41
  42   errcode = setup(plug);
  43   switch (errcode) {
  44   case mismatch_error:
  45     /* SG plugin return mismatch when in RL mode (and vice versa) */
  46     free(plug->name);
  47     free(plug);
  48     break;
  49
  50   case no_error:
  51     TRY(gras_dict_set(_gras_trp_plugins,
  52                       name, plug, gras_trp_plugin_free));
  53     break;
  54
  55   default:
  56     free(plug);
  57     return errcode;
  58   }
  59   return no_error;
  60 }
  61
  62 gras_error_t
  63 gras_trp_init(void){
  64   gras_error_t errcode;
  65
  66   /* make room for all plugins */
  67   TRY(gras_dict_new(&_gras_trp_plugins));
  68
  69   /* Add them */
  70   TRY(gras_trp_plugin_new("tcp", gras_trp_tcp_setup));
  71   TRY(gras_trp_plugin_new("file",gras_trp_file_setup));
  72   TRY(gras_trp_plugin_new("sg",gras_trp_sg_setup));
  73
  74   return no_error;
  75 }
  76
  77 void
  78 gras_trp_exit(void){
  79   gras_dict_free(&_gras_trp_plugins);
  80 }
  81
  82
  83 void gras_trp_plugin_free(void *p) {
  84   gras_trp_plugin_t *plug = p;
  85
  86   if (plug) {
  87     if (plug->exit) {
  88       plug->exit(plug);
  89     } else if (plug->data) {
  90       DEBUG1("Plugin %s lacks exit(). Free data anyway.",plug->name);
  91       free(plug->data);
  92     }
  93
  94     free(plug->name);
  95     free(plug);
  96   }
  97 }
  98
  99
 100 /**
 101  * gras_trp_socket_new:
 102  *
 103  * Malloc a new socket, and initialize it with defaults
 104  */
 105 gras_error_t gras_trp_socket_new(int incoming,
 106                                  gras_socket_t **dst) {
 107
 108   gras_socket_t *sock;
 109
 110   if (! (sock=malloc(sizeof(gras_socket_t))) )
 111     RAISE_MALLOC;
 112   DEBUG1("Create a new socket (%p)", sock);
 113
 114   sock->plugin = NULL;
 115   sock->sd     = -1;
 116
 117   sock->incoming  = incoming ? 1:0;
 118   sock->outgoing  = incoming ? 0:1;
 119   sock->accepting = incoming ? 1:0;
 120
 121   sock->port      = -1;
 122   sock->peer_port = -1;
 123   sock->peer_name = NULL;
 124   sock->raw = 0;
 125
 126   *dst = sock;
 127
 128   return gras_dynar_push(gras_socketset_get(),dst);
 129 }
 130
 131
 132 /**
 133  * gras_socket_server:
 134  *
 135  * Opens a server socket and make it ready to be listened to.
 136  * In real life, you'll get a TCP socket.
 137  */
 138 gras_error_t
 139 gras_socket_server(unsigned short port,
 140                    /* OUT */ gras_socket_t **dst) {
 141
 142   gras_error_t errcode;
 143   gras_trp_plugin_t *trp;
 144   gras_socket_t *sock;
 145
 146   *dst = NULL;
 147
 148   DEBUG1("Create a server socket from plugin %s",gras_if_RL() ? "tcp" : "sg");
 149   TRY(gras_trp_plugin_get_by_name(gras_if_RL() ? "tcp" : "sg",
 150                                   &trp));
 151
 152   /* defaults settings */
 153   TRY(gras_trp_socket_new(1,&sock));
 154   sock->plugin= trp;
 155   sock->port=port;
 156
 157   /* Call plugin socket creation function */
 158   errcode = trp->socket_server(trp, port, sock);
 159   DEBUG3("in=%c out=%c accept=%c",
 160          sock->incoming?'y':'n',
 161          sock->outgoing?'y':'n',
 162          sock->accepting?'y':'n');
 163
 164   if (errcode != no_error) {
 165     free(sock);
 166     return errcode;
 167   }
 168
 169   *dst = sock;
 170
 171   return no_error;
 172 }
 173
 174 /**
 175  * gras_socket_client:
 176  *
 177  * Opens a client socket to a remote host.
 178  * In real life, you'll get a TCP socket.
 179  */
 180 gras_error_t
 181 gras_socket_client(const char *host,
 182                    unsigned short port,
 183                    /* OUT */ gras_socket_t **dst) {
 184
 185   gras_error_t errcode;
 186   gras_trp_plugin_t *trp;
 187   gras_socket_t *sock;
 188
 189   *dst = NULL;
 190
 191   TRY(gras_trp_plugin_get_by_name(gras_if_RL() ? "tcp" : "sg",
 192                                   &trp));
 193
 194   DEBUG1("Create a client socket from plugin %s",gras_if_RL() ? "tcp" : "sg");
 195   /* defaults settings */
 196   TRY(gras_trp_socket_new(0,&sock));
 197   sock->plugin= trp;
 198   sock->peer_port = port;
 199   sock->peer_name = strdup(host?host:"localhost");
 200
 201   /* plugin-specific */
 202   errcode= (* trp->socket_client)(trp,
 203                                   host ? host : "localhost", port,
 204                                   sock);
 205   DEBUG3("in=%c out=%c accept=%c",
 206          sock->incoming?'y':'n',
 207          sock->outgoing?'y':'n',
 208          sock->accepting?'y':'n');
 209
 210   if (errcode != no_error) {
 211     free(sock);
 212     return errcode;
 213   }
 214
 215   *dst = sock;
 216
 217   return no_error;
 218 }
 219
 220 void gras_socket_close(gras_socket_t *sock) {
 221   gras_dynar_t *sockets = gras_socketset_get();
 222   gras_socket_t *sock_iter;
 223   int cursor;
 224
 225   /* FIXME: Issue an event when the socket is closed */
 226   if (sock) {
 227     gras_dynar_foreach(sockets,cursor,sock_iter) {
 228       if (sock == sock_iter) {
 229         gras_dynar_cursor_rm(sockets,&cursor);
 230         if ( sock->plugin->socket_close)
 231           (* sock->plugin->socket_close)(sock);
 232
 233         /* free the memory */
 234         if (sock->peer_name)
 235           free(sock->peer_name);
 236         free(sock);
 237         return;
 238       }
 239     }
 240     WARN0("Ignoring request to free an unknown socket");
 241   }
 242 }
 243
 244 /**
 245  * gras_trp_chunk_send:
 246  *
 247  * Send a bunch of bytes from on socket
 248  */
 249 gras_error_t
 250 gras_trp_chunk_send(gras_socket_t *sd,
 251                     char *data,
 252                     size_t size) {
 253   gras_assert1(sd->outgoing,
 254                "Socket not suited for data send (outgoing=%c)",
 255                sd->outgoing?'y':'n');
 256   gras_assert1(sd->plugin->chunk_send,
 257                "No function chunk_send on transport plugin %s",
 258                sd->plugin->name);
 259   return (*sd->plugin->chunk_send)(sd,data,size);
 260 }
 261 /**
 262  * gras_trp_chunk_recv:
 263  *
 264  * Receive a bunch of bytes from a socket
 265  */
 266 gras_error_t
 267 gras_trp_chunk_recv(gras_socket_t *sd,
 268                     char *data,
 269                     size_t size) {
 270   gras_assert0(sd->incoming,
 271                "Socket not suited for data receive");
 272   gras_assert1(sd->plugin->chunk_recv,
 273                "No function chunk_recv on transport plugin %s",
 274                sd->plugin->name);
 275   return (sd->plugin->chunk_recv)(sd,data,size);
 276 }
 277
 278
 279 gras_error_t
 280 gras_trp_plugin_get_by_name(const char *name,
 281                             gras_trp_plugin_t **dst){
 282
 283   return gras_dict_get(_gras_trp_plugins,name,(void**)dst);
 284 }
 285
 286 int   gras_socket_my_port  (gras_socket_t *sock) {
 287   return sock->port;
 288 }
 289 int   gras_socket_peer_port(gras_socket_t *sock) {
 290   return sock->peer_port;
 291 }
 292 char *gras_socket_peer_name(gras_socket_t *sock) {
 293   return sock->peer_name;
 294 }