change version.
[paraslash.git] / plm_dbtool.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 plm_dbtool.c Playlist manager for 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 struct plm_client_data {
29 size_t size;
30 /** allocated and set by com_lpl() (child) */
31 int shm_id;
32 /** initially locked, gets unlocked by parent when it is done */
33 int mutex;
34 /** return value, set by parent */
35 int retval;
36 };
37
38 /** data specific to the plm database tool */
39 struct private_plm_data {
40 /** guards against concurrent client access */
41 int client_mutex;
42 /** guards against concurrent parent-child access */
43 int server_mutex;
44 /** pointer to the client data */
45 struct plm_client_data *client_data;
46 /** id of the shm corresponding to \a client_data */
47 int client_data_shm_id;
48 };
49
50 /** we refuse to load playlists bigger than that */
51 #define MAX_PLAYLIST_BYTES (1024 * 1024)
52
53 static unsigned playlist_len, playlist_size, current_playlist_entry;
54 static char **playlist;
55 static struct dbtool *self;
56
57 static int com_ppl(int, int, char **);
58 static int com_lpl(int, int, char **);
59 extern struct misc_meta_data *mmd;
60
61 /* array of commands that are supported by this database tool */
62 static struct server_command cmds[] = {
63 {
64 .name = "ppl",
65 .handler = com_ppl,
66 .perms = DB_READ,
67 .description = "print playlist",
68 .synopsis = "ppl",
69 .help =
70 "Print out the current playlist"
71 }, {
72 .name = "lpl",
73 .handler = com_lpl,
74 .perms = DB_WRITE,
75 .description = "load playlist",
76 .synopsis = "lpl",
77 .help =
78 "Read a new playlist from stdin. Example:\n"
79 "\tfind /audio -name '*.mp3' | para_client lpl"
80 }, {
81 .name = NULL,
82 }
83 };
84
85 static void playlist_add(char *path)
86 {
87 if (playlist_len >= playlist_size) {
88 playlist_size = 2 * playlist_size + 1;
89 playlist = para_realloc(playlist, playlist_size * sizeof(char *));
90 }
91 PARA_DEBUG_LOG("adding #%d/%d: %s\n", playlist_len, playlist_size, path);
92 playlist[playlist_len++] = para_strdup(path);
93 }
94
95 static int send_playlist_to_server(const char *buf, size_t size)
96 {
97 struct private_plm_data *ppd = self->private_data;
98 int ret, shm_mutex = -1, shm_id = -1;
99 void *shm = NULL;
100
101 PARA_DEBUG_LOG("new playlist (%d bytes)\n", size);
102
103 ret = mutex_new();
104 if (ret < 0)
105 return ret;
106 shm_mutex = ret;
107
108 ret = shm_new(size);
109 if (ret < 0)
110 goto out;
111 shm_id = ret;
112
113 ret = shm_attach(shm_id, ATTACH_RW, &shm);
114 if (ret < 0)
115 goto out;
116 mutex_lock(shm_mutex);
117 memcpy(shm, buf, size);
118 mutex_lock(ppd->client_mutex);
119 mutex_lock(ppd->server_mutex);
120 ppd->client_data->size = size;
121 ppd->client_data->shm_id = shm_id;
122 ppd->client_data->mutex = shm_mutex;
123 kill(getppid(), SIGUSR1); /* wake up the server */
124 mutex_unlock(ppd->server_mutex);
125 mutex_lock(shm_mutex); /* wait until server is done */
126 mutex_unlock(shm_mutex);
127 ret = ppd->client_data->retval;
128 mutex_unlock(ppd->client_mutex);
129 shm_detach(shm);
130 out:
131 if (shm_id >= 0)
132 shm_destroy(shm_id);
133 mutex_destroy(shm_mutex);
134 PARA_DEBUG_LOG("returning %d\n", ret);
135 return ret;
136 }
137
138 static int com_lpl(int fd, __unused int argc, __unused char *argv[])
139 {
140 unsigned loaded = 0;
141 size_t bufsize = 4096; /* guess that's enough */
142 char *buf = para_malloc(bufsize);
143 ssize_t ret;
144 ret = send_buffer(fd, AWAITING_DATA_MSG);
145 if (ret < 0)
146 goto out;
147 again:
148 ret = recv_bin_buffer(fd, buf + loaded, bufsize - loaded);
149 if (ret < 0)
150 goto out;
151 if (!ret) {
152 ret = send_playlist_to_server(buf, loaded);
153 goto out;
154 }
155 loaded += ret;
156 ret = -E_LOAD_PLAYLIST;
157 if (loaded >= MAX_PLAYLIST_BYTES)
158 goto out;
159 if (loaded >= bufsize) {
160 bufsize *= 2;
161 buf = para_realloc(buf, bufsize);
162 }
163 goto again;
164 out:
165 free(buf);
166 return ret;
167 }
168
169 static int com_ppl(int fd, __unused int argc, __unused char *argv[])
170 {
171 unsigned i;
172
173 PARA_DEBUG_LOG("sending playlist to client (%d entries)\n", playlist_len);
174 for (i = 0; i < playlist_len; i++) {
175 int ret = send_va_buffer(fd, "%s\n", playlist[
176 (i + current_playlist_entry) % playlist_len]);
177 if (ret < 0)
178 return ret;
179 }
180 return 1;
181 }
182
183 static char **plm_get_audio_file_list(unsigned int num)
184 {
185 char **file_list;
186 unsigned i;
187
188 num = MIN(num, playlist_len);
189 if (!num)
190 return NULL;
191 file_list = para_malloc((num + 1) * sizeof(char *));
192 for (i = 0; i < num; i++) {
193 unsigned j = (current_playlist_entry + i) % playlist_len;
194 file_list[i] = para_strdup(playlist[j]);
195 }
196 file_list[i] = NULL;
197 return file_list;
198 }
199
200 static void free_playlist_contents(void)
201 {
202 int i;
203
204 PARA_DEBUG_LOG("freeing playlist (%d entries)\n", playlist_len);
205 for (i = 0; i < playlist_len; i++)
206 free(playlist[i]);
207 current_playlist_entry = 0;
208 playlist_len = 0;
209 }
210
211 static void plm_shutdown(void)
212 {
213 struct private_plm_data *ppd = self->private_data;
214
215 shm_detach(ppd->client_data);
216 shm_destroy(ppd->client_data_shm_id);
217 mutex_destroy(ppd->server_mutex);
218 mutex_destroy(ppd->client_mutex);
219 free(ppd);
220 free_playlist_contents();
221 free(playlist);
222 playlist = NULL;
223 playlist_len = 0;
224 playlist_size = 0;
225 }
226
227 static void plm_post_select(__unused fd_set *rfds, __unused fd_set *wfds)
228 {
229 struct private_plm_data *ppd = self->private_data;
230 struct plm_client_data *pcd = ppd->client_data;
231 int ret;
232 void *shm;
233
234 mutex_lock(ppd->server_mutex);
235 if (!pcd->size)
236 goto out;
237 free_playlist_contents();
238 ret = shm_attach(pcd->shm_id, ATTACH_RW, &shm);
239 if (ret < 0) {
240 PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret));
241 goto out;
242 }
243 PARA_DEBUG_LOG("loading new playlist (%d bytes)\n", pcd->size);
244 ret = for_each_line((char *)shm, pcd->size, &playlist_add, 0);
245 shm_detach(shm);
246 PARA_NOTICE_LOG("new playlist (%d entries)\n", playlist_len);
247 pcd->retval = 1;
248 pcd->size = 0;
249 mutex_unlock(pcd->mutex);
250 out:
251 mutex_unlock(ppd->server_mutex);
252 }
253
254 void plm_update_audio_file(char *audio_file)
255 {
256 unsigned i;
257
258 for (i = 0; i < playlist_len; i++) {
259 unsigned j = (current_playlist_entry + i) % playlist_len;
260 if (strcmp(playlist[j], audio_file))
261 continue;
262 current_playlist_entry = (j + 1) % playlist_len;
263 }
264 }
265
266 /**
267 * the init function for the plm database tool
268 *
269 * Init all function pointers of \a db
270 *
271 * \sa struct dbtool, misc_meta_data::dbinfo, mysql.c random_dbtool.c
272 */
273 int plm_dbtool_init(struct dbtool *db)
274 {
275 int ret;
276 struct private_plm_data *ppd = NULL;
277 void *shm = NULL;
278
279 self = db;
280 db->cmd_list = cmds;
281 db->get_audio_file_list = plm_get_audio_file_list;
282 db->shutdown = plm_shutdown;
283 db->post_select = plm_post_select;
284 db->update_audio_file = plm_update_audio_file;
285 ppd = para_calloc(sizeof(struct private_plm_data));
286 db->private_data = ppd;
287
288 ppd->client_mutex = -1;
289 ppd->server_mutex = -1;
290 ppd->client_data_shm_id = -1;
291 ppd->client_data = NULL;
292
293 ret = mutex_new();
294 if (ret < 0)
295 goto err_out;
296 ppd->client_mutex = ret;
297
298 ret = mutex_new();
299 if (ret < 0)
300 goto err_out;
301 ppd->server_mutex = ret;
302
303 ret = shm_new(sizeof(struct plm_client_data));
304 if (ret < 0)
305 goto err_out;
306 ppd->client_data_shm_id = ret;
307
308 ret = shm_attach(ppd->client_data_shm_id, ATTACH_RW, &shm);
309 if (ret < 0)
310 goto err_out;
311 ppd->client_data = shm;
312 ppd->client_data->size = 0;
313 sprintf(mmd->dbinfo, "plm initialized");
314 return 1;
315 err_out:
316 if (ppd->client_data_shm_id >= 0)
317 shm_destroy(ppd->client_data_shm_id);
318 if (ppd->client_mutex >= 0)
319 mutex_destroy(ppd->client_mutex);
320 if (ppd->server_mutex >= 0)
321 mutex_destroy(ppd->server_mutex);
322 free(ppd);
323 return ret;
324 }