code.delx.au - pulseaudio/blob - src/pulsecore/pdispatch.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of PulseAudio.
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   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 PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <assert.h>
  29
  30 #include <pulse/timeval.h>
  31 #include <pulse/xmalloc.h>
  32
  33 #include <pulsecore/native-common.h>
  34 #include <pulsecore/llist.h>
  35 #include <pulsecore/log.h>
  36 #include <pulsecore/core-util.h>
  37
  38 #include "pdispatch.h"
  39
  40 /*#define DEBUG_OPCODES */
  41
  42 #ifdef DEBUG_OPCODES
  43
  44 static const char *command_names[PA_COMMAND_MAX] = {
  45     [PA_COMMAND_ERROR] = "ERROR",
  46     [PA_COMMAND_TIMEOUT] = "TIMEOUT",
  47     [PA_COMMAND_REPLY] = "REPLY",
  48     [PA_COMMAND_CREATE_PLAYBACK_STREAM] = "CREATE_PLAYBACK_STREAM",
  49     [PA_COMMAND_DELETE_PLAYBACK_STREAM] = "DELETE_PLAYBACK_STREAM",
  50     [PA_COMMAND_CREATE_RECORD_STREAM] = "CREATE_RECORD_STREAM",
  51     [PA_COMMAND_DELETE_RECORD_STREAM] = "DELETE_RECORD_STREAM",
  52     [PA_COMMAND_AUTH] = "AUTH",
  53     [PA_COMMAND_REQUEST] = "REQUEST",
  54     [PA_COMMAND_EXIT] = "EXIT",
  55     [PA_COMMAND_SET_CLIENT_NAME] = "SET_CLIENT_NAME",
  56     [PA_COMMAND_LOOKUP_SINK] = "LOOKUP_SINK",
  57     [PA_COMMAND_LOOKUP_SOURCE] = "LOOKUP_SOURCE",
  58     [PA_COMMAND_DRAIN_PLAYBACK_STREAM] = "DRAIN_PLAYBACK_STREAM",
  59     [PA_COMMAND_PLAYBACK_STREAM_KILLED] = "PLAYBACK_STREAM_KILLED",
  60     [PA_COMMAND_RECORD_STREAM_KILLED] = "RECORD_STREAM_KILLED",
  61     [PA_COMMAND_STAT] = "STAT",
  62     [PA_COMMAND_GET_PLAYBACK_LATENCY] = "PLAYBACK_LATENCY",
  63     [PA_COMMAND_CREATE_UPLOAD_STREAM] = "CREATE_UPLOAD_STREAM",
  64     [PA_COMMAND_DELETE_UPLOAD_STREAM] = "DELETE_UPLOAD_STREAM",
  65     [PA_COMMAND_FINISH_UPLOAD_STREAM] = "FINISH_UPLOAD_STREAM",
  66     [PA_COMMAND_PLAY_SAMPLE] = "PLAY_SAMPLE",
  67     [PA_COMMAND_REMOVE_SAMPLE] = "REMOVE_SAMPLE",
  68     [PA_COMMAND_GET_SERVER_INFO] = "GET_SERVER_INFO",
  69     [PA_COMMAND_GET_SINK_INFO] = "GET_SINK_INFO",
  70     [PA_COMMAND_GET_SINK_INFO_LIST] = "GET_SINK_INFO_LIST",
  71     [PA_COMMAND_GET_SOURCE_INFO] = "GET_SOURCE_INFO",
  72     [PA_COMMAND_GET_SOURCE_INFO_LIST] = "GET_SOURCE_INFO_LIST",
  73     [PA_COMMAND_GET_MODULE_INFO] = "GET_MODULE_INFO",
  74     [PA_COMMAND_GET_MODULE_INFO_LIST] = "GET_MODULE_INFO_LIST",
  75     [PA_COMMAND_GET_CLIENT_INFO] = "GET_CLIENT_INFO",
  76     [PA_COMMAND_GET_CLIENT_INFO_LIST] = "GET_CLIENT_INFO_LIST",
  77     [PA_COMMAND_GET_SAMPLE_INFO] = "GET_SAMPLE_INFO",
  78     [PA_COMMAND_GET_SAMPLE_INFO_LIST] = "GET_SAMPLE_INFO_LIST",
  79     [PA_COMMAND_GET_SINK_INPUT_INFO] = "GET_SINK_INPUT_INFO",
  80     [PA_COMMAND_GET_SINK_INPUT_INFO_LIST] = "GET_SINK_INPUT_INFO_LIST",
  81     [PA_COMMAND_GET_SOURCE_OUTPUT_INFO] = "GET_SOURCE_OUTPUT_INFO",
  82     [PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST] = "GET_SOURCE_OUTPUT_INFO_LIST",
  83     [PA_COMMAND_SUBSCRIBE] = "SUBSCRIBE",
  84     [PA_COMMAND_SUBSCRIBE_EVENT] = "SUBSCRIBE_EVENT",
  85     [PA_COMMAND_SET_SINK_VOLUME] = "SET_SINK_VOLUME",
  86     [PA_COMMAND_SET_SINK_INPUT_VOLUME] = "SET_SINK_INPUT_VOLUME",
  87     [PA_COMMAND_SET_SOURCE_VOLUME] = "SET_SOURCE_VOLME",
  88     [PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = "TRIGGER_PLAYBACK_STREAM",
  89     [PA_COMMAND_FLUSH_PLAYBACK_STREAM] = "FLUSH_PLAYBACK_STREAM",
  90     [PA_COMMAND_CORK_PLAYBACK_STREAM] = "CORK_PLAYBACK_STREAM",
  91     [PA_COMMAND_GET_AUTOLOAD_INFO] = "GET_AUTOLOAD_INFO",
  92     [PA_COMMAND_GET_AUTOLOAD_INFO_LIST] = "GET_AUTOLOAD_INFO_LIST",
  93 };
  94
  95 #endif
  96
  97 struct reply_info {
  98     pa_pdispatch *pdispatch;
  99     PA_LLIST_FIELDS(struct reply_info);
 100     pa_pdispatch_cb_t callback;
 101     void *userdata;
 102     pa_free_cb_t free_cb;
 103     uint32_t tag;
 104     pa_time_event *time_event;
 105 };
 106
 107 struct pa_pdispatch {
 108     int ref;
 109     pa_mainloop_api *mainloop;
 110     const pa_pdispatch_cb_t *callback_table;
 111     unsigned n_commands;
 112     PA_LLIST_HEAD(struct reply_info, replies);
 113     pa_pdispatch_drain_callback drain_callback;
 114     void *drain_userdata;
 115     const pa_creds *creds;
 116 };
 117
 118 static void reply_info_free(struct reply_info *r) {
 119     assert(r && r->pdispatch && r->pdispatch->mainloop);
 120
 121     if (r->time_event)
 122         r->pdispatch->mainloop->time_free(r->time_event);
 123
 124     PA_LLIST_REMOVE(struct reply_info, r->pdispatch->replies, r);
 125
 126     pa_xfree(r);
 127 }
 128
 129 pa_pdispatch* pa_pdispatch_new(pa_mainloop_api *mainloop, const pa_pdispatch_cb_t*table, unsigned entries) {
 130     pa_pdispatch *pd;
 131     assert(mainloop);
 132
 133     assert((entries && table) || (!entries && !table));
 134
 135     pd = pa_xmalloc(sizeof(pa_pdispatch));
 136     pd->ref = 1;
 137     pd->mainloop = mainloop;
 138     pd->callback_table = table;
 139     pd->n_commands = entries;
 140     PA_LLIST_HEAD_INIT(pa_reply_info, pd->replies);
 141     pd->drain_callback = NULL;
 142     pd->drain_userdata = NULL;
 143     pd->creds = NULL;
 144
 145     return pd;
 146 }
 147
 148 static void pdispatch_free(pa_pdispatch *pd) {
 149     assert(pd);
 150
 151     while (pd->replies) {
 152         if (pd->replies->free_cb)
 153             pd->replies->free_cb(pd->replies->userdata);
 154
 155         reply_info_free(pd->replies);
 156     }
 157
 158     pa_xfree(pd);
 159 }
 160
 161 static void run_action(pa_pdispatch *pd, struct reply_info *r, uint32_t command, pa_tagstruct *ts) {
 162     pa_pdispatch_cb_t callback;
 163     void *userdata;
 164     uint32_t tag;
 165     assert(r);
 166
 167     pa_pdispatch_ref(pd);
 168
 169     callback = r->callback;
 170     userdata = r->userdata;
 171     tag = r->tag;
 172
 173     reply_info_free(r);
 174
 175     callback(pd, command, tag, ts, userdata);
 176
 177     if (pd->drain_callback && !pa_pdispatch_is_pending(pd))
 178         pd->drain_callback(pd, pd->drain_userdata);
 179
 180     pa_pdispatch_unref(pd);
 181 }
 182
 183 int pa_pdispatch_run(pa_pdispatch *pd, pa_packet*packet, const pa_creds *creds, void *userdata) {
 184     uint32_t tag, command;
 185     pa_tagstruct *ts = NULL;
 186     int ret = -1;
 187     assert(pd && packet && packet->data);
 188
 189     pa_pdispatch_ref(pd);
 190
 191     if (packet->length <= 8)
 192         goto finish;
 193
 194     ts = pa_tagstruct_new(packet->data, packet->length);
 195     assert(ts);
 196
 197     if (pa_tagstruct_getu32(ts, &command) < 0 ||
 198         pa_tagstruct_getu32(ts, &tag) < 0)
 199         goto finish;
 200
 201 #ifdef DEBUG_OPCODES
 202 {
 203     char t[256];
 204     char const *p;
 205     if (!(p = command_names[command]))
 206         snprintf((char*) (p = t), sizeof(t), "%u", command);
 207
 208     pa_log(__FILE__": Recieved opcode <%s>", p);
 209 }
 210 #endif
 211
 212     pd->creds = creds;
 213
 214     if (command == PA_COMMAND_ERROR || command == PA_COMMAND_REPLY) {
 215         struct reply_info *r;
 216
 217         for (r = pd->replies; r; r = r->next)
 218             if (r->tag == tag)
 219                 break;
 220
 221         if (r)
 222             run_action(pd, r, command, ts);
 223
 224     } else if (pd->callback_table && (command < pd->n_commands) && pd->callback_table[command]) {
 225         const pa_pdispatch_cb_t *c = pd->callback_table+command;
 226
 227         (*c)(pd, command, tag, ts, userdata);
 228     } else {
 229         pa_log(__FILE__": Recieved unsupported command %u", command);
 230         goto finish;
 231     }
 232
 233     ret = 0;
 234
 235 finish:
 236     pd->creds = NULL;
 237
 238     if (ts)
 239         pa_tagstruct_free(ts);
 240
 241     pa_pdispatch_unref(pd);
 242
 243     return ret;
 244 }
 245
 246 static void timeout_callback(pa_mainloop_api*m, pa_time_event*e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
 247     struct reply_info*r = userdata;
 248     assert(r && r->time_event == e && r->pdispatch && r->pdispatch->mainloop == m && r->callback);
 249
 250     run_action(r->pdispatch, r, PA_COMMAND_TIMEOUT, NULL);
 251 }
 252
 253 void pa_pdispatch_register_reply(pa_pdispatch *pd, uint32_t tag, int timeout, pa_pdispatch_cb_t cb, void *userdata, pa_free_cb_t free_cb) {
 254     struct reply_info *r;
 255     struct timeval tv;
 256     assert(pd && pd->ref >= 1 && cb);
 257
 258     r = pa_xmalloc(sizeof(struct reply_info));
 259     r->pdispatch = pd;
 260     r->callback = cb;
 261     r->userdata = userdata;
 262     r->free_cb = free_cb;
 263     r->tag = tag;
 264
 265     pa_gettimeofday(&tv);
 266     tv.tv_sec += timeout;
 267
 268     r->time_event = pd->mainloop->time_new(pd->mainloop, &tv, timeout_callback, r);
 269     assert(r->time_event);
 270
 271     PA_LLIST_PREPEND(struct reply_info, pd->replies, r);
 272 }
 273
 274 int pa_pdispatch_is_pending(pa_pdispatch *pd) {
 275     assert(pd);
 276
 277     return !!pd->replies;
 278 }
 279
 280 void pa_pdispatch_set_drain_callback(pa_pdispatch *pd, void (*cb)(pa_pdispatch *pd, void *userdata), void *userdata) {
 281     assert(pd);
 282     assert(!cb || pa_pdispatch_is_pending(pd));
 283
 284     pd->drain_callback = cb;
 285     pd->drain_userdata = userdata;
 286 }
 287
 288 void pa_pdispatch_unregister_reply(pa_pdispatch *pd, void *userdata) {
 289     struct reply_info *r, *n;
 290     assert(pd);
 291
 292     for (r = pd->replies; r; r = n) {
 293         n = r->next;
 294
 295         if (r->userdata == userdata)
 296             reply_info_free(r);
 297     }
 298 }
 299
 300 void pa_pdispatch_unref(pa_pdispatch *pd) {
 301     assert(pd && pd->ref >= 1);
 302
 303     if (!(--(pd->ref)))
 304         pdispatch_free(pd);
 305 }
 306
 307 pa_pdispatch* pa_pdispatch_ref(pa_pdispatch *pd) {
 308     assert(pd && pd->ref >= 1);
 309     pd->ref++;
 310     return pd;
 311 }
 312
 313 const pa_creds * pa_pdispatch_creds(pa_pdispatch *pd) {
 314     assert(pd);
 315     assert(pd->ref >= 1);
 316
 317     return pd->creds;
 318 }