ortp_send: Fix EOF packet sending
[paraslash.git] / playlist_selector.c
1 /*
2  * Copyright (C) 2006 Andre Noll <maan@systemlinux.org>
3  *
4  *     This program is free software; you can redistribute it and/or modify
5  *     it under the terms of the GNU General Public License as published by
6  *     the Free Software Foundation; either version 2 of the License, or
7  *     (at your option) any later version.
8  *
9  *     This program is distributed in the hope that it will be useful,
10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  *     GNU General Public License for more details.
13  *
14  *     You should have received a copy of the GNU General Public License
15  *     along with this program; if not, write to the Free Software
16  *     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
17  */
18
19 /** \file playlist_selector.c The playlist audio file selector of paraslash  */
20
21 #include "server.h"
22 #include "db.h"
23 #include "error.h"
24 #include "net.h"
25 #include "string.h"
26 #include "ipc.h"
27
28 /**
29  * structure used for transmission of the playlist
30  *
31  * There's one such struct which gets initialized during startup. It lives in
32  * shared memory and is used by com_lpl().
33  */
34 struct pls_client_data {
35 /** allocated and set by com_lpl() (child) */
36         int shm_id;
37 /** the size of the shared memory area identified by \a shm_id */
38         size_t size;
39 /** initially locked, gets unlocked by parent when it is done */
40         int mutex;
41 /** return value, set by parent */
42         int retval;
43 };
44
45 /** data specific to the playlist selector */
46 struct private_pls_data {
47 /** guards against concurrent client access */
48         int client_mutex;
49 /** guards against concurrent parent-child access */
50         int server_mutex;
51 /** pointer to the client data */
52         struct pls_client_data *client_data;
53 /** id of the shm corresponding to \a client_data */
54         int client_data_shm_id;
55 };
56
57 /** we refuse to load playlists bigger than that */
58 #define MAX_PLAYLIST_BYTES (1024 * 1024)
59
60 static unsigned playlist_len, playlist_size, current_playlist_entry;
61 static char **playlist;
62 static struct audio_file_selector *self;
63
64 static int com_ppl(int, int, char **);
65 static int com_lpl(int, int, char **);
66 extern struct misc_meta_data *mmd;
67
68 /* array of supported commands */
69 static struct server_command cmds[] = {
70 {
71 .name = "ppl",
72 .handler = com_ppl,
73 .perms = DB_READ,
74 .description = "print playlist",
75 .synopsis = "ppl",
76 .help =
77 "Print out the current playlist"
78 }, {
79 .name = "lpl",
80 .handler = com_lpl,
81 .perms = DB_WRITE,
82 .description = "load playlist",
83 .synopsis = "lpl",
84 .help =
85 "Read a new playlist from stdin. Example:\n"
86 "\tfind /audio -name '*.mp3' | para_client lpl"
87 }, {
88 .name = NULL,
89 }
90 };
91
92 static void playlist_add(char *path)
93 {
94         if (playlist_len >= playlist_size) {
95                 playlist_size = 2 * playlist_size + 1;
96                 playlist = para_realloc(playlist, playlist_size * sizeof(char *));
97         }
98         PARA_DEBUG_LOG("adding #%d/%d: %s\n", playlist_len, playlist_size, path);
99         playlist[playlist_len++] = para_strdup(path);
100 }
101
102 static int send_playlist_to_server(const char *buf, size_t size)
103 {
104         struct private_pls_data *ppd = self->private_data;
105         int ret, shm_mutex = -1, shm_id = -1;
106         void *shm = NULL;
107
108         PARA_DEBUG_LOG("new playlist (%zd bytes)\n", size);
109
110         ret = mutex_new();
111         if (ret < 0)
112                 return ret;
113         shm_mutex = ret;
114
115         ret = shm_new(size);
116         if (ret < 0)
117                 goto out;
118         shm_id = ret;
119
120         ret = shm_attach(shm_id, ATTACH_RW, &shm);
121         if (ret < 0)
122                 goto out;
123         mutex_lock(shm_mutex);
124         memcpy(shm, buf, size);
125         mutex_lock(ppd->client_mutex);
126         mutex_lock(ppd->server_mutex);
127         ppd->client_data->size = size;
128         ppd->client_data->shm_id = shm_id;
129         ppd->client_data->mutex = shm_mutex;
130         kill(getppid(), SIGUSR1); /* wake up the server */
131         mutex_unlock(ppd->server_mutex);
132         mutex_lock(shm_mutex); /* wait until server is done */
133         mutex_unlock(shm_mutex);
134         ret = ppd->client_data->retval;
135         mutex_unlock(ppd->client_mutex);
136         shm_detach(shm);
137 out:
138         if (shm_id >= 0)
139                 shm_destroy(shm_id);
140         mutex_destroy(shm_mutex);
141         PARA_DEBUG_LOG("returning %d\n", ret);
142         return ret;
143 }
144
145 static int com_lpl(int fd, __a_unused int argc, __a_unused char *argv[])
146 {
147         unsigned loaded = 0;
148         size_t bufsize = 4096; /* guess that's enough */
149         char *buf = para_malloc(bufsize);
150         ssize_t ret;
151         ret = send_buffer(fd, AWAITING_DATA_MSG);
152         if (ret < 0)
153                 goto out;
154 again:
155         ret = recv_bin_buffer(fd, buf + loaded, bufsize - loaded);
156         if (ret < 0)
157                 goto out;
158         if (!ret) {
159                 ret = send_playlist_to_server(buf, loaded);
160                 goto out;
161         }
162         loaded += ret;
163         ret = -E_LOAD_PLAYLIST;
164         if (loaded >= MAX_PLAYLIST_BYTES)
165                 goto out;
166         if (loaded >= bufsize) {
167                 bufsize *= 2;
168                 buf = para_realloc(buf, bufsize);
169         }
170         goto again;
171 out:
172         free(buf);
173         return ret;
174 }
175
176 static int com_ppl(int fd, __a_unused int argc, __a_unused char *argv[])
177 {
178         unsigned i;
179
180         PARA_DEBUG_LOG("sending playlist to client (%d entries)\n", playlist_len);
181         for (i = 0; i < playlist_len; i++) {
182                 int ret = send_va_buffer(fd, "%s\n", playlist[
183                         (i + current_playlist_entry) % playlist_len]);
184                 if (ret < 0)
185                         return ret;
186         }
187         return 1;
188 }
189
190 static char **pls_get_audio_file_list(unsigned int num)
191 {
192         char **file_list;
193         unsigned i;
194
195         num = PARA_MIN(num, playlist_len);
196         if (!num)
197                 return NULL;
198         file_list = para_malloc((num + 1) * sizeof(char *));
199         for (i = 0; i < num; i++) {
200                 unsigned j = (current_playlist_entry + i) % playlist_len;
201                 file_list[i] = para_strdup(playlist[j]);
202         }
203         file_list[i] = NULL;
204         return file_list;
205 }
206
207 static void free_playlist_contents(void)
208 {
209         int i;
210
211         PARA_DEBUG_LOG("freeing playlist (%d entries)\n", playlist_len);
212         for (i = 0; i < playlist_len; i++)
213                 free(playlist[i]);
214         current_playlist_entry = 0;
215         playlist_len = 0;
216 }
217
218 static void pls_shutdown(void)
219 {
220         struct private_pls_data *ppd = self->private_data;
221
222         shm_detach(ppd->client_data);
223         shm_destroy(ppd->client_data_shm_id);
224         mutex_destroy(ppd->server_mutex);
225         mutex_destroy(ppd->client_mutex);
226         free(ppd);
227         free_playlist_contents();
228         free(playlist);
229         playlist = NULL;
230         playlist_len = 0;
231         playlist_size = 0;
232 }
233
234 static void pls_post_select(__a_unused fd_set *rfds, __a_unused fd_set *wfds)
235 {
236         struct private_pls_data *ppd = self->private_data;
237         struct pls_client_data *pcd = ppd->client_data;
238         int ret;
239         void *shm;
240
241         mutex_lock(ppd->server_mutex);
242         if (!pcd->size)
243                 goto out;
244         free_playlist_contents();
245         ret = shm_attach(pcd->shm_id, ATTACH_RW, &shm);
246         if (ret < 0) {
247                 PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret));
248                 goto out;
249         }
250         PARA_DEBUG_LOG("loading new playlist (%zd bytes)\n", pcd->size);
251         ret = for_each_line((char *)shm, pcd->size, &playlist_add);
252         shm_detach(shm);
253         PARA_NOTICE_LOG("new playlist (%d entries)\n", playlist_len);
254         pcd->retval = 1;
255         pcd->size = 0;
256         mutex_unlock(pcd->mutex);
257 out:
258         mutex_unlock(ppd->server_mutex);
259 }
260
261 void pls_update_audio_file(char *audio_file)
262 {
263         unsigned i;
264
265         for (i = 0; i < playlist_len; i++) {
266                 unsigned j = (current_playlist_entry + i) % playlist_len;
267                 if (strcmp(playlist[j], audio_file))
268                         continue;
269                 current_playlist_entry = (j + 1) % playlist_len;
270         }
271 }
272
273 /**
274  * the init function for the playlist selector
275  *
276  * Init all function pointers of \a db
277  *
278  * \sa struct audio_file_selector, misc_meta_data::selector_info, mysql.c
279  * random_selector.c.
280  */
281 int playlist_selector_init(struct audio_file_selector *db)
282 {
283         int ret;
284         struct private_pls_data *ppd = NULL;
285         void *shm = NULL;
286
287         self = db;
288         db->cmd_list = cmds;
289         db->get_audio_file_list = pls_get_audio_file_list;
290         db->shutdown = pls_shutdown;
291         db->post_select = pls_post_select;
292         db->update_audio_file = pls_update_audio_file;
293         ppd = para_calloc(sizeof(struct private_pls_data));
294         db->private_data = ppd;
295
296         ppd->client_mutex = -1;
297         ppd->server_mutex = -1;
298         ppd->client_data_shm_id = -1;
299         ppd->client_data = NULL;
300
301         ret = mutex_new();
302         if (ret < 0)
303                 goto err_out;
304         ppd->client_mutex = ret;
305
306         ret = mutex_new();
307         if (ret < 0)
308                 goto err_out;
309         ppd->server_mutex = ret;
310
311         ret = shm_new(sizeof(struct pls_client_data));
312         if (ret < 0)
313                 goto err_out;
314         ppd->client_data_shm_id = ret;
315
316         ret = shm_attach(ppd->client_data_shm_id, ATTACH_RW, &shm);
317         if (ret < 0)
318                 goto err_out;
319         ppd->client_data = shm;
320         ppd->client_data->size = 0;
321         sprintf(mmd->selector_info, "playlist selector initialized");
322         return 1;
323 err_out:
324         if (ppd->client_data_shm_id >= 0)
325                 shm_destroy(ppd->client_data_shm_id);
326         if (ppd->client_mutex >= 0)
327                 mutex_destroy(ppd->client_mutex);
328         if (ppd->server_mutex >= 0)
329                 mutex_destroy(ppd->server_mutex);
330         free(ppd);
331         return ret;
332 }