grab_client.c

   1 /*
   2  * Copyright (C) 2006 Andre Noll <maan@tuebingen.mpg.de>
   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 <inttypes.h>
  12 #include <lopsub.h>
  13
  14 #include "audiod_cmd.lsg.h"
  15
  16 #include "para.h"
  17 #include "list.h"
  18 #include "sched.h"
  19 #include "buffer_tree.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 static INITIALIZED_LIST_HEAD(active_grab_client_list);
  66 /* Grab clients that are not currently attached any btr node. */
  67 static 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 = xwrite(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, void *context)
  98 {
  99         struct grab_client *gc = context;
 100         int ret = btr_node_status(gc->btrn, 0, BTR_NT_LEAF);
 101
 102         if (ret == 0)
 103                 return;
 104         if (ret < 0)
 105                 sched_min_delay(s);
 106         para_fd_set(gc->fd, &s->wfds, &s->max_fileno);
 107 }
 108
 109 /*
 110  * We need this forward declaration as post_select() needs
 111  * activate_grab_client and vice versa.
 112  */
 113 static int gc_post_select(struct sched *s, void *context);
 114
 115 /**
 116  * Move a grab client to the active list and start it.
 117  *
 118  * \param gc The grab client to activate.
 119  */
 120 static void gc_activate(struct grab_client *gc, struct sched *s)
 121 {
 122         struct btr_node *root = audiod_get_btr_root(), *parent;
 123         char *name = gc->name? gc->name : "grab";
 124
 125         if (!root)
 126                 return;
 127         parent = btr_search_node(gc->parent, root);
 128         if (!parent)
 129                 return;
 130         PARA_INFO_LOG("activating fd %d\n", gc->fd);
 131         list_move(&gc->node, &active_grab_client_list);
 132         gc->btrn = btr_new_node(&(struct btr_node_description)
 133                 EMBRACE(.name = name, .parent = parent));
 134
 135         gc->task = task_register(&(struct task_info) {
 136                 .name = name,
 137                 .pre_select = gc_pre_select,
 138                 .post_select = gc_post_select,
 139                 .context = gc,
 140         }, s);
 141 }
 142
 143 /**
 144  * Activate inactive grab clients if possible.
 145  *
 146  * \param s Needed to schedule the grab client task.
 147  *
 148  * This is called from audiod.c when the current audio file changes. It loops
 149  * over all inactive grab clients and checks each grab client's configuration
 150  * to determine if the client in question wishes to grab the new stream.  If
 151  * yes, this grab client is moved from the inactive to the active grab client list.
 152  *
 153  * This function also garbage collects all grab clients whose tasks have been
 154  * unscheduled.
 155  */
 156 void activate_grab_clients(struct sched *s)
 157 {
 158         struct grab_client *gc, *tmp;
 159
 160         list_for_each_entry_safe(gc, tmp, &inactive_grab_client_list, node) {
 161                 if (gc->fd < 0) {
 162                         list_del(&gc->node);
 163                         free(gc);
 164                         continue;
 165                 }
 166                 gc_activate(gc, s);
 167         }
 168 }
 169
 170 static int gc_close(struct grab_client *gc, int err)
 171 {
 172         btr_remove_node(&gc->btrn);
 173         PARA_INFO_LOG("closing gc: %s\n", para_strerror(-err));
 174         list_move(&gc->node, &inactive_grab_client_list);
 175         if (err == -E_GC_WRITE || (gc->flags & GF_ONE_SHOT)) {
 176                 /*
 177                  * We must not free the gc structure here as it contains ->task
 178                  * which is still used because this function is called from
 179                  * post_select().
 180                  */
 181                 close(gc->fd);
 182                 gc->fd = -1;
 183                 free(gc->parent);
 184                 free(gc->name);
 185                 return 1;
 186         }
 187         return 0;
 188 }
 189
 190 static int gc_post_select(__a_unused struct sched *s, void *context)
 191 {
 192         struct grab_client *gc = context;
 193         struct btr_node *btrn = gc->btrn;
 194         int ret;
 195         size_t sz;
 196         char *buf;
 197
 198         ret = btr_node_status(btrn, 0, BTR_NT_LEAF);
 199         if (ret == 0)
 200                 return 0;
 201         if (ret < 0)
 202                 goto err;
 203         sz = btr_next_buffer(btrn, &buf);
 204         assert(sz != 0);
 205         ret = gc_write(gc, buf, sz);
 206         if (ret < 0)
 207                 goto err;
 208         if (ret > 0)
 209                 btr_consume(btrn, ret);
 210         return 0;
 211 err:
 212         gc_close(gc, ret);
 213         return ret;
 214 }
 215
 216 static int gc_check_args(struct lls_parse_result *lpr, struct grab_client *gc)
 217 {
 218         const struct lls_opt_result *r;
 219
 220         r = lls_opt_result(LSG_AUDIOD_CMD_GRAB_OPT_MODE, lpr);
 221         if (lls_opt_given(r) > 0) {
 222                 const char *arg = lls_string_val(0, r);
 223                 if (strcmp(arg, "s") == 0)
 224                         gc->mode = GM_SLOPPY;
 225                 else if (strcmp(arg, "a") == 0)
 226                         gc->mode = GM_AGGRESSIVE;
 227                 else if (strcmp(arg, "p") == 0)
 228                         gc->mode = GM_PEDANTIC;
 229                 else
 230                         return -E_GC_SYNTAX;
 231         }
 232
 233         r = lls_opt_result(LSG_AUDIOD_CMD_GRAB_OPT_ONE_SHOT, lpr);
 234         if (lls_opt_given(r) > 0)
 235                 gc->flags |= GF_ONE_SHOT;
 236
 237         r = lls_opt_result(LSG_AUDIOD_CMD_GRAB_OPT_PARENT, lpr);
 238         if (lls_opt_given(r) > 0) {
 239                 const char *arg = lls_string_val(0, r);
 240                 gc->parent = para_strdup(arg);
 241         }
 242
 243         r = lls_opt_result(LSG_AUDIOD_CMD_GRAB_OPT_NAME, lpr);
 244         if (lls_opt_given(r) > 0) {
 245                 const char *arg = lls_string_val(0, r);
 246                 gc->name = para_strdup(arg);
 247         }
 248         return 1;
 249 }
 250
 251 /**
 252  * Create and activate a grab client.
 253  *
 254  * \param fd The file descriptor of the client.
 255  * \param lpr The parsed command line of the grab command.
 256  * \param s The scheduler to register the grab client task to.
 257  *
 258  * This function semantically parses the arguments given as options to the grab
 259  * command. On success it allocates a struct grab_client, associates it with
 260  * the given file descriptor and activates it. If the new grab client can not
 261  * be attached to an existing buffer tree node it is put into the inactive list
 262  * for later activation.
 263  *
 264  * \return Standard.
 265  */
 266 int grab_client_new(int fd, struct lls_parse_result *lpr, struct sched *s)
 267 {
 268         int ret;
 269         struct grab_client *gc = para_calloc(sizeof(struct grab_client));
 270
 271         ret = gc_check_args(lpr, gc);
 272         if (ret < 0)
 273                 goto err_out;
 274         ret = dup(fd);
 275         if (ret < 0) {
 276                 ret = -ERRNO_TO_PARA_ERROR(errno);
 277                 goto err_out;
 278         }
 279         gc->fd = ret;
 280         para_list_add(&gc->node, &inactive_grab_client_list);
 281         gc_activate(gc, s);
 282         return 1;
 283 err_out:
 284         free(gc);
 285         return ret;
 286 }