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