chiark / gitweb /
Make menu_update() robust against being called before the notebook has
[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 2 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, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * 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, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
18  * USA
19  */
20 /** @file server/actions.c
21  * @brief DisOrder web actions
22  *
23  * Actions are anything that the web interface does beyond passive template
24  * expansion and inspection of state recieved from the server.  This means
25  * playing tracks, editing prefs etc but also setting extra headers e.g. to
26  * auto-refresh the playing list.
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->state == playing_isscratch) {
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->state != playing_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 switch(q->state) {
183     case playing_isscratch:
184     case playing_failed:
185     case playing_no_player:
186     case playing_ok:
187     case playing_quitting:
188     case playing_scratched:
189       error(0, "does not make sense to scratch %s", id);
190       break;
191     case playing_paused:                /* started but paused */
192     case playing_started:               /* started to play */
193       disorder_scratch(dcgi_client, id);
194       break;
195     case playing_random:                /* unplayed randomly chosen track */
196     case playing_unplayed:              /* haven't played this track yet */
197       disorder_remove(dcgi_client, id);
198       break;
199     }
200   }
201   redirect(0);
202 }
203
204 /*! move
205  *
206  * Moves the track given by the \fBid\fR argument the distance given by the
207  * \fBdelta\fR argument.  If this is positive the track is moved earlier in the
208  * queue and if negative, later.
209  */
210 static void act_move(void) {
211   const char *id, *delta;
212   struct queue_entry *q;
213
214   if(dcgi_client) {
215     if(!(id = cgi_get("id")))
216       error(0, "missing 'id' argument");
217     else if(!(delta = cgi_get("delta")))
218       error(0, "missing 'delta' argument");
219     else if(!(q = dcgi_findtrack(id)))
220       error(0, "unknown queue id %s", id);
221     else switch(q->state) {
222     case playing_random:                /* unplayed randomly chosen track */
223     case playing_unplayed:              /* haven't played this track yet */
224       disorder_move(dcgi_client, id, atol(delta));
225       break;
226     default:
227       error(0, "does not make sense to scratch %s", id);
228       break;
229     }
230   }
231   redirect(0);
232 }
233
234 /*! play
235  *
236  * Play the track given by the \fBtrack\fR argument, or if that is not set all
237  * the tracks in the directory given by the \fBdir\fR argument.
238  */
239 static void act_play(void) {
240   const char *track, *dir;
241   char **tracks;
242   int ntracks, n;
243   struct dcgi_entry *e;
244   
245   if(dcgi_client) {
246     if((track = cgi_get("track"))) {
247       disorder_play(dcgi_client, track);
248     } else if((dir = cgi_get("dir"))) {
249       if(disorder_files(dcgi_client, dir, 0, &tracks, &ntracks))
250         ntracks = 0;
251       e = xmalloc(ntracks * sizeof (struct dcgi_entry));
252       for(n = 0; n < ntracks; ++n) {
253         e[n].track = tracks[n];
254         e[n].sort = trackname_transform("track", tracks[n], "sort");
255         e[n].display = trackname_transform("track", tracks[n], "display");
256       }
257       qsort(e, ntracks, sizeof (struct dcgi_entry), dcgi_compare_entry);
258       for(n = 0; n < ntracks; ++n)
259         disorder_play(dcgi_client, e[n].track);
260     }
261   }
262   redirect(0);
263 }
264
265 static int clamp(int n, int min, int max) {
266   if(n < min)
267     return min;
268   if(n > max)
269     return max;
270   return n;
271 }
272
273 /*! volume
274  *
275  * If the \fBdelta\fR argument is set: adjust both channels by that amount (up
276  * if positive, down if negative).
277  *
278  * Otherwise if \fBleft\fR and \fBright\fR are set, set the channels
279  * independently to those values.
280  */
281 static void act_volume(void) {
282   const char *l, *r, *d;
283   int nd;
284
285   if(dcgi_client) {
286     if((d = cgi_get("delta"))) {
287       dcgi_lookup(DCGI_VOLUME);
288       nd = clamp(atoi(d), -255, 255);
289       disorder_set_volume(dcgi_client,
290                           clamp(dcgi_volume_left + nd, 0, 255),
291                           clamp(dcgi_volume_right + nd, 0, 255));
292     } else if((l = cgi_get("left")) && (r = cgi_get("right")))
293       disorder_set_volume(dcgi_client, atoi(l), atoi(r));
294   }
295   redirect(0);
296 }
297
298 /** @brief Expand the login template with @b @@error set to @p error
299  * @param e Error keyword
300  */
301 static void login_error(const char *e) {
302   dcgi_error_string = e;
303   dcgi_expand("login", 1);
304 }
305
306 /** @brief Log in
307  * @param username Login name
308  * @param password Password
309  * @return 0 on success, non-0 on error
310  *
311  * On error, calls login_error() to expand the login template.
312  */
313 static int login_as(const char *username, const char *password) {
314   disorder_client *c;
315
316   if(dcgi_cookie && dcgi_client)
317     disorder_revoke(dcgi_client);
318   /* We'll need a new connection as we are going to stop being guest */
319   c = disorder_new(0);
320   if(disorder_connect_user(c, username, password)) {
321     login_error("loginfailed");
322     return -1;
323   }
324   /* Generate a cookie so we can log in again later */
325   if(disorder_make_cookie(c, &dcgi_cookie)) {
326     login_error("cookiefailed");
327     return -1;
328   }
329   /* Use the new connection henceforth */
330   dcgi_client = c;
331   dcgi_lookup_reset();
332   return 0;                             /* OK */
333 }
334
335 /*! login
336  *
337  * If \fBusername\fR and \fBpassword\fR are set (and the username isn't
338  * "guest") then attempt to log in using those credentials.  On success,
339  * redirects to the \fBback\fR argument if that is set, or just expands
340  * \fIlogin.tmpl\fI otherwise, with \fB@status\fR set to \fBloginok\fR.
341  *
342  * If they aren't set then just expands \fIlogin.tmpl\fI.
343  */
344 static void act_login(void) {
345   const char *username, *password;
346
347   /* We try all this even if not connected since the subsequent connection may
348    * succeed. */
349   
350   username = cgi_get("username");
351   password = cgi_get("password");
352   if(!username
353      || !password
354      || !strcmp(username, "guest")/*bodge to avoid guest cookies*/) {
355     /* We're just visiting the login page, not performing an action at all. */
356     dcgi_expand("login", 1);
357     return;
358   }
359   if(!login_as(username, password)) {
360     /* Report the succesful login */
361     dcgi_status_string = "loginok";
362     /* Redirect back to where we came from, if necessary */
363     if(cgi_get("back"))
364       redirect(0);
365     else
366       dcgi_expand("login", 1);
367   }
368 }
369
370 /*! logout
371  *
372  * Logs out the current user and expands \fIlogin.tmpl\fR with \fBstatus\fR or
373  * \fB@error\fR set according to the result.
374  */
375 static void act_logout(void) {
376   if(dcgi_client) {
377     /* Ask the server to revoke the cookie */
378     if(!disorder_revoke(dcgi_client))
379       dcgi_status_string = "logoutok";
380     else
381       dcgi_error_string = "revokefailed";
382   } else {
383     /* We can't guarantee a logout if we can't connect to the server to revoke
384      * the cookie, so we report an error.  We'll still ask the browser to
385      * forget the cookie though. */
386     dcgi_error_string = "connect";
387   }
388   /* Attempt to reconnect without the cookie */
389   dcgi_cookie = 0;
390   dcgi_login();
391   /* Back to login page, hopefuly forcing the browser to forget the cookie. */
392   dcgi_expand("login", 1);
393 }
394
395 /*! register
396  *
397  * Register a new user using \fBusername\fR, \fBpassword1\fR, \fBpassword2\fR
398  * and \fBemail\fR and expands \fIlogin.tmpl\fR with \fBstatus\fR or
399  * \fB@error\fR set according to the result.
400  */
401 static void act_register(void) {
402   const char *username, *password, *password2, *email;
403   char *confirm, *content_type;
404   const char *text, *encoding, *charset;
405
406   /* If we're not connected then this is a hopeless exercise */
407   if(!dcgi_client) {
408     login_error("connect");
409     return;
410   }
411
412   /* Collect arguments */
413   username = cgi_get("username");
414   password = cgi_get("password1");
415   password2 = cgi_get("password2");
416   email = cgi_get("email");
417
418   /* Verify arguments */
419   if(!username || !*username) {
420     login_error("nousername");
421     return;
422   }
423   if(!password || !*password) {
424     login_error("nopassword");
425     return;
426   }
427   if(!password2 || !*password2 || strcmp(password, password2)) {
428     login_error("passwordmismatch");
429     return;
430   }
431   if(!email || !*email) {
432     login_error("noemail");
433     return;
434   }
435   /* We could well do better address validation but for now we'll just do the
436    * minimum */
437   if(!strchr(email, '@')) {
438     login_error("bademail");
439     return;
440   }
441   if(disorder_register(dcgi_client, username, password, email, &confirm)) {
442     login_error("cannotregister");
443     return;
444   }
445   /* Send the user a mail */
446   /* TODO templatize this */
447   byte_xasprintf((char **)&text,
448                  "Welcome to DisOrder.  To active your login, please visit this URL:\n"
449                  "\n"
450                  "%s?c=%s\n", config->url, urlencodestring(confirm));
451   if(!(text = mime_encode_text(text, &charset, &encoding)))
452     fatal(0, "cannot encode email");
453   byte_xasprintf(&content_type, "text/plain;charset=%s",
454                  quote822(charset, 0));
455   sendmail("", config->mail_sender, email, "Welcome to DisOrder",
456            encoding, content_type, text); /* TODO error checking  */
457   /* We'll go back to the login page with a suitable message */
458   dcgi_status_string = "registered";
459   dcgi_expand("login", 1);
460 }
461
462 /*! confirm
463  *
464  * Confirm a user registration using the nonce supplied in \fBc\fR and expands
465  * \fIlogin.tmpl\fR with \fBstatus\fR or \fB@error\fR set according to the
466  * result.
467  */
468 static void act_confirm(void) {
469   const char *confirmation;
470
471   /* If we're not connected then this is a hopeless exercise */
472   if(!dcgi_client) {
473     login_error("connect");
474     return;
475   }
476
477   if(!(confirmation = cgi_get("c"))) {
478     login_error("noconfirm");
479     return;
480   }
481   /* Confirm our registration */
482   if(disorder_confirm(dcgi_client, confirmation)) {
483     login_error("badconfirm");
484     return;
485   }
486   /* Get a cookie */
487   if(disorder_make_cookie(dcgi_client, &dcgi_cookie)) {
488     login_error("cookiefailed");
489     return;
490   }
491   /* Junk cached data */
492   dcgi_lookup_reset();
493   /* Report success */
494   dcgi_status_string = "confirmed";
495   dcgi_expand("login", 1);
496 }
497
498 /*! edituser
499  *
500  * Edit user details using \fBusername\fR, \fBchangepassword1\fR,
501  * \fBchangepassword2\fR and \fBemail\fR and expands \fIlogin.tmpl\fR with
502  * \fBstatus\fR or \fB@error\fR set according to the result.
503  */
504 static void act_edituser(void) {
505   const char *email = cgi_get("email"), *password = cgi_get("changepassword1");
506   const char *password2 = cgi_get("changepassword2");
507   int newpassword = 0;
508
509   /* If we're not connected then this is a hopeless exercise */
510   if(!dcgi_client) {
511     login_error("connect");
512     return;
513   }
514
515   /* Verify input */
516
517   /* If either password or password2 is set we insist they match.  If they
518    * don't we report an error. */
519   if((password && *password) || (password2 && *password2)) {
520     if(!password || !password2 || strcmp(password, password2)) {
521       login_error("passwordmismatch");
522       return;
523     }
524   } else
525     password = password2 = 0;
526   if(email && !strchr(email, '@')) {
527     login_error("bademail");
528     return;
529   }
530
531   /* Commit changes */
532   if(email) {
533     if(disorder_edituser(dcgi_client, disorder_user(dcgi_client),
534                          "email", email)) {
535       login_error("badedit");
536       return;
537     }
538   }
539   if(password) {
540     if(disorder_edituser(dcgi_client, disorder_user(dcgi_client),
541                          "password", password)) {
542       login_error("badedit");
543       return;
544     }
545     newpassword = 1;
546   }
547
548   if(newpassword) {
549     /* If we changed the password, the cookie is now invalid, so we must log
550      * back in. */
551     if(login_as(disorder_user(dcgi_client), password))
552       return;
553   }
554   /* Report success */
555   dcgi_status_string = "edited";
556   dcgi_expand("login", 1);
557 }
558
559 /*! reminder
560  *
561  * Issue an email password reminder to \fBusername\fR and expands
562  * \fIlogin.tmpl\fR with \fBstatus\fR or \fB@error\fR set according to the
563  * result.
564  */
565 static void act_reminder(void) {
566   const char *const username = cgi_get("username");
567
568   /* If we're not connected then this is a hopeless exercise */
569   if(!dcgi_client) {
570     login_error("connect");
571     return;
572   }
573
574   if(!username || !*username) {
575     login_error("nousername");
576     return;
577   }
578   if(disorder_reminder(dcgi_client, username)) {
579     login_error("reminderfailed");
580     return;
581   }
582   /* Report success */
583   dcgi_status_string = "reminded";
584   dcgi_expand("login", 1);
585 }
586
587 /** @brief Get the numbered version of an argument
588  * @param argname Base argument name
589  * @param numfile File number
590  * @return cgi_get(NUMFILE_ARGNAME)
591  */
592 static const char *numbered_arg(const char *argname, int numfile) {
593   char *fullname;
594
595   byte_xasprintf(&fullname, "%d_%s", numfile, argname);
596   return cgi_get(fullname);
597 }
598
599 /** @brief Set preferences for file @p numfile
600  * @return 0 on success, -1 if there is no such track number
601  *
602  * The old @b nfiles parameter has been abolished, we just keep look for more
603  * files until we run out.
604  */
605 static int process_prefs(int numfile) {
606   const char *file, *name, *value, *part, *parts, *context;
607   char **partslist;
608
609   if(!(file = numbered_arg("track", numfile)))
610     return -1;
611   if(!(parts = cgi_get("parts")))
612     parts = "artist album title";
613   if(!(context = cgi_get("context")))
614     context = "display";
615   partslist = split(parts, 0, 0, 0, 0);
616   while((part = *partslist++)) {
617     if(!(value = numbered_arg(part, numfile)))
618       continue;
619     byte_xasprintf((char **)&name, "trackname_%s_%s", context, part);
620     disorder_set(dcgi_client, file, name, value);
621   }
622   if((value = numbered_arg("random", numfile)))
623     disorder_unset(dcgi_client, file, "pick_at_random");
624   else
625     disorder_set(dcgi_client, file, "pick_at_random", "0");
626   if((value = numbered_arg("tags", numfile))) {
627     if(!*value)
628       disorder_unset(dcgi_client, file, "tags");
629     else
630       disorder_set(dcgi_client, file, "tags", value);
631   }
632   if((value = numbered_arg("weight", numfile))) {
633     if(!*value)
634       disorder_unset(dcgi_client, file, "weight");
635     else
636       disorder_set(dcgi_client, file, "weight", value);
637   }
638   return 0;
639 }
640
641 /*! prefs
642  *
643  * Set preferences on a number of tracks.
644  *
645  * The tracks to modify are specified in arguments \fB0_track\fR, \fB1_track\fR
646  * etc.  The number sequence must be contiguous and start from 0.
647  *
648  * For each track \fIINDEX\fB_track\fR:
649  * - \fIINDEX\fB_\fIPART\fR is used to set the trackname preference for
650  * that part.  (See \fBparts\fR below.)
651  * - \fIINDEX\fB_\fIrandom\fR if present enables random play for this track
652  * or disables it if absent.
653  * - \fIINDEX\fB_\fItags\fR sets the list of tags for this track.
654  * - \fIINDEX\fB_\fIweight\fR sets the weight for this track.
655  *
656  * \fBparts\fR can be set to the track name parts to modify.  The default is
657  * "artist album title".
658  *
659  * \fBcontext\fR can be set to the context to modify.  The default is
660  * "display".
661  *
662  * If the server detects a preference being set to its default, it removes the
663  * preference, thus keeping the database tidy.
664  */
665 static void act_set(void) {
666   int numfile;
667
668   if(dcgi_client) {
669     for(numfile = 0; !process_prefs(numfile); ++numfile)
670       ;
671   }
672   redirect(0);
673 }
674
675 /** @brief Table of actions */
676 static const struct action {
677   /** @brief Action name */
678   const char *name;
679   /** @brief Action handler */
680   void (*handler)(void);
681   /** @brief Union of suitable rights */
682   rights_type rights;
683 } actions[] = {
684   { "confirm", act_confirm, 0 },
685   { "disable", act_disable, RIGHT_GLOBAL_PREFS },
686   { "edituser", act_edituser, 0 },
687   { "enable", act_enable, RIGHT_GLOBAL_PREFS },
688   { "login", act_login, 0 },
689   { "logout", act_logout, 0 },
690   { "manage", act_playing, 0 },
691   { "move", act_move, RIGHT_MOVE__MASK },
692   { "pause", act_pause, RIGHT_PAUSE },
693   { "play", act_play, RIGHT_PLAY },
694   { "playing", act_playing, 0 },
695   { "randomdisable", act_random_disable, RIGHT_GLOBAL_PREFS },
696   { "randomenable", act_random_enable, RIGHT_GLOBAL_PREFS },
697   { "register", act_register, 0 },
698   { "reminder", act_reminder, 0 },
699   { "remove", act_remove, RIGHT_MOVE__MASK|RIGHT_SCRATCH__MASK },
700   { "resume", act_resume, RIGHT_PAUSE },
701   { "set", act_set, RIGHT_PREFS },
702   { "volume", act_volume, RIGHT_VOLUME },
703 };
704
705 /** @brief Check that an action name is valid
706  * @param name Action
707  * @return 1 if valid, 0 if not
708  */
709 static int dcgi_valid_action(const char *name) {
710   int c;
711
712   /* First character must be letter or digit (this also requires there to _be_
713    * a first character) */
714   if(!isalnum((unsigned char)*name))
715     return 0;
716   /* Only letters, digits, '.' and '-' allowed */
717   while((c = (unsigned char)*name++)) {
718     if(!(isalnum(c)
719          || c == '.'
720          || c == '_'))
721       return 0;
722   }
723   return 1;
724 }
725
726 /** @brief Expand a template
727  * @param name Base name of template, or NULL to consult CGI args
728  * @param header True to write header
729  */
730 void dcgi_expand(const char *name, int header) {
731   const char *p, *found;
732
733   /* Parse macros first */
734   if((found = mx_find("macros.tmpl", 1/*report*/)))
735     mx_expand_file(found, sink_discard(), 0);
736   if((found = mx_find("user.tmpl", 0/*report*/)))
737     mx_expand_file(found, sink_discard(), 0);
738   /* For unknown actions check that they aren't evil */
739   if(!dcgi_valid_action(name))
740     fatal(0, "invalid action name '%s'", name);
741   byte_xasprintf((char **)&p, "%s.tmpl", name);
742   if(!(found = mx_find(p, 0/*report*/)))
743     fatal(errno, "cannot find %s", p);
744   if(header) {
745     if(printf("Content-Type: text/html\n"
746               "%s\n"
747               "\n", dcgi_cookie_header()) < 0)
748       fatal(errno, "error writing to stdout");
749   }
750   if(mx_expand_file(found, sink_stdio("stdout", stdout), 0) == -1
751      || fflush(stdout) < 0)
752     fatal(errno, "error writing to stdout");
753 }
754
755 /** @brief Execute a web action
756  * @param action Action to perform, or NULL to consult CGI args
757  *
758  * If no recognized action is specified then 'playing' is assumed.
759  */
760 void dcgi_action(const char *action) {
761   int n;
762
763   /* Consult CGI args if caller had no view */
764   if(!action)
765     action = cgi_get("action");
766   /* Pick a default if nobody cares at all */
767   if(!action) {
768     /* We allow URLs which are just c=... in order to keep confirmation URLs,
769      * which are user-facing, as short as possible.  Actually we could lose the
770      * c= for this... */
771     if(cgi_get("c"))
772       action = "confirm";
773     else
774       action = "playing";
775     /* Make sure 'action' is always set */
776     cgi_set("action", action);
777   }
778   if((n = TABLE_FIND(actions, name, action)) >= 0) {
779     if(actions[n].rights) {
780       /* Some right or other is required */
781       dcgi_lookup(DCGI_RIGHTS);
782       if(!(actions[n].rights & dcgi_rights)) {
783         const char *back = cgi_thisurl(config->url);
784         /* Failed operations jump you to the login screen with an error
785          * message.  On success, the user comes back to the page they were
786          * after. */
787         cgi_clear();
788         cgi_set("back", back);
789         login_error("noright");
790         return;
791       }
792     }
793     /* It's a known action */
794     actions[n].handler();
795   } else {
796     /* Just expand the template */
797     dcgi_expand(action, 1/*header*/);
798   }
799 }
800
801 /** @brief Generate an error page */
802 void dcgi_error(const char *key) {
803   dcgi_error_string = xstrdup(key);
804   dcgi_expand("error", 1);
805 }
806
807 /*
808 Local Variables:
809 c-basic-offset:2
810 comment-column:40
811 fill-column:79
812 indent-tabs-mode:nil
813 End:
814 */