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