grab_client.c

   1 /*
   2  * Copyright (C) 2006-2010 Andre Noll <maan@systemlinux.org>
   3  *
   4  * Licensed under the GPL v2. For licencing details see COPYING.
   5  */
   6
   7 /** \file grab_client.c Functions for grabbing the audio stream. */
   8
   9 #include <regex.h>
  10 #include <sys/types.h>
  11 #include <dirent.h>
  12 #include <stdbool.h>
  13
  14 #include "para.h"
  15 #include "list.h"
  16 #include "sched.h"
  17 #include "ggo.h"
  18 #include "buffer_tree.h"
  19 #include "filter.h"
  20 #include "grab_client.h"
  21 #include "audiod.h"
  22 #include "error.h"
  23 #include "string.h"
  24 #include "fd.h"
  25
  26 /**
  27  * How to handle blocking writes for the grab client fds.
  28  */
  29 enum grab_mode {
  30         /** Ignore the data and do not write. */
  31         GM_SLOPPY,
  32         /** Write anyway (default). */
  33         GM_AGGRESSIVE,
  34         /** Close fd if write would block. */
  35         GM_PEDANTIC,
  36 };
  37
  38 /** Flags specified as arguments to the grab command. */
  39 enum grab_flags {
  40         /** Stop grabbing if audio file changes. */
  41         GF_ONE_SHOT = 1,
  42 };
  43
  44 /** Describes one active grab client. */
  45 struct grab_client {
  46         /* The value of the -p option. */
  47         char *parent;
  48         /* The value of the -n option. */
  49         char *name;
  50         /** The file descriptor to send the grabbed stream to. */
  51         int fd;
  52         /** See \ref grab_mode. */
  53         enum grab_mode mode;
  54         /** Flags given at the command line. */
  55         enum grab_flags flags;
  56         /** The point of the grab client's node in the buffer tree. */
  57         struct btr_node *btrn;
  58         /* The task of this grab client. */
  59         struct task task;
  60         /** Belongs to either the active or the inactive list. */
  61         struct list_head node;
  62 };
  63
  64 /* Grab clients that are attached to a btr node. */
  65 INITIALIZED_LIST_HEAD(active_grab_client_list);
  66 /* Grab clients that are not currently attached any btr node. */
  67 INITIALIZED_LIST_HEAD(inactive_grab_client_list);
  68
  69 static int gc_write(struct grab_client *gc, char *buf, size_t len)
  70 {
  71         int ret = write_ok(gc->fd);
  72
  73         if (ret < 0)
  74                 goto err;
  75         if (ret == 0) { /* fd not ready */
  76                 if (gc->mode == GM_PEDANTIC)
  77                         goto err;
  78                 if (gc->mode == GM_SLOPPY)
  79                         return len;
  80         }
  81         ret = write_nonblock(gc->fd, buf, len);
  82         if (ret < 0)
  83                 goto err;
  84         if (ret > 0)
  85                 return ret;
  86         if (ret == 0) {
  87                 if (gc->mode == GM_PEDANTIC)
  88                         goto err;
  89                 if (gc->mode == GM_SLOPPY)
  90                         return len;
  91         }
  92         return 0;
  93 err:
  94         return -E_GC_WRITE;
  95 }
  96
  97 static void gc_pre_select(struct sched *s, struct task *t)
  98 {
  99         struct grab_client *gc = container_of(t, struct grab_client, task);
 100         int ret = btr_node_status(gc->btrn, 0, BTR_NT_LEAF);
 101
 102         if (ret == 0)
 103                 return;
 104         if (ret < 0) {
 105                 s->timeout.tv_sec = 0;
 106                 s->timeout.tv_usec = 0;
 107                 return;
 108         }
 109         para_fd_set(gc->fd, &s->wfds, &s->max_fileno);
 110 }
 111
 112 /*
 113  * We need this forward declaration as post_select() needs
 114  * activate_grab_client and vice versa.
 115  */
 116 static void gc_post_select(struct sched *s, struct task *t);
 117
 118 /**
 119  * Move a grab client to the active list and start it.
 120  *
 121  * \param gc The grab client to activate.
 122  */
 123 static void gc_activate(struct grab_client *gc)
 124 {
 125         struct btr_node *root = audiod_get_btr_root(), *parent;
 126         char *name = gc->name? gc->name : "grab";
 127
 128         if (!root)
 129                 return;
 130         parent = btr_search_node(gc->parent, root);
 131         if (!parent)
 132                 return;
 133         PARA_INFO_LOG("activating fd %d\n", gc->fd);
 134         list_move(&gc->node, &active_grab_client_list);
 135         gc->btrn = btr_new_node(&(struct btr_node_description)
 136                 EMBRACE(.name = name, .parent = parent));
 137         if (!gc->task.pre_select) {
 138                 gc->task.pre_select = gc_pre_select;
 139                 gc->task.post_select = gc_post_select;
 140                 snprintf(gc->task.status, sizeof(gc->task.status) - 1, "%s", name);
 141                 gc->task.status[sizeof(gc->task.status) - 1] = '\0';
 142                 register_task(&gc->task);
 143         }
 144 }
 145
 146 /**
 147  * Activate inactive grab clients if possible.
 148  *
 149  * This is called from audiod.c when the current audio file changes. It loops
 150  * over all inactive grab clients and checks each grab client's configuration
 151  * to determine if the client in question wishes to grab the new stream.  If
 152  * yes, this grab client is moved from the inactive to the active grab client list.
 153  *
 154  * This function also garbage collects all grab clients whose tasks have been
 155  * unscheduled.
 156  */
 157 void activate_grab_clients(void)
 158 {
 159         struct grab_client *gc, *tmp;
 160
 161         list_for_each_entry_safe(gc, tmp, &inactive_grab_client_list, node) {
 162                 if (gc->task.error == -E_TASK_UNREGISTERED) {
 163                         list_del(&gc->node);
 164                         free(gc);
 165                         continue;
 166                 }
 167                 gc_activate(gc);
 168         }
 169 }
 170
 171 static int gc_close(struct grab_client *gc, int err)
 172 {
 173         btr_remove_node(gc->btrn);
 174         btr_free_node(gc->btrn);
 175         gc->btrn = NULL;
 176         PARA_INFO_LOG("closing gc: %s\n", para_strerror(-err));
 177         list_move(&gc->node, &inactive_grab_client_list);
 178         if (err == -E_GC_WRITE || (gc->flags & GF_ONE_SHOT)) {
 179                 /*
 180                  * We must not free the gc structure here as it contains ->task
 181                  * which is still used because this function is called from
 182                  * post_select().
 183                  */
 184                 close(gc->fd);
 185                 free(gc->parent);
 186                 free(gc->name);
 187                 return 1;
 188         }
 189         gc_activate(gc);
 190         return 0;
 191 }
 192
 193 static void gc_post_select(__a_unused struct sched *s, struct task *t)
 194 {
 195         struct grab_client *gc = container_of(t, struct grab_client, task);
 196         struct btr_node *btrn = gc->btrn;
 197         int ret;
 198         size_t sz;
 199         char *buf;
 200
 201         t->error = 0;
 202         ret = btr_node_status(btrn, 0, BTR_NT_LEAF);
 203         if (ret == 0)
 204                 return;
 205         if (ret < 0)
 206                 goto err;
 207         sz = btr_next_buffer(btrn, &buf);
 208         assert(sz != 0);
 209         ret = gc_write(gc, buf, sz);
 210         if (ret < 0)
 211                 goto err;
 212         if (ret > 0)
 213                 btr_consume(btrn, ret);
 214         return;
 215 err:
 216         t->error = gc_close(gc, ret)? ret : 0;
 217 }
 218
 219 static int gc_check_args(int argc, char **argv, struct grab_client *gc)
 220 {
 221         int i;
 222
 223         for (i = 1; i < argc; i++) {
 224                 const char *arg = argv[i];
 225                 if (arg[0] != '-')
 226                         break;
 227                 if (!strcmp(arg, "--")) {
 228                         i++;
 229                         break;
 230                 }
 231                 if (!strncmp(arg, "-m", 2)) {
 232                         if (*(arg + 3))
 233                                 return -E_GC_SYNTAX;
 234                         switch(*(arg + 2)) {
 235                         case 's':
 236                                 gc->mode = GM_SLOPPY;
 237                                 continue;
 238                         case 'a':
 239                                 gc->mode = GM_AGGRESSIVE;
 240                                 continue;
 241                         case 'p':
 242                                 gc->mode = GM_PEDANTIC;
 243                                 continue;
 244                         default:
 245                                 return -E_GC_SYNTAX;
 246                         }
 247                 }
 248                 if (!strcmp(arg, "-o")) {
 249                         gc->flags |= GF_ONE_SHOT;
 250                         continue;
 251                 }
 252                 if (!strncmp(arg, "-p=", 3)) {
 253                         gc->parent = para_strdup(arg + 3);
 254                         continue;
 255                 }
 256                 if (!strncmp(arg, "-n=", 3)) {
 257                         gc->name = para_strdup(arg + 3);
 258                         continue;
 259                 }
 260                 return -E_GC_SYNTAX;
 261         }
 262         if (i != argc)
 263                 return -E_GC_SYNTAX;
 264         return 1;
 265 }
 266
 267 /**
 268  * Check the command line options and allocate a grab_client structure.
 269  *
 270  * \param fd The file descriptor of the client.
 271  * \param argc Argument count.
 272  * \param argv Argument vector.
 273  *
 274  * If the command line options given by \a argc and \a argv are valid.
 275  * allocate a struct grab_client and initialize it with this valid
 276  * configuration.
 277  *
 278  * If the new grab client can be added to an existing buffer tree, activate it.
 279  * Otherwise, add it to the inactive list for later activation.
 280  *
 281  * \return Standard.
 282  */
 283 int grab_client_new(int fd, int argc, char **argv)
 284 {
 285         int ret;
 286         struct grab_client *gc = para_calloc(sizeof(struct grab_client));
 287
 288         ret = gc_check_args(argc, argv, gc);
 289         if (ret < 0)
 290                 goto err_out;
 291         gc->fd = fd;
 292         para_list_add(&gc->node, &inactive_grab_client_list);
 293         gc_activate(gc);
 294         return 1;
 295 err_out:
 296         free(gc);
 297         return ret;
 298 }