chiark / gitweb /
Fix mis-merged trackdb_open().
[disorder] / cgi / actions.c
1 /*
2  * This file is part of DisOrder.
3  * Copyright (C) 2004-2008 Richard Kettlewell
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 3 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  * 
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 /** @file cgi/actions.c
19  * @brief DisOrder web actions
20  *
21  * Actions are anything that the web interface does beyond passive template
22  * expansion and inspection of state recieved from the server.  This means
23  * playing tracks, editing prefs etc but also setting extra headers e.g. to
24  * auto-refresh the playing list.
25  *
26  * See @ref lib/macros-builtin.c for docstring syntax.
27  */
28
29 #include "disorder-cgi.h"
30
31 /** @brief Redirect to some other action or URL */
32 static void redirect(const char *url) {
33   /* By default use the 'back' argument */
34   if(!url)
35     url = cgi_get("back");
36   if(url && *url) {
37     if(strncmp(url, "http", 4))
38       /* If the target is not a full URL assume it's the action */
39       url = cgi_makeurl(config->url, "action", url, (char *)0);
40   } else {
41     /* If back= is not set just go back to the front page */
42     url = config->url;
43   }
44   if(printf("Location: %s\n"
45             "%s\n"
46             "\n", url, dcgi_cookie_header()) < 0)
47     fatal(errno, "error writing to stdout");
48 }
49
50 /*$ playing
51  *
52  * Expands \fIplaying.tmpl\fR as if there was no special 'playing' action, but
53  * adds a Refresh: field to the HTTP header.  The maximum refresh interval is
54  * defined by \fBrefresh\fR (see \fBdisorder_config\fR(5)) but may be less if
55  * the end of the track is near.
56  */
57 /*$ manage
58  *
59  * Expands \fIplaying.tmpl\fR (NB not \fImanage.tmpl\fR) as if there was no
60  * special 'playing' action, and adds a Refresh: field to the HTTP header.  The
61  * maximum refresh interval is defined by \Bfrefresh\fR (see
62  * \fBdisorder_config\fR(5)) but may be less if the end of the track is near.
63  */
64 static void act_playing(void) {
65   long refresh = config->refresh;
66   long length;
67   time_t now, fin;
68   char *url;
69   const char *action;
70
71   dcgi_lookup(DCGI_PLAYING|DCGI_QUEUE|DCGI_ENABLED|DCGI_RANDOM_ENABLED);
72   if(dcgi_playing
73      && dcgi_playing->state == playing_started /* i.e. not paused */
74      && !disorder_length(dcgi_client, dcgi_playing->track, &length)
75      && length
76      && dcgi_playing->sofar >= 0) {
77     /* Try to put the next refresh at the start of the next track. */
78     time(&now);
79     fin = now + length - dcgi_playing->sofar + config->gap;
80     if(now + refresh > fin)
81       refresh = fin - now;
82   }
83   if(dcgi_queue && dcgi_queue->origin == origin_scratch) {
84     /* next track is a scratch, don't leave more than the inter-track gap */
85     if(refresh > config->gap)
86       refresh = config->gap;
87   }
88   if(!dcgi_playing
89      && ((dcgi_queue
90           && dcgi_queue->origin != origin_random)
91          || dcgi_random_enabled)
92      && dcgi_enabled) {
93     /* no track playing but playing is enabled and there is something coming
94      * up, must be in a gap */
95     if(refresh > config->gap)
96       refresh = config->gap;
97   }
98   if((action = cgi_get("action")))
99     url = cgi_makeurl(config->url, "action", action, (char *)0);
100   else
101     url = config->url;
102   if(printf("Refresh: %ld;url=%s\n",
103             refresh, url) < 0)
104     fatal(errno, "error writing to stdout");
105   dcgi_expand("playing", 1);
106 }
107
108 /*$ disable
109  *
110  * Disables play.
111  */
112 static void act_disable(void) {
113   if(dcgi_client)
114     disorder_disable(dcgi_client);
115   redirect(0);
116 }
117
118 /*$ enable
119  *
120  * Enables play.
121  */
122 static void act_enable(void) {
123   if(dcgi_client)
124     disorder_enable(dcgi_client);
125   redirect(0);
126 }
127
128 /*$ random-disable
129  *
130  * Disables random play.
131  */
132 static void act_random_disable(void) {
133   if(dcgi_client)
134     disorder_random_disable(dcgi_client);
135   redirect(0);
136 }
137
138 /*$ random-enable
139  *
140  * Enables random play.
141  */
142 static void act_random_enable(void) {
143   if(dcgi_client)
144     disorder_random_enable(dcgi_client);
145   redirect(0);
146 }
147
148 /*$ pause
149  *
150  * Pauses the current track (if there is one and it's not paused already).
151  */
152 static void act_pause(void) {
153   if(dcgi_client)
154     disorder_pause(dcgi_client);
155   redirect(0);
156 }
157
158 /*$ resume
159  *
160  * Resumes the current track (if there is one and it's paused).
161  */
162 static void act_resume(void) {
163   if(dcgi_client)
164     disorder_resume(dcgi_client);
165   redirect(0);
166 }
167
168 /*$ remove
169  *
170  * Removes the track given by the \fBid\fR argument.  If this is the currently
171  * playing track then it is scratched.
172  */
173 static void act_remove(void) {
174   const char *id;
175   struct queue_entry *q;
176
177   if(dcgi_client) {
178     if(!(id = cgi_get("id")))
179       error(0, "missing 'id' argument");
180     else if(!(q = dcgi_findtrack(id)))
181       error(0, "unknown queue id %s", id);
182     else if(q->origin == origin_scratch)
183       /* can't scratch scratches */
184       error(0, "does not make sense to scratch or remove %s", id);
185     else if(q->state == playing_paused
186             || q->state == playing_started)
187       /* removing the playing track = scratching */
188       disorder_scratch(dcgi_client, id);
189     else if(q->state == playing_unplayed)
190       /* otherwise it must be in the queue */
191       disorder_remove(dcgi_client, id);
192     else
193       /* various error states */
194       error(0, "does not make sense to scratch or remove %s", id);
195   }
196   redirect(0);
197 }
198
199 /*$ move
200  *
201  * Moves the track given by the \fBid\fR argument the distance given by the
202  * \fBdelta\fR argument.  If this is positive the track is moved earlier in the
203  * queue and if negative, later.
204  */
205 static void act_move(void) {
206   const char *id, *delta;
207   struct queue_entry *q;
208
209   if(dcgi_client) {
210     if(!(id = cgi_get("id")))
211       error(0, "missing 'id' argument");
212     else if(!(delta = cgi_get("delta")))
213       error(0, "missing 'delta' argument");
214     else if(!(q = dcgi_findtrack(id)))
215       error(0, "unknown queue id %s", id);
216     else switch(q->state) {
217     case playing_random:                /* unplayed randomly chosen track */
218     case playing_unplayed:              /* haven't played this track yet */
219       disorder_move(dcgi_client, id, atol(delta));
220       break;
221     default:
222       error(0, "does not make sense to scratch %s", id);
223       break;
224     }
225   }
226   redirect(0);
227 }
228
229 /*$ play
230  *
231  * Play the track given by the \fBtrack\fR argument, or if that is not set all
232  * the tracks in the directory given by the \fBdir\fR argument.
233  */
234 static void act_play(void) {
235   const char *track, *dir;
236   char **tracks;
237   int ntracks, n;
238   struct tracksort_data *tsd;
239   
240   if(dcgi_client) {
241     if((track = cgi_get("track"))) {
242       disorder_play(dcgi_client, track);
243     } else if((dir = cgi_get("dir"))) {
244       if(disorder_files(dcgi_client, dir, 0, &tracks, &ntracks))
245         ntracks = 0;
246       tsd = tracksort_init(ntracks, tracks, "track");
247       for(n = 0; n < ntracks; ++n)
248         disorder_play(dcgi_client, tsd[n].track);
249     }
250   }
251   redirect(0);
252 }
253
254 static int clamp(int n, int min, int max) {
255   if(n < min)
256     return min;
257   if(n > max)
258     return max;
259   return n;
260 }
261
262 /*$ volume
263  *
264  * If the \fBdelta\fR argument is set: adjust both channels by that amount (up
265  * if positive, down if negative).
266  *
267  * Otherwise if \fBleft\fR and \fBright\fR are set, set the channels
268  * independently to those values.
269  */
270 static void act_volume(void) {
271   const char *l, *r, *d;
272   int nd;
273
274   if(dcgi_client) {
275     if((d = cgi_get("delta"))) {
276       dcgi_lookup(DCGI_VOLUME);
277       nd = clamp(atoi(d), -255, 255);
278       disorder_set_volume(dcgi_client,
279                           clamp(dcgi_volume_left + nd, 0, 255),
280                           clamp(dcgi_volume_right + nd, 0, 255));
281     } else if((l = cgi_get("left")) && (r = cgi_get("right")))
282       disorder_set_volume(dcgi_client, atoi(l), atoi(r));
283   }
284   redirect(0);
285 }
286
287 /** @brief Expand the login template with @b @@error set to @p error
288  * @param e Error keyword
289  */
290 static void login_error(const char *e) {
291   dcgi_error_string = e;
292   dcgi_expand("login", 1);
293 }
294
295 /** @brief Log in
296  * @param username Login name
297  * @param password Password
298  * @return 0 on success, non-0 on error
299  *
300  * On error, calls login_error() to expand the login template.
301  */
302 static int login_as(const char *username, const char *password) {
303   disorder_client *c;
304
305   if(dcgi_cookie && dcgi_client)
306     disorder_revoke(dcgi_client);
307   /* We'll need a new connection as we are going to stop being guest */
308   c = disorder_new(0);
309   if(disorder_connect_user(c, username, password)) {
310     login_error("loginfailed");
311     return -1;
312   }
313   /* Generate a cookie so we can log in again later */
314   if(disorder_make_cookie(c, &dcgi_cookie)) {
315     login_error("cookiefailed");
316     return -1;
317   }
318   /* Use the new connection henceforth */
319   dcgi_client = c;
320   dcgi_lookup_reset();
321   return 0;                             /* OK */
322 }
323
324 /*$ login
325  *
326  * If \fBusername\fR and \fBpassword\fR are set (and the username isn't
327  * "guest") then attempt to log in using those credentials.  On success,
328  * redirects to the \fBback\fR argument if that is set, or just expands
329  * \fIlogin.tmpl\fI otherwise, with \fB@status\fR set to \fBloginok\fR.
330  *
331  * If they aren't set then just expands \fIlogin.tmpl\fI.
332  */
333 static void act_login(void) {
334   const char *username, *password;
335
336   /* We try all this even if not connected since the subsequent connection may
337    * succeed. */
338   
339   username = cgi_get("username");
340   password = cgi_get("password");
341   if(!username
342      || !password
343      || !strcmp(username, "guest")/*bodge to avoid guest cookies*/) {
344     /* We're just visiting the login page, not performing an action at all. */
345     dcgi_expand("login", 1);
346     return;
347   }
348   if(!login_as(username, password)) {
349     /* Report the succesful login */
350     dcgi_status_string = "loginok";
351     /* Redirect back to where we came from, if necessary */
352     if(cgi_get("back"))
353       redirect(0);
354     else
355       dcgi_expand("login", 1);
356   }
357 }
358
359 /*$ logout
360  *
361  * Logs out the current user and expands \fIlogin.tmpl\fR with \fBstatus\fR or
362  * \fB@error\fR set according to the result.
363  */
364 static void act_logout(void) {
365   if(dcgi_client) {
366     /* Ask the server to revoke the cookie */
367     if(!disorder_revoke(dcgi_client))
368       dcgi_status_string = "logoutok";
369     else
370       dcgi_error_string = "revokefailed";
371   } else {
372     /* We can't guarantee a logout if we can't connect to the server to revoke
373      * the cookie, so we report an error.  We'll still ask the browser to
374      * forget the cookie though. */
375     dcgi_error_string = "connect";
376   }
377   /* Attempt to reconnect without the cookie */
378   dcgi_cookie = 0;
379   dcgi_login();
380   /* Back to login page, hopefuly forcing the browser to forget the cookie. */
381   dcgi_expand("login", 1);
382 }
383
384 /*$ register
385  *
386  * Register a new user using \fBusername\fR, \fBpassword1\fR, \fBpassword2\fR
387  * and \fBemail\fR and expands \fIlogin.tmpl\fR with \fBstatus\fR or
388  * \fB@error\fR set according to the result.
389  */
390 static void act_register(void) {
391   const char *username, *password, *password2, *email;
392   char *confirm, *content_type;
393   const char *text, *encoding, *charset;
394
395   /* If we're not connected then this is a hopeless exercise */
396   if(!dcgi_client) {
397     login_error("connect");
398     return;
399   }
400
401   /* Collect arguments */
402   username = cgi_get("username");
403   password = cgi_get("password1");
404   password2 = cgi_get("password2");
405   email = cgi_get("email");
406
407   /* Verify arguments */
408   if(!username || !*username) {
409     login_error("nousername");
410     return;
411   }
412   if(!password || !*password) {
413     login_error("nopassword");
414     return;
415   }
416   if(!password2 || !*password2 || strcmp(password, password2)) {
417     login_error("passwordmismatch");
418     return;
419   }
420   if(!email || !*email) {
421     login_error("noemail");
422     return;
423   }
424   /* We could well do better address validation but for now we'll just do the
425    * minimum */
426   if(!email_valid(email)) {
427     login_error("bademail");
428     return;
429   }
430   if(disorder_register(dcgi_client, username, password, email, &confirm)) {
431     login_error("cannotregister");
432     return;
433   }
434   /* Send the user a mail */
435   /* TODO templatize this */
436   byte_xasprintf((char **)&text,
437                  "Welcome to DisOrder.  To active your login, please visit this URL:\n"
438                  "\n"
439                  "%s?c=%s\n", config->url, urlencodestring(confirm));
440   if(!(text = mime_encode_text(text, &charset, &encoding)))
441     fatal(0, "cannot encode email");
442   byte_xasprintf(&content_type, "text/plain;charset=%s",
443                  quote822(charset, 0));
444   sendmail("", config->mail_sender, email, "Welcome to DisOrder",
445            encoding, content_type, text); /* TODO error checking  */
446   /* We'll go back to the login page with a suitable message */
447   dcgi_status_string = "registered";
448   dcgi_expand("login", 1);
449 }
450
451 /*$ confirm
452  *
453  * Confirm a user registration using the nonce supplied in \fBc\fR and expands
454  * \fIlogin.tmpl\fR with \fBstatus\fR or \fB@error\fR set according to the
455  * result.
456  */
457 static void act_confirm(void) {
458   const char *confirmation;
459
460   /* If we're not connected then this is a hopeless exercise */
461   if(!dcgi_client) {
462     login_error("connect");
463     return;
464   }
465
466   if(!(confirmation = cgi_get("c"))) {
467     login_error("noconfirm");
468     return;
469   }
470   /* Confirm our registration */
471   if(disorder_confirm(dcgi_client, confirmation)) {
472     login_error("badconfirm");
473     return;
474   }
475   /* Get a cookie */
476   if(disorder_make_cookie(dcgi_client, &dcgi_cookie)) {
477     login_error("cookiefailed");
478     return;
479   }
480   /* Junk cached data */
481   dcgi_lookup_reset();
482   /* Report success */
483   dcgi_status_string = "confirmed";
484   dcgi_expand("login", 1);
485 }
486
487 /*$ edituser
488  *
489  * Edit user details using \fBusername\fR, \fBchangepassword1\fR,
490  * \fBchangepassword2\fR and \fBemail\fR and expands \fIlogin.tmpl\fR with
491  * \fBstatus\fR or \fB@error\fR set according to the result.
492  */
493 static void act_edituser(void) {
494   const char *email = cgi_get("email"), *password = cgi_get("changepassword1");
495   const char *password2 = cgi_get("changepassword2");
496   int newpassword = 0;
497
498   /* If we're not connected then this is a hopeless exercise */
499   if(!dcgi_client) {
500     login_error("connect");
501     return;
502   }
503
504   /* Verify input */
505
506   /* If either password or password2 is set we insist they match.  If they
507    * don't we report an error. */
508   if((password && *password) || (password2 && *password2)) {
509     if(!password || !password2 || strcmp(password, password2)) {
510       login_error("passwordmismatch");
511       return;
512     }
513   } else
514     password = password2 = 0;
515   if(email && !email_valid(email)) {
516     login_error("bademail");
517     return;
518   }
519
520   /* Commit changes */
521   if(email) {
522     if(disorder_edituser(dcgi_client, disorder_user(dcgi_client),
523                          "email", email)) {
524       login_error("badedit");
525       return;
526     }
527   }
528   if(password) {
529     if(disorder_edituser(dcgi_client, disorder_user(dcgi_client),
530                          "password", password)) {
531       login_error("badedit");
532       return;
533     }
534     newpassword = 1;
535   }
536
537   if(newpassword) {
538     /* If we changed the password, the cookie is now invalid, so we must log
539      * back in. */
540     if(login_as(disorder_user(dcgi_client), password))
541       return;
542   }
543   /* Report success */
544   dcgi_status_string = "edited";
545   dcgi_expand("login", 1);
546 }
547
548 /*$ reminder
549  *
550  * Issue an email password reminder to \fBusername\fR and expands
551  * \fIlogin.tmpl\fR with \fBstatus\fR or \fB@error\fR set according to the
552  * result.
553  */
554 static void act_reminder(void) {
555   const char *const username = cgi_get("username");
556
557   /* If we're not connected then this is a hopeless exercise */
558   if(!dcgi_client) {
559     login_error("connect");
560     return;
561   }
562
563   if(!username || !*username) {
564     login_error("nousername");
565     return;
566   }
567   if(disorder_reminder(dcgi_client, username)) {
568     login_error("reminderfailed");
569     return;
570   }
571   /* Report success */
572   dcgi_status_string = "reminded";
573   dcgi_expand("login", 1);
574 }
575
576 /** @brief Get the numbered version of an argument
577  * @param argname Base argument name
578  * @param numfile File number
579  * @return cgi_get(NUMFILE_ARGNAME)
580  */
581 static const char *numbered_arg(const char *argname, int numfile) {
582   char *fullname;
583
584   byte_xasprintf(&fullname, "%d_%s", numfile, argname);
585   return cgi_get(fullname);
586 }
587
588 /** @brief Set preferences for file @p numfile
589  * @return 0 on success, -1 if there is no such track number
590  *
591  * The old @b nfiles parameter has been abolished, we just keep look for more
592  * files until we run out.
593  */
594 static int process_prefs(int numfile) {
595   const char *file, *name, *value, *part, *parts, *context;
596   char **partslist;
597
598   if(!(file = numbered_arg("track", numfile)))
599     return -1;
600   if(!(parts = cgi_get("parts")))
601     parts = "artist album title";
602   if(!(context = cgi_get("context")))
603     context = "display";
604   partslist = split(parts, 0, 0, 0, 0);
605   while((part = *partslist++)) {
606     if(!(value = numbered_arg(part, numfile)))
607       continue;
608     byte_xasprintf((char **)&name, "trackname_%s_%s", context, part);
609     disorder_set(dcgi_client, file, name, value);
610   }
611   if((value = numbered_arg("random", numfile)))
612     disorder_unset(dcgi_client, file, "pick_at_random");
613   else
614     disorder_set(dcgi_client, file, "pick_at_random", "0");
615   if((value = numbered_arg("tags", numfile))) {
616     if(!*value)
617       disorder_unset(dcgi_client, file, "tags");
618     else
619       disorder_set(dcgi_client, file, "tags", value);
620   }
621   if((value = numbered_arg("weight", numfile))) {
622     if(!*value)
623       disorder_unset(dcgi_client, file, "weight");
624     else
625       disorder_set(dcgi_client, file, "weight", value);
626   }
627   return 0;
628 }
629
630 /*$ prefs
631  *
632  * Set preferences on a number of tracks.
633  *
634  * The tracks to modify are specified in arguments \fB0_track\fR, \fB1_track\fR
635  * etc.  The number sequence must be contiguous and start from 0.
636  *
637  * For each track \fIINDEX\fB_track\fR:
638  * - \fIINDEX\fB_\fIPART\fR is used to set the trackname preference for
639  * that part.  (See \fBparts\fR below.)
640  * - \fIINDEX\fB_\fIrandom\fR if present enables random play for this track
641  * or disables it if absent.
642  * - \fIINDEX\fB_\fItags\fR sets the list of tags for this track.
643  * - \fIINDEX\fB_\fIweight\fR sets the weight for this track.
644  *
645  * \fBparts\fR can be set to the track name parts to modify.  The default is
646  * "artist album title".
647  *
648  * \fBcontext\fR can be set to the context to modify.  The default is
649  * "display".
650  *
651  * If the server detects a preference being set to its default, it removes the
652  * preference, thus keeping the database tidy.
653  */
654 static void act_set(void) {
655   int numfile;
656
657   if(dcgi_client) {
658     for(numfile = 0; !process_prefs(numfile); ++numfile)
659       ;
660   }
661   redirect(0);
662 }
663
664 /** @brief Table of actions */
665 static const struct action {
666   /** @brief Action name */
667   const char *name;
668   /** @brief Action handler */
669   void (*handler)(void);
670   /** @brief Union of suitable rights */
671   rights_type rights;
672 } actions[] = {
673   { "confirm", act_confirm, 0 },
674   { "disable", act_disable, RIGHT_GLOBAL_PREFS },
675   { "edituser", act_edituser, 0 },
676   { "enable", act_enable, RIGHT_GLOBAL_PREFS },
677   { "login", act_login, 0 },
678   { "logout", act_logout, 0 },
679   { "manage", act_playing, 0 },
680   { "move", act_move, RIGHT_MOVE__MASK },
681   { "pause", act_pause, RIGHT_PAUSE },
682   { "play", act_play, RIGHT_PLAY },
683   { "playing", act_playing, 0 },
684   { "randomdisable", act_random_disable, RIGHT_GLOBAL_PREFS },
685   { "randomenable", act_random_enable, RIGHT_GLOBAL_PREFS },
686   { "register", act_register, 0 },
687   { "reminder", act_reminder, 0 },
688   { "remove", act_remove, RIGHT_MOVE__MASK|RIGHT_SCRATCH__MASK },
689   { "resume", act_resume, RIGHT_PAUSE },
690   { "set", act_set, RIGHT_PREFS },
691   { "volume", act_volume, RIGHT_VOLUME },
692 };
693
694 /** @brief Check that an action name is valid
695  * @param name Action
696  * @return 1 if valid, 0 if not
697  */
698 static int dcgi_valid_action(const char *name) {
699   int c;
700
701   /* First character must be letter or digit (this also requires there to _be_
702    * a first character) */
703   if(!isalnum((unsigned char)*name))
704     return 0;
705   /* Only letters, digits, '.' and '-' allowed */
706   while((c = (unsigned char)*name++)) {
707     if(!(isalnum(c)
708          || c == '.'
709          || c == '_'))
710       return 0;
711   }
712   return 1;
713 }
714
715 /** @brief Expand a template
716  * @param name Base name of template, or NULL to consult CGI args
717  * @param header True to write header
718  */
719 void dcgi_expand(const char *name, int header) {
720   const char *p, *found;
721
722   /* Parse macros first */
723   if((found = mx_find("macros.tmpl", 1/*report*/)))
724     mx_expand_file(found, sink_discard(), 0);
725   if((found = mx_find("user.tmpl", 0/*report*/)))
726     mx_expand_file(found, sink_discard(), 0);
727   /* For unknown actions check that they aren't evil */
728   if(!dcgi_valid_action(name))
729     fatal(0, "invalid action name '%s'", name);
730   byte_xasprintf((char **)&p, "%s.tmpl", name);
731   if(!(found = mx_find(p, 0/*report*/)))
732     fatal(errno, "cannot find %s", p);
733   if(header) {
734     if(printf("Content-Type: text/html; charset=UTF-8\n"
735               "%s\n"
736               "\n", dcgi_cookie_header()) < 0)
737       fatal(errno, "error writing to stdout");
738   }
739   if(mx_expand_file(found, sink_stdio("stdout", stdout), 0) == -1
740      || fflush(stdout) < 0)
741     fatal(errno, "error writing to stdout");
742 }
743
744 /** @brief Execute a web action
745  * @param action Action to perform, or NULL to consult CGI args
746  *
747  * If no recognized action is specified then 'playing' is assumed.
748  */
749 void dcgi_action(const char *action) {
750   int n;
751
752   /* Consult CGI args if caller had no view */
753   if(!action)
754     action = cgi_get("action");
755   /* Pick a default if nobody cares at all */
756   if(!action) {
757     /* We allow URLs which are just c=... in order to keep confirmation URLs,
758      * which are user-facing, as short as possible.  Actually we could lose the
759      * c= for this... */
760     if(cgi_get("c"))
761       action = "confirm";
762     else
763       action = "playing";
764     /* Make sure 'action' is always set */
765     cgi_set("action", action);
766   }
767   if((n = TABLE_FIND(actions, name, action)) >= 0) {
768     if(actions[n].rights) {
769       /* Some right or other is required */
770       dcgi_lookup(DCGI_RIGHTS);
771       if(!(actions[n].rights & dcgi_rights)) {
772         const char *back = cgi_thisurl(config->url);
773         /* Failed operations jump you to the login screen with an error
774          * message.  On success, the user comes back to the page they were
775          * after. */
776         cgi_clear();
777         cgi_set("back", back);
778         login_error("noright");
779         return;
780       }
781     }
782     /* It's a known action */
783     actions[n].handler();
784   } else {
785     /* Just expand the template */
786     dcgi_expand(action, 1/*header*/);
787   }
788 }
789
790 /** @brief Generate an error page */
791 void dcgi_error(const char *key) {
792   dcgi_error_string = xstrdup(key);
793   dcgi_expand("error", 1);
794 }
795
796 /*
797 Local Variables:
798 c-basic-offset:2
799 comment-column:40
800 fill-column:79
801 indent-tabs-mode:nil
802 End:
803 */