chiark / gitweb /
examples/disorder.init.in: Read settings from `/etc/default/disorder'.
[disorder] / lib / client.c
1 /*
2  * This file is part of DisOrder.
3  * Copyright (C) 2004-13 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 lib/client.c
19  * @brief Simple C client
20  *
21  * See @ref lib/eclient.c for an asynchronous-capable client
22  * implementation.
23  */
24
25 #include "common.h"
26
27 #include <sys/types.h>
28 #if HAVE_SYS_SOCKET_H
29 # include <sys/socket.h>
30 #endif
31 #if HAVE_NETINET_IN_H
32 # include <netinet/in.h>
33 #endif
34 #if HAVE_SYS_UN_H
35 # include <sys/un.h>
36 #endif
37 #if HAVE_UNISTD_H
38 # include <unistd.h>
39 #endif
40 #include <errno.h>
41 #if HAVE_NETDB_H
42 # include <netdb.h>
43 #endif
44
45 #include "log.h"
46 #include "mem.h"
47 #include "queue.h"
48 #include "client.h"
49 #include "charset.h"
50 #include "hex.h"
51 #include "split.h"
52 #include "vector.h"
53 #include "inputline.h"
54 #include "kvp.h"
55 #include "syscalls.h"
56 #include "printf.h"
57 #include "sink.h"
58 #include "addr.h"
59 #include "authhash.h"
60 #include "client-common.h"
61 #include "rights.h"
62 #include "kvp.h"
63 #include "socketio.h"
64
65 /** @brief Client handle contents */
66 struct disorder_client {
67   /** @brief Stream to read from */
68   struct source *input;
69   /** @brief Stream to write to */
70   struct sink *output;
71   /** @brief Peer description */
72   char *ident;
73   /** @brief Username */
74   char *user;
75   /** @brief Report errors to @c stderr */
76   int verbose;
77   /** @brief Last error string */
78   const char *last;
79   /** @brief Address family */
80   int family;
81   /** @brief True if open */
82   int open;
83   /** @brief Socket I/O context */
84   struct socketio sio;
85   /** @brief Whether to try to open a privileged connection */
86   int trypriv;
87 };
88
89 /** @brief Create a new client
90  * @param verbose If nonzero, write extra junk to stderr
91  * @return Pointer to new client
92  *
93  * You must call disorder_connect(), disorder_connect_user() or
94  * disorder_connect_cookie() to connect it.  Use disorder_close() to
95  * dispose of the client when finished with it.
96  */
97 disorder_client *disorder_new(int verbose) {
98   disorder_client *c = xmalloc(sizeof (struct disorder_client));
99
100   c->verbose = verbose;
101   c->family = -1;
102   c->trypriv = 1;
103   return c;
104 }
105
106 /** @brief Don't try to make a privileged connection
107  * @param c Client
108  *
109  * You must call this before any of the connection functions (e.g.,
110  * disorder_connect(), disorder_connect_user()), if at all.
111  */
112 void disorder_force_unpriv(disorder_client *c) {
113   assert(!c->open);
114   c->trypriv = 0;
115 }
116
117 /** @brief Return the address family used by this client */
118 int disorder_client_af(disorder_client *c) {
119   return c->family;
120 }
121
122 /** @brief Read a response line
123  * @param c Client
124  * @param rp Where to store response, or NULL (UTF-8)
125  * @return Response code 0-999 or -1 on error
126  */
127 static int response(disorder_client *c, char **rp) {
128   char *r;
129   char errbuf[1024];
130
131   if(inputlines(c->ident, c->input, &r, '\n')) {
132     byte_xasprintf((char **)&c->last, "input error: %s",
133                    format_error(c->input->eclass, source_err(c->input), errbuf, sizeof errbuf));
134     return -1;
135   }
136   D(("response: %s", r));
137   if(rp)
138     *rp = r;
139   if(r[0] >= '0' && r[0] <= '9'
140      && r[1] >= '0' && r[1] <= '9'
141      && r[2] >= '0' && r[2] <= '9'
142      && r[3] == ' ') {
143     c->last = r + 4;
144     return (r[0] * 10 + r[1]) * 10 + r[2] - 111 * '0';
145   } else {
146     c->last = "invalid reply format";
147     disorder_error(0, "invalid reply format from %s", c->ident);
148     return -1;
149   }
150 }
151
152 /** @brief Return last response string
153  * @param c Client
154  * @return Last response string (UTF-8, English) or NULL
155  */
156 const char *disorder_last(disorder_client *c) {
157   return c->last;
158 }
159
160 /** @brief Read and partially parse a response
161  * @param c Client
162  * @param rp Where to store response text (or NULL) (UTF-8)
163  * @return 0 on success, non-0 on error
164  *
165  * 5xx responses count as errors.
166  *
167  * @p rp will NOT be filled in for xx9 responses (where it is just
168  * commentary for a command where it would normally be meaningful).
169  *
170  * NB that the response will NOT be converted to the local encoding.
171  */
172 static int check_response(disorder_client *c, char **rp) {
173   int rc;
174   char *r;
175
176   if((rc = response(c, &r)) == -1)
177     return -1;
178   else if(rc / 100 == 2) {
179     if(rp)
180       *rp = (rc % 10 == 9) ? 0 : xstrdup(r + 4);
181     xfree(r);
182     return 0;
183   } else {
184     if(c->verbose)
185       disorder_error(0, "from %s: %s", c->ident, utf82mb(r));
186     xfree(r);
187     return rc;
188   }
189 }
190
191 /** @brief Issue a command and parse a simple response
192  * @param c Client
193  * @param rp Where to store result, or NULL
194  * @param cmd Command
195  * @param ap Arguments (UTF-8), terminated by (char *)0
196  * @return 0 on success, non-0 on error
197  *
198  * 5xx responses count as errors.
199  *
200  * @p rp will NOT be filled in for xx9 responses (where it is just
201  * commentary for a command where it would normally be meaningful).
202  *
203  * NB that the response will NOT be converted to the local encoding
204  * nor will quotes be stripped.  See dequote().
205  *
206  * Put @ref disorder__body in the argument list followed by a char **
207  * and int giving the body to follow the command.  If the int is @c -1
208  * then the list is assumed to be NULL-terminated.  This may be used
209  * only once.
210  *
211  * Put @ref disorder__list in the argument list followed by a char **
212  * and int giving a list of arguments to include.  If the int is @c -1
213  * then the list is assumed to be NULL-terminated.  This may be used
214  * any number of times.
215  *
216  * Put @ref disorder__integer in the argument list followed by a long to
217  * send its value in decimal.  This may be used any number of times.
218  *
219  * Put @ref disorder__time in the argument list followed by a time_t
220  * to send its value in decimal.  This may be used any number of
221  * times.
222  *
223  * Usually you would call this via one of the following interfaces:
224  * - disorder_simple()
225  */
226 static int disorder_simple_v(disorder_client *c,
227                              char **rp,
228                              const char *cmd,
229                              va_list ap) {
230   const char *arg;
231   struct dynstr d;
232   char **body = NULL;
233   int nbody = 0;
234   int has_body = 0;
235   char errbuf[1024];
236
237   if(!c->open) {
238     c->last = "not connected";
239     disorder_error(0, "not connected to server");
240     return -1;
241   }
242   if(cmd) {
243     dynstr_init(&d);
244     dynstr_append_string(&d, cmd);
245     while((arg = va_arg(ap, const char *))) {
246       if(arg == disorder__body) {
247         body = va_arg(ap, char **);
248         nbody = va_arg(ap, int);
249         has_body = 1;
250       } else if(arg == disorder__list) {
251         char **list = va_arg(ap, char **);
252         int nlist = va_arg(ap, int);
253         int n;
254         if(nlist < 0) {
255           for(nlist = 0; list[nlist]; ++nlist)
256             ;
257         }
258         for(n = 0; n < nlist; ++n) {
259           dynstr_append(&d, ' ');
260           dynstr_append_string(&d, quoteutf8(arg));
261         }
262       } else if(arg == disorder__integer) {
263         long n = va_arg(ap, long);
264         char buffer[16];
265         byte_snprintf(buffer, sizeof buffer, "%ld", n);
266         dynstr_append(&d, ' ');
267         dynstr_append_string(&d, buffer);
268       } else if(arg == disorder__time) {
269         time_t n = va_arg(ap, time_t);
270         char buffer[16];
271         byte_snprintf(buffer, sizeof buffer, "%lld", (long long)n);
272         dynstr_append(&d, ' ');
273         dynstr_append_string(&d, buffer);
274       } else {
275         dynstr_append(&d, ' ');
276         dynstr_append_string(&d, quoteutf8(arg));
277       }
278     }
279     dynstr_append(&d, '\n');
280     dynstr_terminate(&d);
281     D(("command: %s", d.vec));
282     if(sink_write(c->output, d.vec, d.nvec) < 0)
283       goto write_error;
284     xfree(d.vec);
285     if(has_body) {
286       int n;
287       if(nbody < 0)
288         for(nbody = 0; body[nbody]; ++nbody)
289           ;
290       for(n = 0; n < nbody; ++n) {
291         if(body[n][0] == '.')
292           if(sink_writec(c->output, '.') < 0)
293             goto write_error;
294         if(sink_writes(c->output, body[n]) < 0)
295           goto write_error;
296         if(sink_writec(c->output, '\n') < 0)
297           goto write_error;
298       }
299       if(sink_writes(c->output, ".\n") < 0)
300         goto write_error;
301     }
302     if(sink_flush(c->output))
303       goto write_error;
304   }
305   return check_response(c, rp);
306 write_error:
307   byte_xasprintf((char **)&c->last, "write error: %s", 
308                  format_error(c->output->eclass, sink_err(c->output), errbuf, sizeof errbuf));
309   disorder_error(0, "%s: %s", c->ident, c->last);
310   return -1;
311 }
312
313 /** @brief Issue a command and parse a simple response
314  * @param c Client
315  * @param rp Where to store result, or NULL (UTF-8)
316  * @param cmd Command
317  * @return 0 on success, non-0 on error
318  *
319  * The remaining arguments are command arguments, terminated by (char
320  * *)0.  They should be in UTF-8.
321  *
322  * 5xx responses count as errors.
323  *
324  * @p rp will NOT be filled in for xx9 responses (where it is just
325  * commentary for a command where it would normally be meaningful).
326  *
327  * NB that the response will NOT be converted to the local encoding
328  * nor will quotes be stripped.  See dequote().
329  */
330 static int disorder_simple(disorder_client *c,
331                            char **rp,
332                            const char *cmd, ...) {
333   va_list ap;
334   int ret;
335
336   va_start(ap, cmd);
337   ret = disorder_simple_v(c, rp, cmd, ap);
338   va_end(ap);
339   return ret;
340 }
341
342 /** @brief Issue a command and split the response
343  * @param c Client
344  * @param vecp Where to store results
345  * @param nvecp Where to store count of results
346  * @param expected Expected count (or -1 to not check)
347  * @param cmd Command
348  * @return 0 on success, non-0 on error
349  *
350  * The remaining arguments are command arguments, terminated by (char
351  * *)0.  They should be in UTF-8.
352  *
353  * 5xx responses count as errors.
354  *
355  * @p rp will NOT be filled in for xx9 responses (where it is just
356  * commentary for a command where it would normally be meaningful).
357  *
358  * NB that the response will NOT be converted to the local encoding
359  * nor will quotes be stripped.  See dequote().
360  */
361 static int disorder_simple_split(disorder_client *c,
362                                  char ***vecp,
363                                  int *nvecp,
364                                  int expected,
365                                  const char *cmd, ...) {
366   va_list ap;
367   int ret;
368   char *r;
369   char **vec;
370   int nvec;
371
372   va_start(ap, cmd);
373   ret = disorder_simple_v(c, &r, cmd, ap);
374   va_end(ap);
375   if(!ret) {
376     vec = split(r, &nvec, SPLIT_QUOTES, 0, 0);
377     xfree(r);
378     if(expected < 0 || nvec == expected) {
379       *vecp = vec;
380       *nvecp = nvec;
381     } else {
382       disorder_error(0, "malformed reply to %s", cmd);
383       c->last = "malformed reply";
384       ret = -1;
385       free_strings(nvec, vec);
386     }
387   }
388   if(ret) {
389     *vecp = NULL;
390     *nvecp = 0;
391   }
392   return ret;
393 }
394
395 /** @brief Dequote a result string
396  * @param rc 0 on success, non-0 on error
397  * @param rp Where result string is stored (UTF-8)
398  * @return @p rc
399  *
400  * This is used as a wrapper around disorder_simple() to dequote
401  * results in place.
402  */
403 static int dequote(int rc, char **rp) {
404   char **rr;
405
406   if(!rc) {
407     if((rr = split(*rp, 0, SPLIT_QUOTES, 0, 0)) && *rr) {
408       xfree(*rp);
409       *rp = *rr;
410       xfree(rr);
411       return 0;
412     }
413     disorder_error(0, "invalid reply: %s", *rp);
414   }
415   return rc;
416 }
417
418 /** @brief Generic connection routine
419  * @param conf Configuration to follow
420  * @param c Client
421  * @param username Username to log in with or NULL
422  * @param password Password to log in with or NULL
423  * @param cookie Cookie to log in with or NULL
424  * @return 0 on success, non-0 on error
425  *
426  * @p cookie is tried first if not NULL.  If it is NULL then @p
427  * username must not be.  If @p username is not NULL then nor may @p
428  * password be.
429  */
430 int disorder_connect_generic(struct config *conf,
431                              disorder_client *c,
432                              const char *username,
433                              const char *password,
434                              const char *cookie) {
435   SOCKET sd = INVALID_SOCKET;
436   int nrvec = 0, rc;
437   unsigned char *nonce = NULL;
438   size_t nl;
439   char *res = NULL;
440   char *r = NULL, **rvec = NULL;
441   const char *protocol, *algorithm, *challenge;
442   struct sockaddr *sa = NULL;
443   socklen_t salen;
444   char errbuf[1024];
445
446   if((salen = disorder_find_server(conf,
447                                    (c->trypriv ? 0 : DISORDER_FS_NOTPRIV),
448                                    &sa, &c->ident)) == (socklen_t)-1)
449     return -1;
450   c->input = 0;
451   c->output = 0;
452   if((sd = socket(sa->sa_family, SOCK_STREAM, 0)) < 0) {
453     byte_xasprintf((char **)&c->last, "socket: %s",
454                    format_error(ec_socket, socket_error(), errbuf, sizeof errbuf));
455     disorder_error(0, "%s", c->last);
456     return -1;
457   }
458   c->family = sa->sa_family;
459   if(connect(sd, sa, salen) < 0) {
460     byte_xasprintf((char **)&c->last, "connect: %s",
461                    format_error(ec_socket, socket_error(), errbuf, sizeof errbuf));
462     disorder_error(0, "%s", c->last);
463     goto error;
464   }
465   socketio_init(&c->sio, sd);
466   c->open = 1;
467   sd = INVALID_SOCKET;
468   c->output = sink_socketio(&c->sio);
469   c->input = source_socketio(&c->sio);
470   if((rc = disorder_simple(c, &r, 0, (const char *)0)))
471     goto error_rc;
472   if(!(rvec = split(r, &nrvec, SPLIT_QUOTES, 0, 0)))
473     goto error;
474   if(nrvec != 3) {
475     c->last = "cannot parse server greeting";
476     disorder_error(0, "cannot parse server greeting %s", r);
477     goto error;
478   }
479   protocol = rvec[0];
480   if(strcmp(protocol, "2")) {
481     c->last = "unknown protocol version";
482     disorder_error(0, "unknown protocol version: %s", protocol);
483     goto error;
484   }
485   algorithm = rvec[1];
486   challenge = rvec[2];
487   if(!(nonce = unhex(challenge, &nl)))
488     goto error;
489   if(cookie) {
490     if(!dequote(disorder_simple(c, &c->user, "cookie", cookie, (char *)0),
491                 &c->user))
492       return 0;                         /* success */
493     if(!username) {
494       c->last = "cookie failed and no username";
495       disorder_error(0, "cookie did not work and no username available");
496       goto error;
497     }
498   }
499   if(!(res = authhash(nonce, nl, password, algorithm))) {
500     c->last = "error computing authorization hash";
501     goto error;
502   }
503   if((rc = disorder_simple(c, 0, "user", username, res, (char *)0)))
504     goto error_rc;
505   c->user = xstrdup(username);
506   xfree(res);
507   free_strings(nrvec, rvec);
508   xfree(nonce);
509   xfree(sa);
510   xfree(r);
511   return 0;
512 error:
513   rc = -1;
514 error_rc:
515   xfree(c->output);
516   c->output = NULL;
517   xfree(c->input);
518   c->input = NULL;
519   if(c->open) { socketio_close(&c->sio); c->open = 0; }
520   if(sd != INVALID_SOCKET) closesocket(sd);
521   return rc;
522 }
523
524 /** @brief Connect a client with a specified username and password
525  * @param c Client
526  * @param username Username to log in with
527  * @param password Password to log in with
528  * @return 0 on success, non-0 on error
529  */
530 int disorder_connect_user(disorder_client *c,
531                           const char *username,
532                           const char *password) {
533   return disorder_connect_generic(config,
534                                   c,
535                                   username,
536                                   password,
537                                   0);
538 }
539
540 /** @brief Connect a client
541  * @param c Client
542  * @return 0 on success, non-0 on error
543  *
544  * The connection will use the username and password found in @ref
545  * config, or directly from the database if no password is found and
546  * the database is readable (usually only for root).
547  */
548 int disorder_connect(disorder_client *c) {
549   const char *username, *password;
550
551   if(!(username = config->username)) {
552     c->last = "no username";
553     disorder_error(0, "no username configured");
554     return -1;
555   }
556   password = config->password;
557   /* If we're connecting as 'root' guess that we're the system root
558    * user (or the jukebox user), both of which can use the privileged
559    * socket.  They can also furtle with the db directly: that is why
560    * privileged socket does not represent a privilege escalation. */
561   if(!password
562      && !strcmp(username, "root"))
563     password = "anything will do for root";
564   if(!password) {
565     /* Oh well */
566     c->last = "no password";
567     disorder_error(0, "no password configured for user '%s'", username);
568     return -1;
569   }
570   return disorder_connect_generic(config,
571                                   c,
572                                   username,
573                                   password,
574                                   0);
575 }
576
577 /** @brief Connect a client
578  * @param c Client
579  * @param cookie Cookie to log in with, or NULL
580  * @return 0 on success, non-0 on error
581  *
582  * If @p cookie is NULL or does not work then we attempt to log in as
583  * guest instead (so when the cookie expires only an extra round trip
584  * is needed rather than a complete new login).
585  */
586 int disorder_connect_cookie(disorder_client *c,
587                             const char *cookie) {
588   return disorder_connect_generic(config,
589                                   c,
590                                   "guest",
591                                   "",
592                                   cookie);
593 }
594
595 /** @brief Close a client
596  * @param c Client
597  * @return 0 on succcess, non-0 on errior
598  *
599  * The client is still closed even on error.  It might well be
600  * appropriate to ignore the return value.
601  */
602 int disorder_close(disorder_client *c) {
603   int ret = 0;
604
605   if(c->open)
606     socketio_close(&c->sio);
607   xfree(c->output);
608   c->output = NULL;
609   xfree(c->input);
610   c->input = NULL;
611   xfree(c->ident);
612   c->ident = 0;
613   xfree(c->user);
614   c->user = 0;
615   return ret;
616 }
617
618 static void client_error(const char *msg,
619                          void attribute((unused)) *u) {
620   disorder_error(0, "error parsing reply: %s", msg);
621 }
622
623 /** @brief Get a single queue entry
624  * @param c Client
625  * @param cmd Command
626  * @param qp Where to store track information
627  * @return 0 on success, non-0 on error
628  */
629 static int onequeue(disorder_client *c, const char *cmd,
630                     struct queue_entry **qp) {
631   char *r;
632   struct queue_entry *q;
633   int rc;
634
635   if((rc = disorder_simple(c, &r, cmd, (char *)0)))
636     return rc;
637   if(r) {
638     q = xmalloc(sizeof *q);
639     if(queue_unmarshall(q, r, client_error, 0))
640       return -1;
641     *qp = q;
642   } else
643     *qp = 0;
644   return 0;
645 }
646
647 /** @brief Fetch the queue, recent list, etc */
648 static int readqueue(disorder_client *c,
649                      struct queue_entry **qp) {
650   struct queue_entry *qh, **qt = &qh, *q;
651   char *l;
652   char errbuf[1024];
653
654   while(inputlines(c->ident, c->input, &l, '\n') >= 0) {
655     if(!strcmp(l, ".")) {
656       *qt = 0;
657       *qp = qh;
658       xfree(l);
659       return 0;
660     }
661     q = xmalloc(sizeof *q);
662     if(!queue_unmarshall(q, l, client_error, 0)) {
663       *qt = q;
664       qt = &q->next;
665     }
666     xfree(l);
667   }
668   if(source_err(c->input)) {
669     byte_xasprintf((char **)&c->last, "input error: %s",
670                    format_error(c->input->eclass, source_err(c->input), errbuf, sizeof errbuf));
671   } else {
672     c->last = "input error: unexpected EOF";
673   }
674   disorder_error(0, "%s: %s", c->ident, c->last);
675   return -1;
676 }
677
678 /** @brief Read a dot-stuffed list
679  * @param c Client
680  * @param vecp Where to store list (UTF-8)
681  * @param nvecp Where to store number of items, or NULL
682  * @return 0 on success, non-0 on error
683  *
684  * The list will have a final NULL not counted in @p nvecp.
685  */
686 static int readlist(disorder_client *c, char ***vecp, int *nvecp) {
687   char *l;
688   struct vector v;
689   char errbuf[1024];
690
691   vector_init(&v);
692   while(inputlines(c->ident, c->input, &l, '\n') >= 0) {
693     if(!strcmp(l, ".")) {
694       vector_terminate(&v);
695       if(nvecp)
696         *nvecp = v.nvec;
697       *vecp = v.vec;
698       xfree(l);
699       return 0;
700     }
701     vector_append(&v, xstrdup(l + (*l == '.')));
702     xfree(l);
703   }
704   if(source_err(c->input)) {
705     byte_xasprintf((char **)&c->last, "input error: %s",
706                    format_error(c->input->eclass, source_err(c->input), errbuf, sizeof errbuf));
707   } else {
708     c->last = "input error: unexpxected EOF";
709   }
710   disorder_error(0, "%s: %s", c->ident, c->last);
711   return -1;
712 }
713
714 /** @brief Return the user we logged in with
715  * @param c Client
716  * @return User name (owned by @p c, don't modify)
717  */
718 char *disorder_user(disorder_client *c) {
719   return c->user;
720 }
721
722 static void pairlist_error_handler(const char *msg,
723                                void attribute((unused)) *u) {
724   disorder_error(0, "error handling key-value pair reply: %s", msg);
725 }
726
727 /** @brief Get a list of key-value pairs
728  * @param c Client
729  * @param kp Where to store linked list of preferences
730  * @param cmd Command
731  * @param ... Arguments
732  * @return 0 on success, non-0 on error
733  */
734 static int pairlist(disorder_client *c, struct kvp **kp, const char *cmd, ...) {
735   char **vec, **pvec;
736   int nvec, npvec, n, rc;
737   struct kvp *k;
738   va_list ap;
739
740   va_start(ap, cmd);
741   rc = disorder_simple_v(c, 0, cmd, ap);
742   va_end(ap);
743   if(rc)
744     return rc;
745   if((rc = readlist(c, &vec, &nvec)))
746      return rc;
747   for(n = 0; n < nvec; ++n) {
748     if(!(pvec = split(vec[n], &npvec, SPLIT_QUOTES, pairlist_error_handler, 0)))
749       return -1;
750     if(npvec != 2) {
751       pairlist_error_handler("malformed response", 0);
752       return -1;
753     }
754     *kp = k = xmalloc(sizeof *k);
755     k->name = pvec[0];
756     k->value = pvec[1];
757     kp = &k->next;
758     xfree(pvec);
759   }
760   free_strings(nvec, vec);
761   *kp = 0;
762   return 0;
763 }
764
765 #if _WIN32
766 # define boolean bodge_boolean
767 #endif
768
769 /** @brief Parse a boolean response
770  * @param cmd Command for use in error messsage
771  * @param value Result from server
772  * @param flagp Where to store result
773  * @return 0 on success, non-0 on error
774  */
775 static int boolean(const char *cmd, const char *value,
776                    int *flagp) {
777   if(!strcmp(value, "yes")) *flagp = 1;
778   else if(!strcmp(value, "no")) *flagp = 0;
779   else {
780     disorder_error(0, "malformed response to '%s'", cmd);
781     return -1;
782   }
783   return 0;
784 }
785
786 /** @brief Log to a sink
787  * @param c Client
788  * @param s Sink to write log lines to
789  * @return 0 on success, non-0 on error
790  */
791 int disorder_log(disorder_client *c, struct sink *s) {
792   char *l;
793   int rc;
794   char errbuf[1024];
795     
796   if((rc = disorder_simple(c, 0, "log", (char *)0)))
797     return rc;
798   while(inputlines(c->ident, c->input, &l, '\n') >= 0 && strcmp(l, "."))
799     if(sink_printf(s, "%s\n", l) < 0) return -1;
800   if(source_err(c->input)) {
801     byte_xasprintf((char **)&c->last, "input error: %s",
802                    format_error(c->input->eclass, source_err(c->input), errbuf, sizeof errbuf));
803     return -1;
804   } else if(source_eof(c->input)) {
805     byte_xasprintf((char **)&c->last, "input error: unexpected EOF");
806     return -1;
807   }
808
809   return 0;
810 }
811
812 #include "client-stubs.c"
813
814 /*
815 Local Variables:
816 c-basic-offset:2
817 comment-column:40
818 End:
819 */