aserver/aserver.c

   1 /*
   2  *  ALSA server
   3  *  Copyright (c) by Abramo Bagnara <abramo@alsa-project.org>
   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,
  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, write to the Free Software
  17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18  *
  19  */
  20
  21 #include <sys/shm.h>
  22 #include <sys/socket.h>
  23 #include <sys/poll.h>
  24 #include <sys/un.h>
  25 #include <sys/uio.h>
  26 #include <stdio.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <stddef.h>
  30 #include <getopt.h>
  31 #include <netinet/in.h>
  32 #include <netdb.h>
  33 #include <limits.h>
  34 #include <signal.h>
  35
  36 #include "aserver.h"
  37
  38 char *command;
  39
  40 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
  41 #define ERROR(...) do {\
  42         fprintf(stderr, "%s %s:%i:(%s) ", command, __FILE__, __LINE__, __FUNCTION__); \
  43         fprintf(stderr, __VA_ARGS__); \
  44         putc('\n', stderr); \
  45 } while (0)
  46 #else
  47 #define ERROR(args...) do {\
  48         fprintf(stderr, "%s %s:%i:(%s) ", command, __FILE__, __LINE__, __FUNCTION__); \
  49         fprintf(stderr, ##args); \
  50         putc('\n', stderr); \
  51 } while (0)
  52 #endif
  53
  54 #define SYSERROR(string) ERROR(string ": %s", strerror(errno))
  55
  56 static int make_local_socket(const char *filename)
  57 {
  58         size_t l = strlen(filename);
  59         size_t size = offsetof(struct sockaddr_un, sun_path) + l;
  60         struct sockaddr_un *addr = alloca(size);
  61         int sock;
  62
  63         sock = socket(PF_LOCAL, SOCK_STREAM, 0);
  64         if (sock < 0) {
  65                 int result = -errno;
  66                 SYSERROR("socket failed");
  67                 return result;
  68         }
  69
  70         unlink(filename);
  71
  72         addr->sun_family = AF_LOCAL;
  73         memcpy(addr->sun_path, filename, l);
  74
  75         if (bind(sock, (struct sockaddr *) addr, size) < 0) {
  76                 int result = -errno;
  77                 SYSERROR("bind failed");
  78                 return result;
  79         }
  80
  81         return sock;
  82 }
  83
  84 static int make_inet_socket(int port)
  85 {
  86         struct sockaddr_in addr;
  87         int sock;
  88
  89         sock = socket(PF_INET, SOCK_STREAM, 0);
  90         if (sock < 0) {
  91                 int result = -errno;
  92                 SYSERROR("socket failed");
  93                 return result;
  94         }
  95
  96         addr.sin_family = AF_INET;
  97         addr.sin_port = htons(port);
  98         addr.sin_addr.s_addr = INADDR_ANY;
  99
 100         if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 101                 int result = -errno;
 102                 SYSERROR("bind failed");
 103                 return result;
 104         }
 105
 106         return sock;
 107 }
 108
 109 struct pollfd *pollfds;
 110 unsigned int pollfds_count = 0;
 111 typedef struct waiter waiter_t;
 112 typedef int (*waiter_handler_t)(waiter_t *waiter, unsigned short events);
 113 struct waiter {
 114         int fd;
 115         void *private_data;
 116         waiter_handler_t handler;
 117 };
 118 waiter_t *waiters;
 119
 120 static void add_waiter(int fd, unsigned short events, waiter_handler_t handler,
 121                 void *data)
 122 {
 123         waiter_t *w = &waiters[fd];
 124         struct pollfd *pfd = &pollfds[pollfds_count];
 125         assert(!w->handler);
 126         pfd->fd = fd;
 127         pfd->events = events;
 128         pfd->revents = 0;
 129         w->fd = fd;
 130         w->private_data = data;
 131         w->handler = handler;
 132         pollfds_count++;
 133 }
 134
 135 static void del_waiter(int fd)
 136 {
 137         waiter_t *w = &waiters[fd];
 138         unsigned int k;
 139         assert(w->handler);
 140         w->handler = 0;
 141         for (k = 0; k < pollfds_count; ++k) {
 142                 if (pollfds[k].fd == fd)
 143                         break;
 144         }
 145         assert(k < pollfds_count);
 146         pollfds_count--;
 147         memmove(&pollfds[k], &pollfds[k + 1], pollfds_count - k);
 148 }
 149
 150 typedef struct client client_t;
 151
 152 typedef struct {
 153         int (*open)(client_t *client, int *cookie);
 154         int (*cmd)(client_t *client);
 155         int (*close)(client_t *client);
 156 } transport_ops_t;
 157
 158 struct client {
 159         struct list_head list;
 160         int poll_fd;
 161         int ctrl_fd;
 162         int local;
 163         int transport_type;
 164         int dev_type;
 165         char name[256];
 166         int stream;
 167         int mode;
 168         transport_ops_t *ops;
 169         snd_async_handler_t *async_handler;
 170         int async_sig;
 171         pid_t async_pid;
 172         union {
 173                 struct {
 174                         snd_pcm_t *handle;
 175                         int fd;
 176                 } pcm;
 177                 struct {
 178                         snd_ctl_t *handle;
 179                         int fd;
 180                 } ctl;
 181 #if 0
 182                 struct {
 183                         snd_rawmidi_t *handle;
 184                 } rawmidi;
 185                 struct {
 186                         snd_timer_open_t *handle;
 187                 } timer;
 188                 struct {
 189                         snd_hwdep_t *handle;
 190                 } hwdep;
 191                 struct {
 192                         snd_seq_t *handle;
 193                 } seq;
 194 #endif
 195         } device;
 196         int polling;
 197         int open;
 198         int cookie;
 199         union {
 200                 struct {
 201                         int ctrl_id;
 202                         void *ctrl;
 203                 } shm;
 204         } transport;
 205 };
 206
 207 LIST_HEAD(clients);
 208
 209 typedef struct {
 210         struct list_head list;
 211         int fd;
 212         uint32_t cookie;
 213 } inet_pending_t;
 214 LIST_HEAD(inet_pendings);
 215
 216 #if 0
 217 static int pcm_handler(waiter_t *waiter, unsigned short events)
 218 {
 219         client_t *client = waiter->private_data;
 220         char buf[1];
 221         ssize_t n;
 222         if (events & POLLIN) {
 223                 n = write(client->poll_fd, buf, 1);
 224                 if (n != 1) {
 225                         SYSERROR("write failed");
 226                         return -errno;
 227                 }
 228         } else if (events & POLLOUT) {
 229                 n = read(client->poll_fd, buf, 1);
 230                 if (n != 1) {
 231                         SYSERROR("read failed");
 232                         return -errno;
 233                 }
 234         }
 235         del_waiter(waiter->fd);
 236         client->polling = 0;
 237         return 0;
 238 }
 239 #endif
 240
 241 static void pcm_shm_hw_ptr_changed(snd_pcm_t *pcm, snd_pcm_t *src ATTRIBUTE_UNUSED)
 242 {
 243         client_t *client = pcm->hw.private_data;
 244         volatile snd_pcm_shm_ctrl_t *ctrl = client->transport.shm.ctrl;
 245         snd_pcm_t *loop;
 246
 247         ctrl->hw.changed = 1;
 248         if (pcm->hw.fd >= 0) {
 249                 ctrl->hw.use_mmap = 1;
 250                 ctrl->hw.offset = pcm->hw.offset;
 251                 return;
 252         }
 253         ctrl->hw.use_mmap = 0;
 254         ctrl->hw.ptr = pcm->hw.ptr ? *pcm->hw.ptr : 0;
 255         for (loop = pcm->hw.master; loop; loop = loop->hw.master)
 256                 loop->hw.ptr = &ctrl->hw.ptr;
 257         pcm->hw.ptr = &ctrl->hw.ptr;
 258 }
 259
 260 static void pcm_shm_appl_ptr_changed(snd_pcm_t *pcm, snd_pcm_t *src ATTRIBUTE_UNUSED)
 261 {
 262         client_t *client = pcm->appl.private_data;
 263         volatile snd_pcm_shm_ctrl_t *ctrl = client->transport.shm.ctrl;
 264         snd_pcm_t *loop;
 265
 266         ctrl->appl.changed = 1;
 267         if (pcm->appl.fd >= 0) {
 268                 ctrl->appl.use_mmap = 1;
 269                 ctrl->appl.offset = pcm->appl.offset;
 270                 return;
 271         }
 272         ctrl->appl.use_mmap = 0;
 273         ctrl->appl.ptr = pcm->appl.ptr ? *pcm->appl.ptr : 0;
 274         for (loop = pcm->appl.master; loop; loop = loop->appl.master)
 275                 loop->appl.ptr = &ctrl->appl.ptr;
 276         pcm->appl.ptr = &ctrl->appl.ptr;
 277 }
 278
 279 static int pcm_shm_open(client_t *client, int *cookie)
 280 {
 281         int shmid;
 282         snd_pcm_t *pcm;
 283         int err;
 284         int result;
 285         err = snd_pcm_open(&pcm, client->name, client->stream, SND_PCM_NONBLOCK);
 286         if (err < 0)
 287                 return err;
 288         client->device.pcm.handle = pcm;
 289         client->device.pcm.fd = _snd_pcm_poll_descriptor(pcm);
 290         pcm->hw.private_data = client;
 291         pcm->hw.changed = pcm_shm_hw_ptr_changed;
 292         pcm->appl.private_data = client;
 293         pcm->appl.changed = pcm_shm_appl_ptr_changed;
 294
 295         shmid = shmget(IPC_PRIVATE, PCM_SHM_SIZE, 0666);
 296         if (shmid < 0) {
 297                 result = -errno;
 298                 SYSERROR("shmget failed");
 299                 goto _err;
 300         }
 301         client->transport.shm.ctrl_id = shmid;
 302         client->transport.shm.ctrl = shmat(shmid, 0, 0);
 303         if (client->transport.shm.ctrl == (void*) -1) {
 304                 result = -errno;
 305                 shmctl(shmid, IPC_RMID, 0);
 306                 SYSERROR("shmat failed");
 307                 goto _err;
 308         }
 309         *cookie = shmid;
 310         return 0;
 311
 312  _err:
 313         snd_pcm_close(pcm);
 314         return result;
 315
 316 }
 317
 318 static int pcm_shm_close(client_t *client)
 319 {
 320         int err;
 321         snd_pcm_shm_ctrl_t *ctrl = client->transport.shm.ctrl;
 322         if (client->polling) {
 323                 del_waiter(client->device.pcm.fd);
 324                 client->polling = 0;
 325         }
 326         err = snd_pcm_close(client->device.pcm.handle);
 327         ctrl->result = err;
 328         if (err < 0)
 329                 ERROR("snd_pcm_close");
 330         if (client->transport.shm.ctrl) {
 331                 err = shmdt((void *)client->transport.shm.ctrl);
 332                 if (err < 0)
 333                         SYSERROR("shmdt failed");
 334                 err = shmctl(client->transport.shm.ctrl_id, IPC_RMID, 0);
 335                 if (err < 0)
 336                         SYSERROR("shmctl IPC_RMID failed");
 337                 client->transport.shm.ctrl = 0;
 338         }
 339         client->open = 0;
 340         return 0;
 341 }
 342
 343 static int shm_ack(client_t *client)
 344 {
 345         struct pollfd pfd;
 346         int err;
 347         char buf[1];
 348         pfd.fd = client->ctrl_fd;
 349         pfd.events = POLLHUP;
 350         if (poll(&pfd, 1, 0) == 1)
 351                 return -EBADFD;
 352         err = write(client->ctrl_fd, buf, 1);
 353         if (err != 1)
 354                 return -EBADFD;
 355         return 0;
 356 }
 357
 358 static int shm_ack_fd(client_t *client, int fd)
 359 {
 360         struct pollfd pfd;
 361         int err;
 362         char buf[1];
 363         pfd.fd = client->ctrl_fd;
 364         pfd.events = POLLHUP;
 365         if (poll(&pfd, 1, 0) == 1)
 366                 return -EBADFD;
 367         err = snd_send_fd(client->ctrl_fd, buf, 1, fd);
 368         if (err != 1)
 369                 return -EBADFD;
 370         return 0;
 371 }
 372
 373 static int shm_rbptr_fd(client_t *client, snd_pcm_rbptr_t *rbptr)
 374 {
 375         if (rbptr->fd < 0)
 376                 return -EINVAL;
 377         return shm_ack_fd(client, rbptr->fd);
 378 }
 379
 380 static void async_handler(snd_async_handler_t *handler)
 381 {
 382         client_t *client = snd_async_handler_get_callback_private(handler);
 383         /* FIXME: use sigqueue */
 384         kill(client->async_pid, client->async_sig);
 385 }
 386
 387 static int pcm_shm_cmd(client_t *client)
 388 {
 389         volatile snd_pcm_shm_ctrl_t *ctrl = client->transport.shm.ctrl;
 390         char buf[1];
 391         int err;
 392         int cmd;
 393         snd_pcm_t *pcm;
 394         err = read(client->ctrl_fd, buf, 1);
 395         if (err != 1)
 396                 return -EBADFD;
 397         cmd = ctrl->cmd;
 398         ctrl->cmd = 0;
 399         pcm = client->device.pcm.handle;
 400         switch (cmd) {
 401         case SND_PCM_IOCTL_ASYNC:
 402                 ctrl->result = snd_pcm_async(pcm, ctrl->u.async.sig, ctrl->u.async.pid);
 403                 if (ctrl->result < 0)
 404                         break;
 405                 if (ctrl->u.async.sig >= 0) {
 406                         assert(client->async_sig < 0);
 407                         ctrl->result = snd_async_add_pcm_handler(&client->async_handler, pcm, async_handler, client);
 408                         if (ctrl->result < 0)
 409                                 break;
 410                 } else {
 411                         assert(client->async_sig >= 0);
 412                         snd_async_del_handler(client->async_handler);
 413                 }
 414                 client->async_sig = ctrl->u.async.sig;
 415                 client->async_pid = ctrl->u.async.pid;
 416                 break;
 417         case SNDRV_PCM_IOCTL_INFO:
 418                 ctrl->result = snd_pcm_info(pcm, (snd_pcm_info_t *) &ctrl->u.info);
 419                 break;
 420         case SNDRV_PCM_IOCTL_HW_REFINE:
 421                 ctrl->result = snd_pcm_hw_refine(pcm, (snd_pcm_hw_params_t *) &ctrl->u.hw_refine);
 422                 break;
 423         case SNDRV_PCM_IOCTL_HW_PARAMS:
 424                 ctrl->result = snd_pcm_hw_params(pcm, (snd_pcm_hw_params_t *) &ctrl->u.hw_params);
 425                 break;
 426         case SNDRV_PCM_IOCTL_HW_FREE:
 427                 ctrl->result = snd_pcm_hw_free(pcm);
 428                 break;
 429         case SNDRV_PCM_IOCTL_SW_PARAMS:
 430                 ctrl->result = snd_pcm_sw_params(pcm, (snd_pcm_sw_params_t *) &ctrl->u.sw_params);
 431                 break;
 432         case SNDRV_PCM_IOCTL_STATUS:
 433                 ctrl->result = snd_pcm_status(pcm, (snd_pcm_status_t *) &ctrl->u.status);
 434                 break;
 435         case SND_PCM_IOCTL_STATE:
 436                 ctrl->result = snd_pcm_state(pcm);
 437                 break;
 438         case SND_PCM_IOCTL_HWSYNC:
 439                 ctrl->result = snd_pcm_hwsync(pcm);
 440                 break;
 441         case SNDRV_PCM_IOCTL_DELAY:
 442                 ctrl->result = snd_pcm_delay(pcm, (snd_pcm_sframes_t *) &ctrl->u.delay.frames);
 443                 break;
 444         case SND_PCM_IOCTL_AVAIL_UPDATE:
 445                 ctrl->result = snd_pcm_avail_update(pcm);
 446                 break;
 447         case SNDRV_PCM_IOCTL_PREPARE:
 448                 ctrl->result = snd_pcm_prepare(pcm);
 449                 break;
 450         case SNDRV_PCM_IOCTL_RESET:
 451                 ctrl->result = snd_pcm_reset(pcm);
 452                 break;
 453         case SNDRV_PCM_IOCTL_START:
 454                 ctrl->result = snd_pcm_start(pcm);
 455                 break;
 456         case SNDRV_PCM_IOCTL_DRAIN:
 457                 ctrl->result = snd_pcm_drain(pcm);
 458                 break;
 459         case SNDRV_PCM_IOCTL_DROP:
 460                 ctrl->result = snd_pcm_drop(pcm);
 461                 break;
 462         case SNDRV_PCM_IOCTL_PAUSE:
 463                 ctrl->result = snd_pcm_pause(pcm, ctrl->u.pause.enable);
 464                 break;
 465         case SNDRV_PCM_IOCTL_CHANNEL_INFO:
 466                 ctrl->result = snd_pcm_channel_info(pcm, (snd_pcm_channel_info_t *) &ctrl->u.channel_info);
 467                 if (ctrl->result >= 0 &&
 468                     ctrl->u.channel_info.type == SND_PCM_AREA_MMAP)
 469                         return shm_ack_fd(client, ctrl->u.channel_info.u.mmap.fd);
 470                 break;
 471         case SNDRV_PCM_IOCTL_REWIND:
 472                 ctrl->result = snd_pcm_rewind(pcm, ctrl->u.rewind.frames);
 473                 break;
 474         case SND_PCM_IOCTL_FORWARD:
 475                 ctrl->result = snd_pcm_forward(pcm, ctrl->u.forward.frames);
 476                 break;
 477         case SNDRV_PCM_IOCTL_LINK:
 478         {
 479                 /* FIXME */
 480                 ctrl->result = -ENOSYS;
 481                 break;
 482         }
 483         case SNDRV_PCM_IOCTL_UNLINK:
 484                 ctrl->result = snd_pcm_unlink(pcm);
 485                 break;
 486         case SNDRV_PCM_IOCTL_RESUME:
 487                 ctrl->result = snd_pcm_resume(pcm);
 488                 break;
 489         case SND_PCM_IOCTL_MMAP:
 490         {
 491                 ctrl->result = snd_pcm_mmap(pcm);
 492         }
 493         case SND_PCM_IOCTL_MUNMAP:
 494         {
 495                 ctrl->result = snd_pcm_munmap(pcm);
 496                 break;
 497         }
 498         case SND_PCM_IOCTL_MMAP_COMMIT:
 499                 ctrl->result = snd_pcm_mmap_commit(pcm,
 500                                                    ctrl->u.mmap_commit.offset,
 501                                                    ctrl->u.mmap_commit.frames);
 502                 break;
 503         case SND_PCM_IOCTL_POLL_DESCRIPTOR:
 504                 ctrl->result = 0;
 505                 return shm_ack_fd(client, _snd_pcm_poll_descriptor(pcm));
 506         case SND_PCM_IOCTL_CLOSE:
 507                 client->ops->close(client);
 508                 break;
 509         case SND_PCM_IOCTL_HW_PTR_FD:
 510                 return shm_rbptr_fd(client, &pcm->hw);
 511         case SND_PCM_IOCTL_APPL_PTR_FD:
 512                 return shm_rbptr_fd(client, &pcm->appl);
 513         default:
 514                 ERROR("Bogus cmd: %x", ctrl->cmd);
 515                 ctrl->result = -ENOSYS;
 516         }
 517         return shm_ack(client);
 518 }
 519
 520 transport_ops_t pcm_shm_ops = {
 521         .open   = pcm_shm_open,
 522         .cmd    = pcm_shm_cmd,
 523         .close  = pcm_shm_close,
 524 };
 525
 526 static int ctl_handler(waiter_t *waiter, unsigned short events)
 527 {
 528         client_t *client = waiter->private_data;
 529         char buf[1];
 530         ssize_t n;
 531         if (events & POLLIN) {
 532                 n = write(client->poll_fd, buf, 1);
 533                 if (n != 1) {
 534                         SYSERROR("write failed");
 535                         return -errno;
 536                 }
 537         }
 538         del_waiter(waiter->fd);
 539         client->polling = 0;
 540         return 0;
 541 }
 542
 543 static int ctl_shm_open(client_t *client, int *cookie)
 544 {
 545         int shmid;
 546         snd_ctl_t *ctl;
 547         int err;
 548         int result;
 549         err = snd_ctl_open(&ctl, client->name, SND_CTL_NONBLOCK);
 550         if (err < 0)
 551                 return err;
 552         client->device.ctl.handle = ctl;
 553         client->device.ctl.fd = _snd_ctl_poll_descriptor(ctl);
 554
 555         shmid = shmget(IPC_PRIVATE, CTL_SHM_SIZE, 0666);
 556         if (shmid < 0) {
 557                 result = -errno;
 558                 SYSERROR("shmget failed");
 559                 goto _err;
 560         }
 561         client->transport.shm.ctrl_id = shmid;
 562         client->transport.shm.ctrl = shmat(shmid, 0, 0);
 563         if (!client->transport.shm.ctrl) {
 564                 result = -errno;
 565                 shmctl(shmid, IPC_RMID, 0);
 566                 SYSERROR("shmat failed");
 567                 goto _err;
 568         }
 569         *cookie = shmid;
 570         add_waiter(client->device.ctl.fd, POLLIN, ctl_handler, client);
 571         client->polling = 1;
 572         return 0;
 573
 574  _err:
 575         snd_ctl_close(ctl);
 576         return result;
 577
 578 }
 579
 580 static int ctl_shm_close(client_t *client)
 581 {
 582         int err;
 583         snd_ctl_shm_ctrl_t *ctrl = client->transport.shm.ctrl;
 584         if (client->polling) {
 585                 del_waiter(client->device.ctl.fd);
 586                 client->polling = 0;
 587         }
 588         err = snd_ctl_close(client->device.ctl.handle);
 589         ctrl->result = err;
 590         if (err < 0)
 591                 ERROR("snd_ctl_close");
 592         if (client->transport.shm.ctrl) {
 593                 err = shmdt((void *)client->transport.shm.ctrl);
 594                 if (err < 0)
 595                         SYSERROR("shmdt failed");
 596                 err = shmctl(client->transport.shm.ctrl_id, IPC_RMID, 0);
 597                 if (err < 0)
 598                         SYSERROR("shmctl failed");
 599                 client->transport.shm.ctrl = 0;
 600         }
 601         client->open = 0;
 602         return 0;
 603 }
 604
 605 static int ctl_shm_cmd(client_t *client)
 606 {
 607         snd_ctl_shm_ctrl_t *ctrl = client->transport.shm.ctrl;
 608         char buf[1];
 609         int err;
 610         int cmd;
 611         snd_ctl_t *ctl;
 612         err = read(client->ctrl_fd, buf, 1);
 613         if (err != 1)
 614                 return -EBADFD;
 615         cmd = ctrl->cmd;
 616         ctrl->cmd = 0;
 617         ctl = client->device.ctl.handle;
 618         switch (cmd) {
 619         case SND_CTL_IOCTL_ASYNC:
 620                 ctrl->result = snd_ctl_async(ctl, ctrl->u.async.sig, ctrl->u.async.pid);
 621                 if (ctrl->result < 0)
 622                         break;
 623                 if (ctrl->u.async.sig >= 0) {
 624                         assert(client->async_sig < 0);
 625                         ctrl->result = snd_async_add_ctl_handler(&client->async_handler, ctl, async_handler, client);
 626                         if (ctrl->result < 0)
 627                                 break;
 628                 } else {
 629                         assert(client->async_sig >= 0);
 630                         snd_async_del_handler(client->async_handler);
 631                 }
 632                 client->async_sig = ctrl->u.async.sig;
 633                 client->async_pid = ctrl->u.async.pid;
 634                 break;
 635                 break;
 636         case SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS:
 637                 ctrl->result = snd_ctl_subscribe_events(ctl, ctrl->u.subscribe_events);
 638                 break;
 639         case SNDRV_CTL_IOCTL_CARD_INFO:
 640                 ctrl->result = snd_ctl_card_info(ctl, &ctrl->u.card_info);
 641                 break;
 642         case SNDRV_CTL_IOCTL_ELEM_LIST:
 643         {
 644                 size_t maxsize = CTL_SHM_DATA_MAXLEN;
 645                 if (ctrl->u.element_list.space * sizeof(*ctrl->u.element_list.pids) > maxsize) {
 646                         ctrl->result = -EFAULT;
 647                         break;
 648                 }
 649                 ctrl->u.element_list.pids = (snd_ctl_elem_id_t*) ctrl->data;
 650                 ctrl->result = snd_ctl_elem_list(ctl, &ctrl->u.element_list);
 651                 break;
 652         }
 653         case SNDRV_CTL_IOCTL_ELEM_INFO:
 654                 ctrl->result = snd_ctl_elem_info(ctl, &ctrl->u.element_info);
 655                 break;
 656         case SNDRV_CTL_IOCTL_ELEM_READ:
 657                 ctrl->result = snd_ctl_elem_read(ctl, &ctrl->u.element_read);
 658                 break;
 659         case SNDRV_CTL_IOCTL_ELEM_WRITE:
 660                 ctrl->result = snd_ctl_elem_write(ctl, &ctrl->u.element_write);
 661                 break;
 662         case SNDRV_CTL_IOCTL_ELEM_LOCK:
 663                 ctrl->result = snd_ctl_elem_lock(ctl, &ctrl->u.element_lock);
 664                 break;
 665         case SNDRV_CTL_IOCTL_ELEM_UNLOCK:
 666                 ctrl->result = snd_ctl_elem_unlock(ctl, &ctrl->u.element_unlock);
 667                 break;
 668         case SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE:
 669                 ctrl->result = snd_ctl_hwdep_next_device(ctl, &ctrl->u.device);
 670                 break;
 671         case SNDRV_CTL_IOCTL_HWDEP_INFO:
 672                 ctrl->result = snd_ctl_hwdep_info(ctl, &ctrl->u.hwdep_info);
 673                 break;
 674         case SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE:
 675                 ctrl->result = snd_ctl_pcm_next_device(ctl, &ctrl->u.device);
 676                 break;
 677         case SNDRV_CTL_IOCTL_PCM_INFO:
 678                 ctrl->result = snd_ctl_pcm_info(ctl, &ctrl->u.pcm_info);
 679                 break;
 680         case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
 681                 ctrl->result = snd_ctl_pcm_prefer_subdevice(ctl, ctrl->u.pcm_prefer_subdevice);
 682                 break;
 683         case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE:
 684                 ctrl->result = snd_ctl_rawmidi_next_device(ctl, &ctrl->u.device);
 685                 break;
 686         case SNDRV_CTL_IOCTL_RAWMIDI_INFO:
 687                 ctrl->result = snd_ctl_rawmidi_info(ctl, &ctrl->u.rawmidi_info);
 688                 break;
 689         case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE:
 690                 ctrl->result = snd_ctl_rawmidi_prefer_subdevice(ctl, ctrl->u.rawmidi_prefer_subdevice);
 691                 break;
 692         case SNDRV_CTL_IOCTL_POWER:
 693                 ctrl->result = snd_ctl_set_power_state(ctl, ctrl->u.power_state);
 694                 break;
 695         case SNDRV_CTL_IOCTL_POWER_STATE:
 696                 ctrl->result = snd_ctl_get_power_state(ctl, &ctrl->u.power_state);
 697                 break;
 698         case SND_CTL_IOCTL_READ:
 699                 ctrl->result = snd_ctl_read(ctl, &ctrl->u.read);
 700                 break;
 701         case SND_CTL_IOCTL_CLOSE:
 702                 client->ops->close(client);
 703                 break;
 704         case SND_CTL_IOCTL_POLL_DESCRIPTOR:
 705                 ctrl->result = 0;
 706                 return shm_ack_fd(client, _snd_ctl_poll_descriptor(ctl));
 707         default:
 708                 ERROR("Bogus cmd: %x", ctrl->cmd);
 709                 ctrl->result = -ENOSYS;
 710         }
 711         return shm_ack(client);
 712 }
 713
 714 transport_ops_t ctl_shm_ops = {
 715         .open   = ctl_shm_open,
 716         .cmd    = ctl_shm_cmd,
 717         .close  = ctl_shm_close,
 718 };
 719
 720 static int snd_client_open(client_t *client)
 721 {
 722         int err;
 723         snd_client_open_request_t req;
 724         snd_client_open_answer_t ans;
 725         char *name;
 726         memset(&ans, 0, sizeof(ans));
 727         err = read(client->ctrl_fd, &req, sizeof(req));
 728         if (err < 0) {
 729                 SYSERROR("read failed");
 730                 exit(1);
 731         }
 732         if (err != sizeof(req)) {
 733                 ans.result = -EINVAL;
 734                 goto _answer;
 735         }
 736         name = alloca(req.namelen);
 737         err = read(client->ctrl_fd, name, req.namelen);
 738         if (err < 0) {
 739                 SYSERROR("read failed");
 740                 exit(1);
 741         }
 742         if (err != req.namelen) {
 743                 ans.result = -EINVAL;
 744                 goto _answer;
 745         }
 746
 747         switch (req.transport_type) {
 748         case SND_TRANSPORT_TYPE_SHM:
 749                 if (!client->local) {
 750                         ans.result = -EINVAL;
 751                         goto _answer;
 752                 }
 753                 switch (req.dev_type) {
 754                 case SND_DEV_TYPE_PCM:
 755                         client->ops = &pcm_shm_ops;
 756                         break;
 757                 case SND_DEV_TYPE_CONTROL:
 758                         client->ops = &ctl_shm_ops;
 759                         break;
 760                 default:
 761                         ans.result = -EINVAL;
 762                         goto _answer;
 763                 }
 764                 break;
 765         default:
 766                 ans.result = -EINVAL;
 767                 goto _answer;
 768         }
 769
 770         name[req.namelen] = '\0';
 771
 772         client->transport_type = req.transport_type;
 773         strcpy(client->name, name);
 774         client->stream = req.stream;
 775         client->mode = req.mode;
 776
 777         err = client->ops->open(client, &ans.cookie);
 778         if (err < 0) {
 779                 ans.result = err;
 780         } else {
 781                 client->open = 1;
 782                 ans.result = 0;
 783         }
 784
 785  _answer:
 786         err = write(client->ctrl_fd, &ans, sizeof(ans));
 787         if (err != sizeof(ans)) {
 788                 SYSERROR("write failed");
 789                 exit(1);
 790         }
 791         return 0;
 792 }
 793
 794 static int client_poll_handler(waiter_t *waiter, unsigned short events ATTRIBUTE_UNUSED)
 795 {
 796         client_t *client = waiter->private_data;
 797         if (client->open)
 798                 client->ops->close(client);
 799         close(client->poll_fd);
 800         close(client->ctrl_fd);
 801         del_waiter(client->poll_fd);
 802         del_waiter(client->ctrl_fd);
 803         list_del(&client->list);
 804         free(client);
 805         return 0;
 806 }
 807
 808 static int client_ctrl_handler(waiter_t *waiter, unsigned short events)
 809 {
 810         client_t *client = waiter->private_data;
 811         if (events & POLLHUP) {
 812                 if (client->open)
 813                         client->ops->close(client);
 814                 close(client->ctrl_fd);
 815                 del_waiter(client->ctrl_fd);
 816                 list_del(&client->list);
 817                 free(client);
 818                 return 0;
 819         }
 820         if (client->open)
 821                 return client->ops->cmd(client);
 822         else
 823                 return snd_client_open(client);
 824 }
 825
 826 static int inet_pending_handler(waiter_t *waiter, unsigned short events)
 827 {
 828         inet_pending_t *pending = waiter->private_data;
 829         inet_pending_t *pdata;
 830         client_t *client;
 831         uint32_t cookie;
 832         struct list_head *item;
 833         int remove = 0;
 834         if (events & POLLHUP)
 835                 remove = 1;
 836         else {
 837                 int err = read(waiter->fd, &cookie, sizeof(cookie));
 838                 if (err != sizeof(cookie))
 839                         remove = 1;
 840                 else {
 841                         err = write(waiter->fd, &cookie, sizeof(cookie));
 842                         if (err != sizeof(cookie))
 843                                 remove = 1;
 844                 }
 845         }
 846         del_waiter(waiter->fd);
 847         if (remove) {
 848                 close(waiter->fd);
 849                 list_del(&pending->list);
 850                 free(pending);
 851                 return 0;
 852         }
 853
 854         list_for_each(item, &inet_pendings) {
 855                 pdata = list_entry(item, inet_pending_t, list);
 856                 if (pdata->cookie == cookie)
 857                         goto found;
 858         }
 859         pending->cookie = cookie;
 860         return 0;
 861
 862  found:
 863         client = calloc(1, sizeof(*client));
 864         client->local = 0;
 865         client->poll_fd = pdata->fd;
 866         client->ctrl_fd = waiter->fd;
 867         add_waiter(client->ctrl_fd, POLLIN | POLLHUP, client_ctrl_handler, client);
 868         add_waiter(client->poll_fd, POLLHUP, client_poll_handler, client);
 869         client->open = 0;
 870         list_add_tail(&client->list, &clients);
 871         list_del(&pending->list);
 872         list_del(&pdata->list);
 873         free(pending);
 874         free(pdata);
 875         return 0;
 876 }
 877
 878 static int local_handler(waiter_t *waiter, unsigned short events ATTRIBUTE_UNUSED)
 879 {
 880         int sock;
 881         sock = accept(waiter->fd, 0, 0);
 882         if (sock < 0) {
 883                 int result = -errno;
 884                 SYSERROR("accept failed");
 885                 return result;
 886         } else {
 887                 client_t *client = calloc(1, sizeof(*client));
 888                 client->ctrl_fd = sock;
 889                 client->local = 1;
 890                 client->open = 0;
 891                 add_waiter(sock, POLLIN | POLLHUP, client_ctrl_handler, client);
 892                 list_add_tail(&client->list, &clients);
 893         }
 894         return 0;
 895 }
 896
 897 static int inet_handler(waiter_t *waiter, unsigned short events ATTRIBUTE_UNUSED)
 898 {
 899         int sock;
 900         sock = accept(waiter->fd, 0, 0);
 901         if (sock < 0) {
 902                 int result = -errno;
 903                 SYSERROR("accept failed");
 904                 return result;
 905         } else {
 906                 inet_pending_t *pending = calloc(1, sizeof(*pending));
 907                 pending->fd = sock;
 908                 pending->cookie = 0;
 909                 add_waiter(sock, POLLIN, inet_pending_handler, pending);
 910                 list_add_tail(&pending->list, &inet_pendings);
 911         }
 912         return 0;
 913 }
 914
 915 static int server(const char *sockname, int port)
 916 {
 917         int err;
 918         unsigned int k;
 919         long open_max;
 920         int result;
 921
 922         if (!sockname && port < 0)
 923                 return -EINVAL;
 924         open_max = sysconf(_SC_OPEN_MAX);
 925         if (open_max < 0) {
 926                 result = -errno;
 927                 SYSERROR("sysconf failed");
 928                 return result;
 929         }
 930         pollfds = calloc((size_t) open_max, sizeof(*pollfds));
 931         waiters = calloc((size_t) open_max, sizeof(*waiters));
 932
 933         if (sockname) {
 934                 int sock = make_local_socket(sockname);
 935                 if (sock < 0)
 936                         return sock;
 937                 if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) {
 938                         result = -errno;
 939                         SYSERROR("fcntl O_NONBLOCK failed");
 940                         goto _end;
 941                 }
 942                 if (listen(sock, 4) < 0) {
 943                         result = -errno;
 944                         SYSERROR("listen failed");
 945                         goto _end;
 946                 }
 947                 add_waiter(sock, POLLIN, local_handler, NULL);
 948         }
 949         if (port >= 0) {
 950                 int sock = make_inet_socket(port);
 951                 if (sock < 0)
 952                         return sock;
 953                 if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0) {
 954                         result = -errno;
 955                         SYSERROR("fcntl failed");
 956                         goto _end;
 957                 }
 958                 if (listen(sock, 4) < 0) {
 959                         result = -errno;
 960                         SYSERROR("listen failed");
 961                         goto _end;
 962                 }
 963                 add_waiter(sock, POLLIN, inet_handler, NULL);
 964         }
 965
 966         while (1) {
 967                 struct pollfd pfds[open_max];
 968                 size_t pfds_count;
 969                 do {
 970                         err = poll(pollfds, pollfds_count, -1);
 971                 } while (err == 0);
 972                 if (err < 0) {
 973                         SYSERROR("poll failed");
 974                         continue;
 975                 }
 976
 977                 pfds_count = pollfds_count;
 978                 memcpy(pfds, pollfds, sizeof(*pfds) * pfds_count);
 979                 for (k = 0; k < pfds_count; k++) {
 980                         struct pollfd *pfd = &pfds[k];
 981                         if (pfd->revents) {
 982                                 waiter_t *w = &waiters[pfd->fd];
 983                                 if (!w->handler)
 984                                         continue;
 985                                 err = w->handler(w, pfd->revents);
 986                                 if (err < 0)
 987                                         ERROR("waiter handler failed");
 988                         }
 989                 }
 990         }
 991  _end:
 992         free(pollfds);
 993         free(waiters);
 994         return result;
 995 }
 996
 997
 998 static void usage(void)
 999 {
1000         fprintf(stderr,
1001                 "Usage: %s [OPTIONS] server\n"
1002                 "--help                 help\n",
1003                 command);
1004 }
1005
1006 int main(int argc, char **argv)
1007 {
1008         static const struct option long_options[] = {
1009                 {"help", 0, 0, 'h'},
1010                 { 0 , 0 , 0, 0 }
1011         };
1012         int c;
1013         snd_config_t *conf;
1014         snd_config_iterator_t i, next;
1015         const char *sockname = NULL;
1016         const char *host = NULL;
1017         long port = -1;
1018         int err;
1019         char *srvname;
1020         struct hostent *h;
1021         command = argv[0];
1022         while ((c = getopt_long(argc, argv, "h", long_options, 0)) != -1) {
1023                 switch (c) {
1024                 case 'h':
1025                         usage();
1026                         return 0;
1027                 default:
1028                         fprintf(stderr, "Try `%s --help' for more information\n", command);
1029                         return 1;
1030                 }
1031         }
1032         if (argc - optind != 1) {
1033                 ERROR("you need to specify server name");
1034                 return 1;
1035         }
1036         err = snd_config_update();
1037         if (err < 0) {
1038                 ERROR("cannot read configuration file");
1039                 return 1;
1040         }
1041         srvname = argv[optind];
1042         err = snd_config_search_definition(snd_config, "server", srvname, &conf);
1043         if (err < 0) {
1044                 ERROR("Missing definition for server %s", srvname);
1045                 return 1;
1046         }
1047         if (snd_config_get_type(conf) != SND_CONFIG_TYPE_COMPOUND) {
1048                 SNDERR("Invalid type for server %s definition", srvname);
1049                 return -EINVAL;
1050         }
1051         snd_config_for_each(i, next, conf) {
1052                 snd_config_t *n = snd_config_iterator_entry(i);
1053                 const char *id;
1054                 if (snd_config_get_id(n, &id) < 0)
1055                         continue;
1056                 if (strcmp(id, "comment") == 0)
1057                         continue;
1058                 if (strcmp(id, "host") == 0) {
1059                         err = snd_config_get_string(n, &host);
1060                         if (err < 0) {
1061                                 ERROR("Invalid type for %s", id);
1062                                 return 1;
1063                         }
1064                         continue;
1065                 }
1066                 if (strcmp(id, "socket") == 0) {
1067                         err = snd_config_get_string(n, &sockname);
1068                         if (err < 0) {
1069                                 ERROR("Invalid type for %s", id);
1070                                 return 1;
1071                         }
1072                         continue;
1073                 }
1074                 if (strcmp(id, "port") == 0) {
1075                         err = snd_config_get_integer(n, &port);
1076                         if (err < 0) {
1077                                 ERROR("Invalid type for %s", id);
1078                                 return 1;
1079                         }
1080                         continue;
1081                 }
1082                 ERROR("Unknown field %s", id);
1083                 return 1;
1084         }
1085         if (!host) {
1086                 ERROR("host is not defined");
1087                 return 1;
1088         }
1089         h = gethostbyname(host);
1090         if (!h) {
1091                 ERROR("Cannot resolve %s", host);
1092                 return 1;
1093         }
1094         if (!snd_is_local(h)) {
1095                 ERROR("%s is not the local host", host);
1096                 return 1;
1097         }
1098         if (!sockname && port < 0) {
1099                 ERROR("either socket or port need to be defined");
1100                 return 1;
1101         }
1102         server(sockname, port);
1103         return 0;
1104 }