echld/echld-util.c

   1 /* echld-util.c
   2  *  utility for echld
   3  *
   4  * Wireshark - Network traffic analyzer
   5  * By Gerald Combs <gerald@wireshark.org>
   6  * Copyright 1998 Gerald Combs
   7  *
   8  * Copyright (c) 2013 by Luis Ontanon <luis@ontanon.org>
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  23  */
  24
  25 #include "config.h"
  26
  27 #include "echld-int.h"
  28 #include "echld-util.h"
  29
  30 #include <glib.h>
  31
  32 struct _ping {
  33         struct timeval tv;
  34         echld_ping_cb_t cb;
  35         void* cb_data;
  36 };
  37
  38 static long timevaldiff(struct timeval *starttime, struct timeval *finishtime) {
  39   long msec;
  40   msec=(finishtime->tv_sec-starttime->tv_sec)*1000;
  41   msec+=(finishtime->tv_usec-starttime->tv_usec)/1000;
  42   return msec;
  43 }
  44
  45 static gboolean pong(echld_msg_type_t type, GByteArray* ba _U_, void* data) {
  46         struct _ping* p = (struct _ping*)data;
  47         struct timeval t;
  48         long ret = -1;
  49         gettimeofday(&t,NULL);
  50
  51
  52         switch (type) {
  53                 case ECHLD_PONG:
  54                         ret = timevaldiff(&(p->tv),&t);
  55                         break;
  56                 default:
  57                         ret = -1;
  58                         break;
  59         }
  60
  61         if (p->cb) p->cb(ret, p->cb_data);
  62
  63         g_free(p);
  64
  65         return TRUE;
  66 }
  67
  68
  69 extern echld_state_t echld_ping(int chld_id, echld_ping_cb_t pcb, void* cb_data) {
  70         struct _ping* p = g_new0(struct _ping,1);
  71
  72         p->cb = pcb;
  73         p->cb_data = cb_data;
  74         gettimeofday(&(p->tv),NULL);
  75
  76         return echld_reqh(chld_id, ECHLD_PING, 0, NULL, pong, p);
  77 }
  78
  79
  80 struct _get_param {
  81         const char* name;
  82         echld_param_cb_t cb;
  83         void* cb_data;
  84         echld_bool_t (*dec)(enc_msg_t*, char**, char**);
  85         echld_bool_t (*dec_err)(enc_msg_t*, int* , char**);
  86         const char** err_msg;
  87 };
  88
  89 #define CHNULL ((char*)NULL)
  90
  91 static gboolean got_param(echld_msg_type_t type, GByteArray* ba _U_, void* data) {
  92         struct _get_param* g = (struct _get_param*)data;
  93         char* err_msg;
  94
  95         switch (type) {
  96                 case ECHLD_PARAM:
  97                         if (g->cb) {
  98                                 char* param;
  99                                 char* value;
 100                                 g->dec(ba,&param,&value);
 101                                 g->cb(param,value,NULL,g->cb_data);
 102
 103                         }
 104                         break;
 105                 case ECHLD_ERROR: {
 106                         int errnum;
 107                         g->dec_err(ba,&errnum,&err_msg);
 108                         g->cb(NULL,NULL,err_msg,g->cb_data);
 109                         break;
 110                 }
 111                 default:
 112                         err_msg = g_strdup_printf("other type='%s'",TY(type));
 113                         g->cb(NULL,NULL,err_msg,g->cb_data);
 114                         g_free(err_msg);
 115                         break;
 116         }
 117
 118         g_free(g);
 119         return TRUE;
 120 }
 121
 122 extern echld_state_t echld_get_param(int chld_id, const char* param, echld_param_cb_t acb, void* cb_data) {
 123         struct _get_param* g = g_new0(struct _get_param,1);
 124         echld_parent_encoder_t* enc;
 125         parent_decoder_t* dec;
 126         enc_msg_t* em;
 127
 128         echld_get_all_codecs(NULL, NULL, &enc, &dec);
 129
 130         em = enc->get_param(param);
 131
 132         g->name = param;
 133         g->cb = acb;
 134         g->cb_data = cb_data;
 135         g->dec = dec->param;
 136         g->dec_err = dec->error;
 137
 138         return echld_reqh(chld_id, ECHLD_GET_PARAM, 0, em, got_param, g);
 139 }
 140
 141 extern echld_state_t echld_set_param(int chld_id, const char* param, const char* value, echld_param_cb_t acb, void* cb_data) {
 142         struct _get_param* g = g_new0(struct _get_param,1);
 143         echld_parent_encoder_t* enc;
 144         parent_decoder_t* dec;
 145         enc_msg_t* em;
 146
 147         echld_get_all_codecs(NULL, NULL, &enc, &dec);
 148
 149         em = enc->set_param(param,value);
 150
 151         g->name = param;
 152         g->cb = acb;
 153         g->cb_data = cb_data;
 154         g->dec = dec->param;
 155         g->dec_err = dec->error;
 156
 157         return echld_reqh(chld_id, ECHLD_SET_PARAM, 0, em, got_param, g);
 158 }
 159
 160 typedef struct _close {
 161         echld_close_cb_t cb;
 162         void* cb_data;
 163 } close_t;
 164
 165 static gboolean closed(echld_msg_type_t type, GByteArray* ba, void* data) {
 166         close_t* c = (close_t*)data;
 167         parent_decoder_t* dec;
 168         char* err_msg;
 169
 170         echld_get_all_codecs(NULL, NULL, NULL, &dec);
 171
 172         switch (type) {
 173                 case ECHLD_CLOSING: {
 174                         if (c->cb) {
 175                                 c->cb(NULL,c->cb_data);
 176                         }
 177                         break;
 178                 }
 179                 case ECHLD_ERROR: {
 180                         int errnum;
 181
 182                         if ( dec->error(ba, &errnum ,&err_msg) ) {
 183                                 c->cb(err_msg,c->cb_data);
 184                                 g_free(err_msg);
 185                         } else {
 186                                 c->cb("Canot decode error message",c->cb_data);
 187                         }
 188                         break;
 189                 }
 190                 default:
 191                         err_msg = g_strdup_printf("other type='%s'",TY(type));
 192                         c->cb(err_msg,c->cb_data);
 193                         g_free(err_msg);
 194                         break;
 195         }
 196
 197         g_free(c);
 198         return TRUE;
 199
 200 }
 201
 202 echld_state_t echld_close(int child_id, echld_close_cb_t pcb, void* cb_data) {
 203         close_t* c = g_new0(close_t,1);
 204         c->cb = pcb;
 205         c->cb_data = cb_data;
 206
 207         return echld_reqh(child_id,ECHLD_CLOSE_CHILD, 0, NULL, closed, c);
 208 }
 209
 210