server: Convert com_mvatt() to lopsub.
[paraslash.git] / 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 }