command.c

   1 /* Copyright (C) 1997 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
   2
   3 /** \file command.c Client authentication and server commands. */
   4
   5 #include <netinet/in.h>
   6 #include <sys/socket.h>
   7 #include <regex.h>
   8 #include <signal.h>
   9 #include <sys/types.h>
  10 #include <osl.h>
  11 #include <arpa/inet.h>
  12 #include <sys/un.h>
  13 #include <netdb.h>
  14 #include <lopsub.h>
  15
  16 #include "server.lsg.h"
  17 #include "para.h"
  18 #include "error.h"
  19 #include "lsu.h"
  20 #include "crypt.h"
  21 #include "sideband.h"
  22 #include "command.h"
  23 #include "string.h"
  24 #include "afh.h"
  25 #include "afs.h"
  26 #include "net.h"
  27 #include "server.h"
  28 #include "list.h"
  29 #include "send.h"
  30 #include "sched.h"
  31 #include "vss.h"
  32 #include "daemon.h"
  33 #include "fd.h"
  34 #include "ipc.h"
  35 #include "server_cmd.lsg.h"
  36 #include "user_list.h"
  37 #include "signal.h"
  38 #include "version.h"
  39
  40 #define SERVER_CMD_AUX_INFO(_arg) _arg,
  41 static const unsigned server_command_perms[] = {LSG_SERVER_CMD_AUX_INFOS};
  42 #undef SERVER_CMD_AUX_INFO
  43 #define SERVER_CMD_AUX_INFO(_arg) #_arg,
  44 static const char * const server_command_perms_txt[] = {LSG_SERVER_CMD_AUX_INFOS};
  45 #undef SERVER_CMD_AUX_INFO
  46
  47 /** Commands including options must be shorter than this. */
  48 #define MAX_COMMAND_LEN 32768
  49
  50 extern int mmd_mutex;
  51 extern struct misc_meta_data *mmd;
  52 int send_afs_status(struct command_context *cc, int parser_friendly);
  53 static bool subcmd_should_die;
  54
  55 static void command_handler_sighandler(int s)
  56 {
  57         if (s != SIGTERM)
  58                 return;
  59         PARA_EMERG_LOG("terminating on signal %d\n", SIGTERM);
  60         subcmd_should_die = true;
  61 }
  62
  63 /*
  64  * Compute human readable vss status text.
  65  *
  66  * We can't call vss_playing() and friends here because those functions read
  67  * the flags from the primary mmd structure, so calling them from command
  68  * handler context would require to take the mmd lock. At the time the function
  69  * is called we already took a copy of the mmd structure and want to use the
  70  * flags value of the copy for computing the vss status text.
  71  */
  72 static char *vss_status_tohuman(unsigned int flags)
  73 {
  74         if (flags & VSS_PLAYING)
  75                 return para_strdup("playing");
  76         if (flags & VSS_NEXT)
  77                 return para_strdup("stopped");
  78         return para_strdup("paused");
  79 }
  80
  81 /*
  82  * Never returns NULL.
  83  */
  84 static char *vss_get_status_flags(unsigned int flags)
  85 {
  86         char *msg = para_malloc(5 * sizeof(char));
  87
  88         msg[0] = (flags & VSS_PLAYING)? 'P' : '_';
  89         msg[1] = (flags & VSS_NOMORE)? 'O' : '_';
  90         msg[2] = (flags & VSS_NEXT)? 'N' : '_';
  91         msg[3] = (flags & VSS_REPOS)? 'R' : '_';
  92         msg[4] = '\0';
  93         return msg;
  94 }
  95
  96 static unsigned get_status(struct misc_meta_data *nmmd, bool parser_friendly,
  97                 char **result)
  98 {
  99         char *status, *flags; /* vss status info */
 100         /* nobody updates our version of "now" */
 101         long offset = (nmmd->offset + 500) / 1000;
 102         struct timeval current_time;
 103         struct para_buffer b = {.flags = parser_friendly? PBF_SIZE_PREFIX : 0};
 104
 105         /* report real status */
 106         status = vss_status_tohuman(nmmd->vss_status_flags);
 107         flags = vss_get_status_flags(nmmd->vss_status_flags);
 108         clock_get_realtime(&current_time);
 109         /*
 110          * The calls to WRITE_STATUS_ITEM() below never fail because
 111          * b->max_size is zero (unlimited), see \ref para_printf(). However,
 112          * clang is not smart enough to prove this and complains nevertheless.
 113          * Casting the return value to void silences clang.
 114          */
 115         (void)WRITE_STATUS_ITEM(&b, SI_status, "%s\n", status);
 116         (void)WRITE_STATUS_ITEM(&b, SI_status_flags, "%s\n", flags);
 117         (void)WRITE_STATUS_ITEM(&b, SI_offset, "%li\n", offset);
 118         (void)WRITE_STATUS_ITEM(&b, SI_afs_mode, "%s\n", mmd->afs_mode_string);
 119         (void)WRITE_STATUS_ITEM(&b, SI_stream_start, "%lu.%lu\n",
 120                 (long unsigned)nmmd->stream_start.tv_sec,
 121                 (long unsigned)nmmd->stream_start.tv_usec);
 122         (void)WRITE_STATUS_ITEM(&b, SI_current_time, "%lu.%lu\n",
 123                 (long unsigned)current_time.tv_sec,
 124                 (long unsigned)current_time.tv_usec);
 125         free(flags);
 126         free(status);
 127         *result = b.buf;
 128         return b.offset;
 129 }
 130
 131 /**
 132  * Send a sideband packet through a blocking file descriptor.
 133  *
 134  * \param scc fd and crypto keys.
 135  * \param buf The buffer to send.
 136  * \param numbytes The size of \a buf.
 137  * \param band The sideband designator of this packet.
 138  * \param dont_free If true, never deallocate \a buf.
 139  *
 140  * The nonblock flag must be disabled for the file descriptor given by \a scc.
 141  *
 142  * Stream cipher encryption is automatically activated if necessary via the
 143  * sideband transformation, depending on the value of \a band.
 144  *
 145  * \return Standard.
 146  *
 147  * \sa \ref send_sb_va().
 148  */
 149 int send_sb(struct stream_cipher_context *scc, void *buf, size_t numbytes,
 150                 int band, bool dont_free)
 151 {
 152         int ret;
 153         struct sb_context *sbc;
 154         struct iovec iov[2];
 155         sb_transformation trafo = band < SBD_PROCEED? NULL : sc_trafo;
 156         struct sb_buffer sbb = SBB_INIT(band, buf, numbytes);
 157
 158         sbc = sb_new_send(&sbb, dont_free, trafo, scc->send);
 159         do {
 160                 ret = sb_get_send_buffers(sbc, iov);
 161                 ret = xwritev(scc->fd, iov, ret);
 162                 if (ret < 0)
 163                         goto fail;
 164         } while (sb_sent(sbc, ret) == false);
 165         return 1;
 166 fail:
 167         sb_free(sbc);
 168         return ret;
 169 }
 170
 171 /**
 172  * Create a variable sized buffer and send it as a sideband packet.
 173  *
 174  * \param scc Passed to \ref send_sb.
 175  * \param band See \ref send_sb.
 176  * \param fmt The format string.
 177  *
 178  * \return The return value of the underlying call to \ref send_sb.
 179  */
 180 __printf_3_4 int send_sb_va(struct stream_cipher_context *scc, int band,
 181                 const char *fmt, ...)
 182 {
 183         va_list ap;
 184         char *msg;
 185         int ret;
 186
 187         va_start(ap, fmt);
 188         ret = xvasprintf(&msg, fmt, ap);
 189         va_end(ap);
 190         return send_sb(scc, msg, ret, band, false);
 191 }
 192
 193 /**
 194  * Send an error message to a client.
 195  *
 196  * \param cc Client info.
 197  * \param err The (positive) error code.
 198  *
 199  * \return The return value of the underlying call to send_sb_va().
 200  */
 201 int send_strerror(struct command_context *cc, int err)
 202 {
 203         return send_sb_va(&cc->scc, SBD_ERROR_LOG, "%s\n", para_strerror(err));
 204 }
 205
 206 /**
 207  * Send an error context to a client,
 208  *
 209  * \param cc Client info.
 210  * \param errctx The error context string.
 211  *
 212  * \return The return value of the underlying call to send_sb_va().
 213  *
 214  * This function frees the error context string after it was sent.
 215  */
 216 int send_errctx(struct command_context *cc, char *errctx)
 217 {
 218         int ret;
 219
 220         if (!errctx)
 221                 return 0;
 222         ret = send_sb_va(&cc->scc, SBD_ERROR_LOG, "%s\n", errctx);
 223         free(errctx);
 224         return ret;
 225 }
 226
 227 static int check_sender_args(struct command_context *cc,
 228                 struct lls_parse_result *lpr, struct sender_command_data *scd)
 229 {
 230         int i, ret;
 231         const char * const subcmds[] = {SENDER_SUBCOMMANDS};
 232         const char *arg;
 233         char *errctx;
 234         unsigned num_inputs = lls_num_inputs(lpr);
 235
 236         scd->sender_num = -1;
 237         ret = lls(lls_check_arg_count(lpr, 2, INT_MAX, &errctx));
 238         if (ret < 0) {
 239                 send_errctx(cc, errctx);
 240                 return ret;
 241         }
 242         arg = lls_input(0, lpr);
 243         FOR_EACH_SENDER(i)
 244                 if (strcmp(senders[i]->name, arg) == 0)
 245                         break;
 246         if (!senders[i])
 247                 return -E_COMMAND_SYNTAX;
 248         scd->sender_num = i;
 249         arg = lls_input(1, lpr);
 250         for (i = 0; i < NUM_SENDER_CMDS; i++)
 251                 if (!strcmp(subcmds[i], arg))
 252                         break;
 253         if (i == NUM_SENDER_CMDS)
 254                 return -E_COMMAND_SYNTAX;
 255         scd->cmd_num = i;
 256         if (!senders[scd->sender_num]->client_cmds[scd->cmd_num])
 257                 return -E_SENDER_CMD;
 258         switch (scd->cmd_num) {
 259         case SENDER_on:
 260         case SENDER_off:
 261                 if (num_inputs != 2)
 262                         return -E_COMMAND_SYNTAX;
 263                 break;
 264         case SENDER_deny:
 265         case SENDER_allow:
 266                 if (num_inputs != 3 || parse_cidr(lls_input(2, lpr), scd->host,
 267                                 sizeof(scd->host), &scd->netmask) == NULL)
 268                         return -E_COMMAND_SYNTAX;
 269                 break;
 270         case SENDER_add:
 271         case SENDER_delete:
 272                 if (num_inputs != 3)
 273                         return -E_COMMAND_SYNTAX;
 274                 return parse_fec_url(lls_input(2, lpr), scd);
 275         default:
 276                 return -E_COMMAND_SYNTAX;
 277         }
 278         return 1;
 279 }
 280
 281 /**
 282  * Receive a sideband packet from a blocking file descriptor.
 283  *
 284  * \param scc fd and crypto keys.
 285  * \param expected_band The expected band designator.
 286  * \param max_size Passed to \ref sb_new_recv().
 287  * \param result Body of the sideband packet is returned here.
 288  *
 289  * If \a expected_band is not \p SBD_ANY, the band designator of the received
 290  * sideband packet is compared to \a expected_band and a mismatch is considered
 291  * an error.
 292  *
 293  * \return Standard.
 294  */
 295 int recv_sb(struct stream_cipher_context *scc,
 296                 enum sb_designator expected_band,
 297                 size_t max_size, struct iovec *result)
 298 {
 299         int ret;
 300         struct sb_context *sbc;
 301         struct iovec iov;
 302         struct sb_buffer sbb;
 303         sb_transformation trafo;
 304
 305         trafo = expected_band != SBD_ANY && expected_band < SBD_PROCEED?
 306                 NULL : sc_trafo;
 307         sbc = sb_new_recv(max_size, trafo, scc->recv);
 308         for (;;) {
 309                 sb_get_recv_buffer(sbc, &iov);
 310                 ret = recv_bin_buffer(scc->fd, iov.iov_base, iov.iov_len);
 311                 if (ret == 0)
 312                         ret = -E_EOF;
 313                 if (ret < 0)
 314                         goto fail;
 315                 ret = sb_received(sbc, ret, &sbb);
 316                 if (ret < 0)
 317                         goto fail;
 318                 if (ret > 0)
 319                         break;
 320         }
 321         ret = -E_BAD_BAND;
 322         if (expected_band != SBD_ANY && sbb.band != expected_band)
 323                 goto fail;
 324         *result = sbb.iov;
 325         return 1;
 326 fail:
 327         sb_free(sbc);
 328         return ret;
 329 }
 330
 331 static int com_sender(struct command_context *cc, struct lls_parse_result *lpr)
 332 {
 333         int i, ret = 0;
 334         char *msg = NULL;
 335         struct sender_command_data scd;
 336
 337         if (lls_num_inputs(lpr) == 0) {
 338                 FOR_EACH_SENDER(i) {
 339                         char *tmp;
 340                         ret = xasprintf(&tmp, "%s%s\n", msg? msg : "",
 341                                 senders[i]->name);
 342                         free(msg);
 343                         msg = tmp;
 344                 }
 345                 return send_sb(&cc->scc, msg, ret, SBD_OUTPUT, false);
 346         }
 347         ret = check_sender_args(cc, lpr, &scd);
 348         if (ret < 0) {
 349                 if (scd.sender_num < 0)
 350                         return ret;
 351                 if (strcmp(lls_input(1, lpr), "status") == 0)
 352                         msg = senders[scd.sender_num]->status();
 353                 else
 354                         msg = senders[scd.sender_num]->help();
 355                 return send_sb(&cc->scc, msg, strlen(msg), SBD_OUTPUT, false);
 356         }
 357
 358         switch (scd.cmd_num) {
 359         case SENDER_add:
 360         case SENDER_delete:
 361                 assert(senders[scd.sender_num]->resolve_target);
 362                 ret = senders[scd.sender_num]->resolve_target(lls_input(2, lpr),
 363                         &scd);
 364                 if (ret < 0)
 365                         return ret;
 366         }
 367
 368         for (i = 0; i < 10; i++) {
 369                 mutex_lock(mmd_mutex);
 370                 if (mmd->sender_cmd_data.cmd_num >= 0) {
 371                         /* another sender command is active, retry in 100ms */
 372                         struct timespec ts = {.tv_nsec = 100 * 1000 * 1000};
 373                         mutex_unlock(mmd_mutex);
 374                         nanosleep(&ts, NULL);
 375                         continue;
 376                 }
 377                 mmd->sender_cmd_data = scd;
 378                 mutex_unlock(mmd_mutex);
 379                 break;
 380         }
 381         return (i < 10)? 1 : -E_LOCK;
 382 }
 383 EXPORT_SERVER_CMD_HANDLER(sender);
 384
 385 static int com_si(struct command_context *cc,
 386                 __a_unused struct lls_parse_result *lpr)
 387 {
 388         char *msg, *ut;
 389         int ret;
 390
 391         ut = daemon_get_uptime_str(now);
 392         mutex_lock(mmd_mutex);
 393         ret = xasprintf(&msg,
 394                 "up: %s\nplayed: %u\n"
 395                 "server_pid: %d\n"
 396                 "afs_pid: %d\n"
 397                 "connections (active/accepted/total): %u/%u/%u\n"
 398                 "current loglevel: %s\n"
 399                 "supported audio formats: %s\n",
 400                 ut, mmd->num_played,
 401                 (int)getppid(),
 402                 (int)afs_pid,
 403                 mmd->active_connections,
 404                 mmd->num_commands,
 405                 mmd->num_connects,
 406                 ENUM_STRING_VAL(LOGLEVEL),
 407                 AUDIO_FORMAT_HANDLERS
 408         );
 409         mutex_unlock(mmd_mutex);
 410         free(ut);
 411         return send_sb(&cc->scc, msg, ret, SBD_OUTPUT, false);
 412 }
 413 EXPORT_SERVER_CMD_HANDLER(si);
 414
 415 static int com_version(struct command_context *cc, struct lls_parse_result *lpr)
 416 {
 417         char *msg;
 418         size_t len;
 419
 420         if (SERVER_CMD_OPT_GIVEN(VERSION, VERBOSE, lpr))
 421                 len = xasprintf(&msg, "%s", version_text("server"));
 422         else
 423                 len = xasprintf(&msg, "%s\n", version_single_line("server"));
 424         return send_sb(&cc->scc, msg, len, SBD_OUTPUT, false);
 425 }
 426 EXPORT_SERVER_CMD_HANDLER(version);
 427
 428 /** These status items are cleared if no audio file is currently open. */
 429 #define EMPTY_STATUS_ITEMS \
 430         ITEM(path) \
 431         ITEM(directory) \
 432         ITEM(basename) \
 433         ITEM(score) \
 434         ITEM(attributes_bitmap) \
 435         ITEM(attributes_txt) \
 436         ITEM(hash) \
 437         ITEM(image_id) \
 438         ITEM(image_name) \
 439         ITEM(lyrics_id) \
 440         ITEM(lyrics_name) \
 441         ITEM(bitrate) \
 442         ITEM(format) \
 443         ITEM(frequency) \
 444         ITEM(channels) \
 445         ITEM(duration) \
 446         ITEM(seconds_total) \
 447         ITEM(num_played) \
 448         ITEM(last_played) \
 449         ITEM(techinfo) \
 450         ITEM(artist) \
 451         ITEM(title) \
 452         ITEM(year) \
 453         ITEM(album) \
 454         ITEM(comment) \
 455         ITEM(mtime) \
 456         ITEM(file_size) \
 457         ITEM(chunk_time) \
 458         ITEM(num_chunks) \
 459         ITEM(amplification) \
 460         ITEM(play_time) \
 461
 462 /*
 463  * Create a set of audio-file related status items with empty values. These are
 464  * written to stat clients when no audio file is open.
 465  */
 466 static unsigned empty_status_items(bool parser_friendly, char **result)
 467 {
 468         char *esi;
 469         unsigned len;
 470
 471         if (parser_friendly)
 472                 len = xasprintf(&esi,
 473                         #define ITEM(x) "0004 %02x:\n"
 474                         EMPTY_STATUS_ITEMS
 475                         #undef ITEM
 476                         #define ITEM(x) , (unsigned) SI_ ## x
 477                         EMPTY_STATUS_ITEMS
 478                         #undef ITEM
 479                 );
 480         else
 481                 len = xasprintf(&esi,
 482                         #define ITEM(x) "%s:\n"
 483                         EMPTY_STATUS_ITEMS
 484                         #undef ITEM
 485                         #define ITEM(x) ,status_item_list[SI_ ## x]
 486                         EMPTY_STATUS_ITEMS
 487                         #undef ITEM
 488                 );
 489         *result = esi;
 490         return len;
 491 }
 492 #undef EMPTY_STATUS_ITEMS
 493
 494 static int com_stat(struct command_context *cc, struct lls_parse_result *lpr)
 495 {
 496         int ret;
 497         struct misc_meta_data tmp, *nmmd = &tmp;
 498         char *s;
 499         bool parser_friendly = SERVER_CMD_OPT_GIVEN(STAT, PARSER_FRIENDLY,
 500                 lpr) > 0;
 501         uint32_t num = SERVER_CMD_UINT32_VAL(STAT, NUM, lpr);
 502         const struct timespec ts = {.tv_sec = 50, .tv_nsec = 0};
 503
 504         para_sigaction(SIGINT, SIG_IGN);
 505         para_sigaction(SIGUSR1, command_handler_sighandler);
 506         para_sigaction(SIGTERM, command_handler_sighandler);
 507         /*
 508          * Simply checking subcmd_should_die is racy because a signal may
 509          * arrive after the check but before the subsequent call to sleep(3).
 510          * If this happens, sleep(3) would not be interrupted by the signal.
 511          * To avoid this we block SIGTERM here and allow it to arrive only
 512          * while we sleep.
 513          */
 514         para_block_signal(SIGTERM);
 515         for (;;) {
 516                 sigset_t set;
 517                 /*
 518                  * Copy the mmd structure to minimize the time we hold the mmd
 519                  * lock.
 520                  */
 521                 mutex_lock(mmd_mutex);
 522                 *nmmd = *mmd;
 523                 mutex_unlock(mmd_mutex);
 524                 ret = get_status(nmmd, parser_friendly, &s);
 525                 ret = send_sb(&cc->scc, s, ret, SBD_OUTPUT, false);
 526                 if (ret < 0)
 527                         goto out;
 528                 if (nmmd->vss_status_flags & VSS_NEXT) {
 529                         char *esi;
 530                         ret = empty_status_items(parser_friendly, &esi);
 531                         ret = send_sb(&cc->scc, esi, ret, SBD_OUTPUT, false);
 532                         if (ret < 0)
 533                                 goto out;
 534                 } else
 535                         send_afs_status(cc, parser_friendly);
 536                 ret = 1;
 537                 if (num > 0 && !--num)
 538                         goto out;
 539                 sigemptyset(&set); /* empty set means: unblock all signals */
 540                 /*
 541                  * pselect(2) allows to atomically unblock signals, then go to
 542                  * sleep. Calling sigprocmask(2) followed by sleep(3) would
 543                  * open a race window similar to the one described above.
 544                  */
 545                 pselect(1, NULL, NULL, NULL, &ts, &set);
 546                 if (subcmd_should_die)
 547                         goto out;
 548                 ret = -E_SERVER_CRASH;
 549                 if (getppid() == 1)
 550                         goto out;
 551         }
 552 out:
 553         return ret;
 554 }
 555 EXPORT_SERVER_CMD_HANDLER(stat);
 556
 557 const char *aux_info_cb(unsigned cmd_num, bool verbose)
 558 {
 559         static char result[80];
 560         unsigned perms = server_command_perms[cmd_num];
 561
 562         if (verbose) {
 563                 /* permissions: VSS_READ | VSS_WRITE */
 564                 sprintf(result, "permissions: %s",
 565                         server_command_perms_txt[cmd_num]);
 566         } else {
 567                 result[0] = perms & AFS_READ? 'a' : '-';
 568                 result[1] = perms & AFS_WRITE? 'A' : '-';
 569                 result[2] = perms & VSS_READ? 'v' : '-';
 570                 result[3] = perms & VSS_WRITE? 'V' : '-';
 571                 result[4] = '\0';
 572         }
 573         return result;
 574 }
 575
 576 static int com_help(struct command_context *cc, struct lls_parse_result *lpr)
 577 {
 578         char *buf;
 579         int ret;
 580         unsigned n;
 581         bool long_help = SERVER_CMD_OPT_GIVEN(HELP, LONG, lpr);
 582
 583         lsu_com_help(long_help, lpr, server_cmd_suite, aux_info_cb, &buf, &n);
 584         ret = send_sb(&cc->scc, buf, n, SBD_OUTPUT, false);
 585         return ret;
 586 }
 587 EXPORT_SERVER_CMD_HANDLER(help);
 588
 589 static int com_hup(__a_unused struct command_context *cc,
 590                 __a_unused struct lls_parse_result *lpr)
 591 {
 592         kill(getppid(), SIGHUP);
 593         return 1;
 594 }
 595 EXPORT_SERVER_CMD_HANDLER(hup);
 596
 597 static int com_term(__a_unused struct command_context *cc,
 598                 __a_unused struct lls_parse_result *lpr)
 599 {
 600         kill(getppid(), SIGTERM);
 601         return 1;
 602 }
 603 EXPORT_SERVER_CMD_HANDLER(term);
 604
 605 static int com_play(__a_unused struct command_context *cc,
 606                 __a_unused struct lls_parse_result *lpr)
 607 {
 608         mutex_lock(mmd_mutex);
 609         mmd->new_vss_status_flags |= VSS_PLAYING;
 610         mmd->new_vss_status_flags &= ~VSS_NOMORE;
 611         mutex_unlock(mmd_mutex);
 612         return 1;
 613 }
 614 EXPORT_SERVER_CMD_HANDLER(play);
 615
 616 static int com_stop(__a_unused struct command_context *cc,
 617                 __a_unused struct lls_parse_result *lpr)
 618 {
 619         mutex_lock(mmd_mutex);
 620         mmd->new_vss_status_flags &= ~VSS_PLAYING;
 621         mmd->new_vss_status_flags &= ~VSS_REPOS;
 622         mmd->new_vss_status_flags |= VSS_NEXT;
 623         mutex_unlock(mmd_mutex);
 624         return 1;
 625 }
 626 EXPORT_SERVER_CMD_HANDLER(stop);
 627
 628 static int com_pause(__a_unused struct command_context *cc,
 629                 __a_unused struct lls_parse_result *lpr)
 630 {
 631         mutex_lock(mmd_mutex);
 632         if (!vss_paused() && !vss_stopped()) {
 633                 mmd->events++;
 634                 mmd->new_vss_status_flags &= ~VSS_PLAYING;
 635                 mmd->new_vss_status_flags &= ~VSS_NEXT;
 636         }
 637         mutex_unlock(mmd_mutex);
 638         return 1;
 639 }
 640 EXPORT_SERVER_CMD_HANDLER(pause);
 641
 642 static int com_next(__a_unused struct command_context *cc,
 643                 __a_unused struct lls_parse_result *lpr)
 644 {
 645         mutex_lock(mmd_mutex);
 646         mmd->events++;
 647         mmd->new_vss_status_flags |= VSS_NEXT;
 648         mutex_unlock(mmd_mutex);
 649         return 1;
 650 }
 651 EXPORT_SERVER_CMD_HANDLER(next);
 652
 653 static int com_nomore(__a_unused struct command_context *cc,
 654                 __a_unused struct lls_parse_result *lpr)
 655 {
 656         mutex_lock(mmd_mutex);
 657         if (vss_playing() || vss_paused())
 658                 mmd->new_vss_status_flags |= VSS_NOMORE;
 659         mutex_unlock(mmd_mutex);
 660         return 1;
 661 }
 662 EXPORT_SERVER_CMD_HANDLER(nomore);
 663
 664 static int com_ff(struct command_context *cc, struct lls_parse_result *lpr)
 665 {
 666         long promille;
 667         int i, ret;
 668         char c, *errctx;
 669
 670         ret = lls(lls_check_arg_count(lpr, 1, 1, &errctx));
 671         if (ret < 0) {
 672                 send_errctx(cc, errctx);
 673                 return ret;
 674         }
 675         ret = para_atoi32(lls_input(0, lpr), &i);
 676         if (ret < 0) {
 677                 if (ret != -E_ATOI_JUNK_AT_END)
 678                         return ret;
 679                 /*
 680                  * Compatibility code to keep the historic syntax (ff 30-)
 681                  * working. This can be removed after 0.7.0.
 682                  */
 683                 ret = sscanf(lls_input(0, lpr), "%i%c", &i, &c);
 684                 if (ret <= 0)
 685                         return -E_COMMAND_SYNTAX;
 686                 if (ret > 1 && c == '-') {
 687                         PARA_WARNING_LOG("use of obsolete syntax\n");
 688                         i = -i;
 689                 }
 690         }
 691         mutex_lock(mmd_mutex);
 692         ret = -E_NO_AUDIO_FILE;
 693         if (!mmd->afd.afhi.chunks_total || !mmd->afd.afhi.seconds_total)
 694                 goto out;
 695         ret = 1;
 696         promille = (1000 * mmd->current_chunk) / mmd->afd.afhi.chunks_total;
 697         /*
 698          * We need this cast because without it the expression on the right
 699          * hand side is of unsigned type.
 700          */
 701         promille += 1000 * i / (int)mmd->afd.afhi.seconds_total;
 702         if (promille < 0)
 703                 promille = 0;
 704         if (promille > 1000) {
 705                 mmd->new_vss_status_flags |= VSS_NEXT;
 706                 goto out;
 707         }
 708         mmd->repos_request = (mmd->afd.afhi.chunks_total * promille) / 1000;
 709         mmd->new_vss_status_flags |= VSS_REPOS;
 710         mmd->new_vss_status_flags &= ~VSS_NEXT;
 711         mmd->events++;
 712 out:
 713         mutex_unlock(mmd_mutex);
 714         return ret;
 715 }
 716 EXPORT_SERVER_CMD_HANDLER(ff);
 717
 718 static int com_jmp(struct command_context *cc, struct lls_parse_result *lpr)
 719 {
 720         long unsigned int i;
 721         int ret;
 722         char *errctx;
 723
 724         ret = lls(lls_check_arg_count(lpr, 1, 1, &errctx));
 725         if (ret < 0) {
 726                 send_errctx(cc, errctx);
 727                 return ret;
 728         }
 729         if (sscanf(lls_input(0, lpr), "%lu", &i) <= 0)
 730                 return -ERRNO_TO_PARA_ERROR(EINVAL);
 731         mutex_lock(mmd_mutex);
 732         ret = -E_NO_AUDIO_FILE;
 733         if (!mmd->afd.afhi.chunks_total)
 734                 goto out;
 735         if (i > 100)
 736                 i = 100;
 737         PARA_INFO_LOG("jumping to %lu%%\n", i);
 738         mmd->repos_request = (mmd->afd.afhi.chunks_total * i + 50) / 100;
 739         PARA_INFO_LOG("sent: %lu, offset before jmp: %li\n",
 740                 mmd->chunks_sent, mmd->offset);
 741         mmd->new_vss_status_flags |= VSS_REPOS;
 742         mmd->new_vss_status_flags &= ~VSS_NEXT;
 743         ret = 1;
 744         mmd->events++;
 745 out:
 746         mutex_unlock(mmd_mutex);
 747         return ret;
 748 }
 749 EXPORT_SERVER_CMD_HANDLER(jmp);
 750
 751 /* deprecated, does nothing */
 752 static int com_tasks(__a_unused struct command_context *cc,
 753                 __a_unused struct lls_parse_result *lpr)
 754 {
 755         return 1;
 756 }
 757 EXPORT_SERVER_CMD_HANDLER(tasks);
 758
 759 static void reset_signals(void)
 760 {
 761         para_sigaction(SIGCHLD, SIG_IGN);
 762         para_sigaction(SIGINT, SIG_DFL);
 763         para_sigaction(SIGTERM, SIG_DFL);
 764         para_sigaction(SIGHUP, SIG_DFL);
 765 }
 766
 767 struct connection_features {
 768         int dummy; /* none at the moment */
 769 };
 770
 771 static int parse_auth_request(char *buf, int len, const struct user **u,
 772                 struct connection_features *cf)
 773 {
 774         int ret;
 775         char *p, *username, **features = NULL;
 776         size_t auth_rq_len = strlen(AUTH_REQUEST_MSG);
 777
 778         *u = NULL;
 779         memset(cf, 0, sizeof(*cf));
 780         if (len < auth_rq_len + 2)
 781                 return -E_AUTH_REQUEST;
 782         if (strncmp(buf, AUTH_REQUEST_MSG, auth_rq_len) != 0)
 783                 return -E_AUTH_REQUEST;
 784         username = buf + auth_rq_len;
 785         p = strchr(username, ' ');
 786         if (p) {
 787                 int i;
 788                 if (p == username)
 789                         return -E_AUTH_REQUEST;
 790                 *p = '\0';
 791                 p++;
 792                 create_argv(p, ",", &features);
 793                 for (i = 0; features[i]; i++) {
 794                         if (strcmp(features[i], "sideband") == 0)
 795                                 continue;
 796                         if (strcmp(features[i], "aes_ctr128") == 0)
 797                                 continue;
 798                         else {
 799                                 ret = -E_BAD_FEATURE;
 800                                 goto out;
 801                         }
 802                 }
 803         }
 804         PARA_DEBUG_LOG("received auth request for user %s\n", username);
 805         *u = user_list_lookup(username);
 806         ret = 1;
 807 out:
 808         free_argv(features);
 809         return ret;
 810 }
 811
 812 #define HANDSHAKE_BUFSIZE 4096
 813
 814 static int run_command(struct command_context *cc, struct iovec *iov)
 815 {
 816         int ret, i, argc;
 817         char *p, *end, **argv;
 818         const struct lls_command *lcmd = NULL;
 819         unsigned perms;
 820         struct lls_parse_result *lpr;
 821         char *errctx;
 822
 823         if (iov->iov_base == NULL || iov->iov_len == 0)
 824                 return -ERRNO_TO_PARA_ERROR(EINVAL);
 825         p = iov->iov_base;
 826         p[iov->iov_len - 1] = '\0'; /* just to be sure */
 827
 828         ret = lls(lls_lookup_subcmd(p, server_cmd_suite, &errctx));
 829         if (ret < 0) {
 830                 send_errctx(cc, errctx);
 831                 return ret;
 832         }
 833         perms = server_command_perms[ret];
 834         if ((perms & cc->u->perms) != perms)
 835                 return -E_PERM;
 836         lcmd = lls_cmd(ret, server_cmd_suite);
 837         end = iov->iov_base + iov->iov_len;
 838         for (i = 0; p < end; i++)
 839                 p += strlen(p) + 1;
 840         argc = i;
 841         argv = para_malloc((argc + 1) * sizeof(char *));
 842         for (i = 0, p = iov->iov_base; p < end; i++) {
 843                 argv[i] = para_strdup(p);
 844                 p += strlen(p) + 1;
 845         }
 846         argv[argc] = NULL;
 847         PARA_NOTICE_LOG("calling com_%s() for user %s\n",
 848                 lls_command_name(lcmd), cc->u->name);
 849         ret = lls(lls_parse(argc, argv, lcmd, &lpr, &errctx));
 850         if (ret >= 0) {
 851                 const struct server_cmd_user_data *ud = lls_user_data(lcmd);
 852                 ret = ud->handler(cc, lpr);
 853                 lls_free_parse_result(lpr, lcmd);
 854         } else
 855                 send_errctx(cc, errctx);
 856         free_argv(argv);
 857         mutex_lock(mmd_mutex);
 858         mmd->num_commands++;
 859         if (ret >= 0 && (perms & AFS_WRITE))
 860                 mmd->events++;
 861         mutex_unlock(mmd_mutex);
 862         return ret;
 863 }
 864
 865 /**
 866  * Perform user authentication and execute a command.
 867  *
 868  * \param fd The file descriptor to send output to.
 869  *
 870  * Whenever para_server accepts an incoming tcp connection on the port it
 871  * listens on, it forks and the resulting child calls this function.
 872  *
 873  * An RSA-based challenge/response is used to authenticate the peer. If the
 874  * authentication succeeds, a random session key is generated and sent back to
 875  * the peer, encrypted with its RSA public key. From this point on, all
 876  * transfers are encrypted with this session key using a stream cipher.
 877  *
 878  * Next it is checked if the peer supplied a valid server command or a command
 879  * for the audio file selector. If yes, and if the user has sufficient
 880  * permissions to execute this command, the function calls the corresponding
 881  * command handler which performs argument checking and further processing.
 882  *
 883  * To cope with DOS attacks, a timer is set up right after the fork. If the
 884  * connection was still not authenticated when the timeout expires, the child
 885  * process is terminated.
 886  *
 887  * \return Standard.
 888  *
 889  * \sa alarm(2), \ref openssl.c, \ref crypt.h.
 890  */
 891 int handle_connect(int fd)
 892 {
 893         int ret;
 894         unsigned char rand_buf[APC_CHALLENGE_SIZE + 2 * SESSION_KEY_LEN];
 895         unsigned char challenge_hash[HASH_SIZE];
 896         char *command = NULL, *buf = para_malloc(HANDSHAKE_BUFSIZE) /* must be on the heap */;
 897         size_t numbytes;
 898         struct command_context cc_struct = {.u = NULL}, *cc = &cc_struct;
 899         struct iovec iov;
 900         struct connection_features cf;
 901
 902         cc->scc.fd = fd;
 903         reset_signals();
 904         /* we need a blocking fd here as recv() might return EAGAIN otherwise. */
 905         ret = mark_fd_blocking(fd);
 906         if (ret < 0)
 907                 goto net_err;
 908         /* send Welcome message */
 909         ret = write_va_buffer(fd, "This is para_server, version "
 910                 PACKAGE_VERSION ".\n"
 911                 "Features: sideband,aes_ctr128\n"
 912         );
 913         if (ret < 0)
 914                 goto net_err;
 915         /* recv auth request line */
 916         ret = recv_buffer(fd, buf, HANDSHAKE_BUFSIZE);
 917         if (ret < 0)
 918                 goto net_err;
 919         ret = parse_auth_request(buf, ret, &cc->u, &cf);
 920         if (ret < 0)
 921                 goto net_err;
 922         if (cc->u) {
 923                 get_random_bytes_or_die(rand_buf, sizeof(rand_buf));
 924                 ret = apc_pub_encrypt(cc->u->pubkey, rand_buf, sizeof(rand_buf),
 925                         (unsigned char *)buf);
 926                 if (ret < 0)
 927                         goto net_err;
 928                 numbytes = ret;
 929         } else {
 930                 /*
 931                  * We don't want to reveal our user names, so we send a
 932                  * challenge to the client even if the user does not exist, and
 933                  * fail the authentication later.
 934                  */
 935                 numbytes = 256;
 936                 get_random_bytes_or_die((unsigned char *)buf, numbytes);
 937         }
 938         PARA_DEBUG_LOG("sending %d byte challenge + session key (%zu bytes)\n",
 939                 APC_CHALLENGE_SIZE, numbytes);
 940         ret = send_sb(&cc->scc, buf, numbytes, SBD_CHALLENGE, false);
 941         buf = NULL;
 942         if (ret < 0)
 943                 goto net_err;
 944         ret = recv_sb(&cc->scc, SBD_CHALLENGE_RESPONSE,
 945                 HANDSHAKE_BUFSIZE, &iov);
 946         if (ret < 0)
 947                 goto net_err;
 948         buf = iov.iov_base;
 949         numbytes = iov.iov_len;
 950         PARA_DEBUG_LOG("received %zu bytes challenge response\n", numbytes);
 951         ret = -E_BAD_USER;
 952         if (!cc->u)
 953                 goto net_err;
 954         /*
 955          * The correct response is the hash of the first APC_CHALLENGE_SIZE bytes
 956          * of the random data.
 957          */
 958         ret = -E_BAD_AUTH;
 959         if (numbytes != HASH_SIZE)
 960                 goto net_err;
 961         hash_function((char *)rand_buf, APC_CHALLENGE_SIZE, challenge_hash);
 962         if (memcmp(challenge_hash, buf, HASH_SIZE))
 963                 goto net_err;
 964         /* auth successful */
 965         alarm(0);
 966         PARA_INFO_LOG("good auth for %s\n", cc->u->name);
 967         /* init stream cipher keys with the second part of the random buffer */
 968         cc->scc.recv = sc_new(rand_buf + APC_CHALLENGE_SIZE, SESSION_KEY_LEN);
 969         cc->scc.send = sc_new(rand_buf + APC_CHALLENGE_SIZE + SESSION_KEY_LEN,
 970                 SESSION_KEY_LEN);
 971         ret = send_sb(&cc->scc, NULL, 0, SBD_PROCEED, false);
 972         if (ret < 0)
 973                 goto net_err;
 974         ret = recv_sb(&cc->scc, SBD_COMMAND, MAX_COMMAND_LEN, &iov);
 975         if (ret < 0)
 976                 goto net_err;
 977         ret = run_command(cc, &iov);
 978         free(iov.iov_base);
 979         if (ret < 0)
 980                 goto err_out;
 981         if (ret >= 0)
 982                 goto out;
 983 err_out:
 984         if (send_strerror(cc, -ret) >= 0)
 985                 send_sb(&cc->scc, NULL, 0, SBD_EXIT__FAILURE, true);
 986 net_err:
 987         PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
 988 out:
 989         free(buf);
 990         free(command);
 991         mutex_lock(mmd_mutex);
 992         mmd->active_connections--;
 993         mutex_unlock(mmd_mutex);
 994         if (ret >= 0) {
 995                 ret = send_sb(&cc->scc, NULL, 0, SBD_EXIT__SUCCESS, true);
 996                 if (ret < 0)
 997                         PARA_NOTICE_LOG("%s\n", para_strerror(-ret));
 998         }
 999         sc_free(cc->scc.recv);
1000         sc_free(cc->scc.send);
1001         return ret;
1002 }