code.delx.au - pulseaudio/blob - polyp/pdispatch.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of polypaudio.
   5
   6   polypaudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   polypaudio 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   General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with polypaudio; 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 "pdispatch.h"
  31 #include "native-common.h"
  32 #include "xmalloc.h"
  33 #include "llist.h"
  34 #include "log.h"
  35
  36 /*#define DEBUG_OPCODES*/
  37
  38 #ifdef DEBUG_OPCODES
  39
  40 static const char *command_names[PA_COMMAND_MAX] = {
  41     [PA_COMMAND_ERROR] = "ERROR",
  42     [PA_COMMAND_TIMEOUT] = "TIMEOUT",
  43     [PA_COMMAND_REPLY] = "REPLY",
  44     [PA_COMMAND_CREATE_PLAYBACK_STREAM] = "CREATE_PLAYBACK_STREAM",
  45     [PA_COMMAND_DELETE_PLAYBACK_STREAM] = "DELETE_PLAYBACK_STREAM",
  46     [PA_COMMAND_CREATE_RECORD_STREAM] = "CREATE_RECORD_STREAM",
  47     [PA_COMMAND_DELETE_RECORD_STREAM] = "DELETE_RECORD_STREAM",
  48     [PA_COMMAND_AUTH] = "AUTH",
  49     [PA_COMMAND_REQUEST] = "REQUEST",
  50     [PA_COMMAND_EXIT] = "EXIT",
  51     [PA_COMMAND_SET_NAME] = "SET_NAME",
  52     [PA_COMMAND_LOOKUP_SINK] = "LOOKUP_SINK",
  53     [PA_COMMAND_LOOKUP_SOURCE] = "LOOKUP_SOURCE",
  54     [PA_COMMAND_DRAIN_PLAYBACK_STREAM] = "DRAIN_PLAYBACK_STREAM",
  55     [PA_COMMAND_PLAYBACK_STREAM_KILLED] = "PLAYBACK_STREAM_KILLED",
  56     [PA_COMMAND_RECORD_STREAM_KILLED] = "RECORD_STREAM_KILLED",
  57     [PA_COMMAND_STAT] = "STAT",
  58     [PA_COMMAND_GET_PLAYBACK_LATENCY] = "PLAYBACK_LATENCY",
  59     [PA_COMMAND_CREATE_UPLOAD_STREAM] = "CREATE_UPLOAD_STREAM",
  60     [PA_COMMAND_DELETE_UPLOAD_STREAM] = "DELETE_UPLOAD_STREAM",
  61     [PA_COMMAND_FINISH_UPLOAD_STREAM] = "FINISH_UPLOAD_STREAM",
  62     [PA_COMMAND_PLAY_SAMPLE] = "PLAY_SAMPLE",
  63     [PA_COMMAND_REMOVE_SAMPLE] = "REMOVE_SAMPLE",
  64     [PA_COMMAND_GET_SERVER_INFO] = "GET_SERVER_INFO",
  65     [PA_COMMAND_GET_SINK_INFO] = "GET_SET_INFO",
  66     [PA_COMMAND_GET_SINK_INPUT_INFO] = "GET_SINK_INPUT_INFO",
  67     [PA_COMMAND_SUBSCRIBE] = "SUBSCRIBE",
  68     [PA_COMMAND_SUBSCRIBE_EVENT] = "SUBSCRIBE_EVENT",
  69     [PA_COMMAND_SET_SINK_VOLUME] = "SET_SINK_VOLUME",
  70     [PA_COMMAND_SET_SINK_INPUT_VOLUME] = "SET_SINK_INPUT_VOLUME",
  71     [PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = "TRIGGER_PLAYBACK_STREAM",
  72     [PA_COMMAND_FLUSH_PLAYBACK_STREAM] = "FLUSH_PLAYBACK_STREAM",
  73     [PA_COMMAND_CORK_PLAYBACK_STREAM] = "CORK_PLAYBACK_STREAM",
  74
  75 };
  76
  77 #endif
  78
  79 struct reply_info {
  80     struct pa_pdispatch *pdispatch;
  81     PA_LLIST_FIELDS(struct reply_info);
  82     void (*callback)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
  83     void *userdata;
  84     uint32_t tag;
  85     struct pa_time_event *time_event;
  86 };
  87
  88 struct pa_pdispatch {
  89     int ref;
  90     struct pa_mainloop_api *mainloop;
  91     const struct pa_pdispatch_command *command_table;
  92     unsigned n_commands;
  93     PA_LLIST_HEAD(struct reply_info, replies);
  94     void (*drain_callback)(struct pa_pdispatch *pd, void *userdata);
  95     void *drain_userdata;
  96 };
  97
  98 static void reply_info_free(struct reply_info *r) {
  99     assert(r && r->pdispatch && r->pdispatch->mainloop);
 100
 101     if (r->time_event)
 102         r->pdispatch->mainloop->time_free(r->time_event);
 103
 104     PA_LLIST_REMOVE(struct reply_info, r->pdispatch->replies, r);
 105
 106     pa_xfree(r);
 107 }
 108
 109 struct pa_pdispatch* pa_pdispatch_new(struct pa_mainloop_api *mainloop, const struct pa_pdispatch_command*table, unsigned entries) {
 110     struct pa_pdispatch *pd;
 111     assert(mainloop);
 112
 113     assert((entries && table) || (!entries && !table));
 114
 115     pd = pa_xmalloc(sizeof(struct pa_pdispatch));
 116     pd->ref = 1;
 117     pd->mainloop = mainloop;
 118     pd->command_table = table;
 119     pd->n_commands = entries;
 120     PA_LLIST_HEAD_INIT(struct pa_reply_info, pd->replies);
 121     pd->drain_callback = NULL;
 122     pd->drain_userdata = NULL;
 123
 124     return pd;
 125 }
 126
 127 void pdispatch_free(struct pa_pdispatch *pd) {
 128     assert(pd);
 129
 130     while (pd->replies)
 131         reply_info_free(pd->replies);
 132
 133     pa_xfree(pd);
 134 }
 135
 136 static void run_action(struct pa_pdispatch *pd, struct reply_info *r, uint32_t command, struct pa_tagstruct *ts) {
 137     void (*callback)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
 138     void *userdata;
 139     uint32_t tag;
 140     assert(r);
 141
 142     pa_pdispatch_ref(pd);
 143
 144     callback = r->callback;
 145     userdata = r->userdata;
 146     tag = r->tag;
 147
 148     reply_info_free(r);
 149
 150     callback(pd, command, tag, ts, userdata);
 151
 152     if (pd->drain_callback && !pa_pdispatch_is_pending(pd))
 153         pd->drain_callback(pd, pd->drain_userdata);
 154
 155     pa_pdispatch_unref(pd);
 156 }
 157
 158 int pa_pdispatch_run(struct pa_pdispatch *pd, struct pa_packet*packet, void *userdata) {
 159     uint32_t tag, command;
 160     struct pa_tagstruct *ts = NULL;
 161     int ret = -1;
 162     assert(pd && packet && packet->data);
 163
 164     pa_pdispatch_ref(pd);
 165
 166     if (packet->length <= 8)
 167         goto finish;
 168
 169     ts = pa_tagstruct_new(packet->data, packet->length);
 170     assert(ts);
 171
 172     if (pa_tagstruct_getu32(ts, &command) < 0 ||
 173         pa_tagstruct_getu32(ts, &tag) < 0)
 174         goto finish;
 175
 176 #ifdef DEBUG_OPCODES
 177     pa_log(__FILE__": Recieved opcode <%s>\n", command_names[command]);
 178 #endif
 179
 180     if (command == PA_COMMAND_ERROR || command == PA_COMMAND_REPLY) {
 181         struct reply_info *r;
 182
 183         for (r = pd->replies; r; r = r->next)
 184             if (r->tag == tag)
 185                 break;
 186
 187         if (r)
 188             run_action(pd, r, command, ts);
 189
 190     } else if (pd->command_table && (command < pd->n_commands) && pd->command_table[command].proc) {
 191         const struct pa_pdispatch_command *c = pd->command_table+command;
 192
 193         c->proc(pd, command, tag, ts, userdata);
 194     } else {
 195         pa_log(__FILE__": Recieved unsupported command %u\n", command);
 196         goto finish;
 197     }
 198
 199     ret = 0;
 200
 201 finish:
 202     if (ts)
 203         pa_tagstruct_free(ts);
 204
 205     pa_pdispatch_unref(pd);
 206
 207     return ret;
 208 }
 209
 210 static void timeout_callback(struct pa_mainloop_api*m, struct pa_time_event*e, const struct timeval *tv, void *userdata) {
 211     struct reply_info*r = userdata;
 212     assert(r && r->time_event == e && r->pdispatch && r->pdispatch->mainloop == m && r->callback);
 213
 214     run_action(r->pdispatch, r, PA_COMMAND_TIMEOUT, NULL);
 215 }
 216
 217 void pa_pdispatch_register_reply(struct pa_pdispatch *pd, uint32_t tag, int timeout, void (*cb)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata), void *userdata) {
 218     struct reply_info *r;
 219     struct timeval tv;
 220     assert(pd && pd->ref >= 1 && cb);
 221
 222     r = pa_xmalloc(sizeof(struct reply_info));
 223     r->pdispatch = pd;
 224     r->callback = cb;
 225     r->userdata = userdata;
 226     r->tag = tag;
 227
 228     gettimeofday(&tv, NULL);
 229     tv.tv_sec += timeout;
 230
 231     r->time_event = pd->mainloop->time_new(pd->mainloop, &tv, timeout_callback, r);
 232     assert(r->time_event);
 233
 234     PA_LLIST_PREPEND(struct reply_info, pd->replies, r);
 235 }
 236
 237 int pa_pdispatch_is_pending(struct pa_pdispatch *pd) {
 238     assert(pd);
 239
 240     return !!pd->replies;
 241 }
 242
 243 void pa_pdispatch_set_drain_callback(struct pa_pdispatch *pd, void (*cb)(struct pa_pdispatch *pd, void *userdata), void *userdata) {
 244     assert(pd);
 245     assert(!cb || pa_pdispatch_is_pending(pd));
 246
 247     pd->drain_callback = cb;
 248     pd->drain_userdata = userdata;
 249 }
 250
 251 void pa_pdispatch_unregister_reply(struct pa_pdispatch *pd, void *userdata) {
 252     struct reply_info *r, *n;
 253     assert(pd);
 254
 255     for (r = pd->replies; r; r = n) {
 256         n = r->next;
 257
 258         if (r->userdata == userdata)
 259             reply_info_free(r);
 260     }
 261 }
 262
 263 void pa_pdispatch_unref(struct pa_pdispatch *pd) {
 264     assert(pd && pd->ref >= 1);
 265
 266     if (!(--(pd->ref)))
 267         pdispatch_free(pd);
 268 }
 269
 270 struct pa_pdispatch* pa_pdispatch_ref(struct pa_pdispatch *pd) {
 271     assert(pd && pd->ref >= 1);
 272     pd->ref++;
 273     return pd;
 274 }