daemon/client.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*
   3  * LADI Session Handler (ladish)
   4  *
   5  * Copyright (C) 2009, 2010 Nedko Arnaudov <nedko@arnaudov.name>
   6  *
   7  **************************************************************************
   8  * This file contains the implementation of the client objects
   9  **************************************************************************
  10  *
  11  * LADI Session Handler is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * LADI Session Handler is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with LADI Session Handler. If not, see <http://www.gnu.org/licenses/>
  23  * or write to the Free Software Foundation, Inc.,
  24  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "common.h"
  28 #include "client.h"
  29
  30 struct ladish_client
  31 {
  32   uuid_t uuid;                             /* The UUID of the client */
  33   uuid_t uuid_interlink;                   /* The UUID of the linked client (vgraph <-> jack graph) */
  34   uuid_t uuid_app;                         /* The UUID of the app that owns this client */
  35   uint64_t jack_id;                        /* JACK client ID */
  36   pid_t pid;                               /* process id. */
  37   ladish_dict_handle dict;
  38   void * vgraph;                /* virtual graph */
  39 };
  40
  41 bool
  42 ladish_client_create(
  43   const uuid_t uuid_ptr,
  44   ladish_client_handle * client_handle_ptr)
  45 {
  46   struct ladish_client * client_ptr;
  47
  48   client_ptr = malloc(sizeof(struct ladish_client));
  49   if (client_ptr == NULL)
  50   {
  51     log_error("malloc() failed to allocate struct ladish_client");
  52     return false;
  53   }
  54
  55   if (!ladish_dict_create(&client_ptr->dict))
  56   {
  57     log_error("ladish_dict_create() failed for client");
  58     free(client_ptr);
  59     return false;
  60   }
  61
  62   if (uuid_ptr == NULL)
  63   {
  64     uuid_generate(client_ptr->uuid);
  65   }
  66   else
  67   {
  68     uuid_copy(client_ptr->uuid, uuid_ptr);
  69   }
  70
  71   uuid_clear(client_ptr->uuid_interlink);
  72   uuid_clear(client_ptr->uuid_app);
  73
  74   client_ptr->jack_id = 0;
  75   client_ptr->pid = 0;
  76   client_ptr->vgraph = NULL;
  77
  78 #if 0
  79   {
  80     char str[37];
  81     uuid_unparse(client_ptr->uuid, str);
  82     log_info("Created client %s", str);
  83   }
  84 #endif
  85
  86   log_info("client %p created", client_ptr);
  87   *client_handle_ptr = (ladish_client_handle)client_ptr;
  88   return true;
  89 }
  90
  91 #define client_ptr ((struct ladish_client *)client_handle)
  92
  93 bool
  94 ladish_client_create_copy(
  95   ladish_client_handle client_handle,
  96   ladish_client_handle * client_handle_ptr)
  97 {
  98   return ladish_client_create(client_ptr->uuid, client_handle_ptr);
  99 }
 100
 101 void
 102 ladish_client_destroy(
 103   ladish_client_handle client_handle)
 104 {
 105   log_info("client %p destroy", client_ptr);
 106
 107   ladish_dict_destroy(client_ptr->dict);
 108
 109   free(client_ptr);
 110 }
 111
 112 ladish_dict_handle ladish_client_get_dict(ladish_client_handle client_handle)
 113 {
 114   return client_ptr->dict;
 115 }
 116
 117 void ladish_client_get_uuid(ladish_client_handle client_handle, uuid_t uuid)
 118 {
 119   uuid_copy(uuid, client_ptr->uuid);
 120 }
 121
 122 void ladish_client_set_jack_id(ladish_client_handle client_handle, uint64_t jack_id)
 123 {
 124   log_info("client jack id set to %"PRIu64, jack_id);
 125   client_ptr->jack_id = jack_id;
 126 }
 127
 128 uint64_t ladish_client_get_jack_id(ladish_client_handle client_handle)
 129 {
 130   return client_ptr->jack_id;
 131 }
 132
 133 void ladish_client_set_pid(ladish_client_handle client_handle, pid_t pid)
 134 {
 135   client_ptr->pid = pid;
 136 }
 137
 138 pid_t ladish_client_get_pid(ladish_client_handle client_handle)
 139 {
 140   return client_ptr->pid;
 141 }
 142
 143 void ladish_client_set_vgraph(ladish_client_handle client_handle, void * vgraph)
 144 {
 145   client_ptr->vgraph = vgraph;
 146 }
 147
 148 void * ladish_client_get_vgraph(ladish_client_handle client_handle)
 149 {
 150   return client_ptr->vgraph;
 151 }
 152
 153 #define client2_ptr ((struct ladish_client *)client2_handle)
 154
 155 void ladish_client_interlink(ladish_client_handle client_handle, ladish_client_handle client2_handle)
 156 {
 157   uuid_copy(client_ptr->uuid_interlink, client2_ptr->uuid);
 158   uuid_copy(client2_ptr->uuid_interlink, client_ptr->uuid);
 159 }
 160
 161 #undef client2_ptr
 162
 163 bool ladish_client_get_interlink(ladish_client_handle client_handle, uuid_t uuid)
 164 {
 165   if (uuid_is_null(client_ptr->uuid_interlink))
 166   {
 167     return false;
 168   }
 169
 170   uuid_copy(uuid, client_ptr->uuid_interlink);
 171   return true;
 172 }
 173
 174 void ladish_client_clear_interlink(ladish_client_handle client_handle)
 175 {
 176   uuid_clear(client_ptr->uuid_interlink);
 177 }
 178
 179 void ladish_client_set_app(ladish_client_handle client_handle, const uuid_t uuid)
 180 {
 181   uuid_copy(client_ptr->uuid_app, uuid);
 182 }
 183
 184 bool ladish_client_get_app(ladish_client_handle client_handle, uuid_t uuid)
 185 {
 186   if (uuid_is_null(client_ptr->uuid_app))
 187   {
 188     return false;
 189   }
 190
 191   uuid_copy(uuid, client_ptr->uuid_app);
 192   return true;
 193 }
 194
 195 bool ladish_client_has_app(ladish_client_handle client_handle)
 196 {
 197   return !uuid_is_null(client_ptr->uuid_app);
 198 }
 199
 200 #undef client_ptr