common/JackSocket.cpp

   1 /*
   2 Copyright (C) 2004-2006 Grame
   3
   4   This program is free software; you can redistribute it and/or modify
   5   it under the terms of the GNU Lesser General Public License as published by
   6   the Free Software Foundation; either version 2.1 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU Lesser General Public License for more details.
  13
  14   You should have received a copy of the GNU Lesser General Public License
  15   along with this program; if not, write to the Free Software
  16   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18 */
  19
  20 #include "JackSocket.h"
  21 #include "JackError.h"
  22 #include <string.h>
  23
  24 namespace Jack
  25 {
  26
  27 JackClientSocket::JackClientSocket(int socket): fSocket(socket)
  28 {}
  29
  30 void JackClientSocket::SetReadTimeOut(long sec)
  31 {
  32     struct timeval timout;
  33     timout.tv_sec = sec;
  34     timout.tv_usec = 0;
  35     if (setsockopt(fSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timout, sizeof(timeval)) < 0) {
  36         JackLog("setsockopt SO_RCVTIMEO fd = %ld err = (%s)\n", fSocket, strerror(errno));
  37     }
  38 }
  39
  40 void JackClientSocket::SetWriteTimeOut(long sec)
  41 {
  42     struct timeval timout;
  43     timout.tv_sec = sec ;
  44     timout.tv_usec = 0;
  45     if (setsockopt(fSocket, SOL_SOCKET, SO_SNDTIMEO, (const char*)&timout, sizeof(timeval)) < 0) {
  46         JackLog("setsockopt SO_SNDTIMEO fd = %ld err = (%s)\n", fSocket, strerror(errno));
  47     }
  48 }
  49
  50 int JackClientSocket::Connect(const char* dir, const char* name, int which) // A revoir : utilisation de "which"
  51 {
  52     struct sockaddr_un addr;
  53
  54     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
  55         jack_error("Cannot create socket (%s)", strerror(errno));
  56         return -1;
  57     }
  58
  59     addr.sun_family = AF_UNIX;
  60     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%s", dir, name);
  61
  62     JackLog("Connect: addr.sun_path %s\n", addr.sun_path);
  63
  64     if (connect(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
  65         jack_error("Cannot connect to server socket (%s)", strerror(errno));
  66         close(fSocket);
  67         return -1;
  68     }
  69
  70 #ifdef __APPLE__
  71     int on = 1 ;
  72     if (setsockopt(fSocket, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&on, sizeof(on)) < 0) {
  73         JackLog("setsockopt SO_NOSIGPIPE fd = %ld err = %s\n", fSocket, strerror(errno));
  74     }
  75 #endif
  76
  77     return 0;
  78 }
  79
  80 int JackClientSocket::Connect(const char* dir, int which)
  81 {
  82     struct sockaddr_un addr;
  83
  84     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
  85         jack_error("Cannot create socket (%s)", strerror(errno));
  86         return -1;
  87     }
  88
  89     addr.sun_family = AF_UNIX;
  90     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%d", dir, which);
  91
  92     JackLog("Connect: addr.sun_path %s\n", addr.sun_path);
  93
  94     if (connect(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
  95         jack_error("Cannot connect to server socket (%s)", strerror(errno));
  96         close(fSocket);
  97         return -1;
  98     }
  99
 100 #ifdef __APPLE__
 101     int on = 1 ;
 102     if (setsockopt(fSocket, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&on, sizeof(on)) < 0) {
 103         JackLog("setsockopt SO_NOSIGPIPE fd = %ld err = %s\n", fSocket, strerror(errno));
 104     }
 105 #endif
 106
 107     return 0;
 108 }
 109
 110 int JackClientSocket::Close()
 111 {
 112     JackLog("JackClientSocket::Close\n");
 113     //shutdown(fSocket, SHUT_RDWR);
 114     if (fSocket > 0) {
 115         close(fSocket);
 116         fSocket = -1;
 117         return 0;
 118     } else {
 119         return -1;
 120     }
 121 }
 122
 123 int JackClientSocket::Read(void* data, int len)
 124 {
 125     int len1;
 126
 127     if ((len1 = read(fSocket, data, len)) != len) {
 128         jack_error("Cannot read socket %d %d (%s)", len, len1, strerror(errno));
 129         if (errno == EWOULDBLOCK) {
 130             JackLog("JackClientSocket::Read time out\n");
 131             return 0;
 132         } else {
 133             return -1;
 134         }
 135     } else {
 136         return 0;
 137     }
 138 }
 139
 140 int JackClientSocket::Write(void* data, int len)
 141 {
 142     if (write(fSocket, data, len) != len) {
 143         jack_error("Cannot write socket fd %ld (%s)", fSocket, strerror(errno));
 144         return -1;
 145     } else {
 146         return 0;
 147     }
 148 }
 149
 150 /*
 151 void
 152 jack_cleanup_files ()
 153 {
 154         DIR *dir;
 155         struct dirent *dirent;
 156
 157         // its important that we remove all files that jackd creates
 158         //   because otherwise subsequent attempts to start jackd will
 159         //   believe that an instance is already running.
 160
 161
 162         if ((dir = opendir (jack_server_dir)) == NULL) {
 163                 fprintf (stderr, "jack(%d): cannot open jack FIFO directory "
 164                          "(%s)\n", getpid(), strerror (errno));
 165                 return;
 166         }
 167
 168         while ((dirent = readdir (dir)) != NULL) {
 169                 if (strncmp (dirent->d_name, "jack-", 5) == 0 ||
 170                     strncmp (dirent->d_name, "jack_", 5) == 0) {
 171                         char fullpath[PATH_MAX+1];
 172                         snprintf (fullpath, sizeof (fullpath), "%s/%s",
 173                                   jack_server_dir, dirent->d_name);
 174                         unlink (fullpath);
 175                 }
 176         }
 177
 178         closedir (dir);
 179 }
 180 */
 181
 182 int JackServerSocket::Bind(const char* dir, const char* name, int which) // A revoir : utilisation de "which"
 183 {
 184     struct sockaddr_un addr;
 185
 186     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
 187         jack_error("Cannot create server socket (%s)", strerror(errno));
 188         return -1;
 189     }
 190
 191     addr.sun_family = AF_UNIX;
 192
 193     // TO CORRECT: always reuse the same name for now...
 194     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%s", dir, name);
 195     snprintf(fName, sizeof(addr.sun_path) - 1, "%s/jack_%s", dir, name);
 196     /*
 197     if (access(addr.sun_path, F_OK) == 0) {
 198         goto error;
 199     }
 200     */
 201
 202     JackLog("Bind: addr.sun_path %s\n", addr.sun_path);
 203     unlink(fName); // Security...
 204
 205     JackLog("Bind: addr.sun_path %s\n", addr.sun_path);
 206     unlink(fName); // Security...
 207
 208     if (bind(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
 209         jack_error("Cannot bind server to socket (%s)", strerror(errno));
 210         goto error;
 211     }
 212
 213     if (listen(fSocket, 1) < 0) {
 214         jack_error("Cannot enable listen on server socket (%s)", strerror(errno));
 215         goto error;
 216     }
 217
 218     return 0;
 219
 220 error:
 221     unlink(fName);
 222     close(fSocket);
 223     return -1;
 224 }
 225
 226 int JackServerSocket::Bind(const char* dir, int which) // A revoir : utilisation de "which"
 227 {
 228     struct sockaddr_un addr;
 229
 230     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
 231         jack_error ("Cannot create server socket (%s)", strerror(errno));
 232         return -1;
 233     }
 234
 235     addr.sun_family = AF_UNIX;
 236
 237     /*
 238     for (int i = 0; i < 999; i++) {
 239         snprintf(addr.sun_path, sizeof(addr.sun_path) - 1,"%s/jack_%d", dir, i);
 240         snprintf(fName, sizeof(addr.sun_path) - 1,"%s/jack_%d", dir, i);
 241         if (access(addr.sun_path, F_OK) != 0) {
 242                 break;
 243         }
 244     }
 245     */
 246
 247     // TO CORRECT: always reuse the same name for now...
 248     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%d", dir, which);
 249     snprintf(fName, sizeof(addr.sun_path) - 1, "%s/jack_%d", dir, which);
 250     /*
 251     if (access(addr.sun_path, F_OK) == 0) {
 252         goto error;
 253     }
 254     */
 255
 256     JackLog("Bind: addr.sun_path %s\n", addr.sun_path);
 257     unlink(fName); // Security...
 258
 259     if (bind(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
 260         jack_error("Cannot bind server to socket (%s)", strerror(errno));
 261         goto error;
 262     }
 263
 264     if (listen(fSocket, 1) < 0) {
 265         jack_error("Cannot enable listen on server socket (%s)", strerror(errno));
 266         goto error;
 267     }
 268
 269     return 0;
 270
 271 error:
 272     unlink(fName);
 273     close(fSocket);
 274     return -1;
 275 }
 276
 277 JackClientSocket* JackServerSocket::Accept()
 278 {
 279     struct sockaddr_un client_addr;
 280     socklen_t client_addrlen;
 281
 282     memset(&client_addr, 0, sizeof(client_addr));
 283     client_addrlen = sizeof(client_addr);
 284
 285     int fd = accept(fSocket, (struct sockaddr*) & client_addr, &client_addrlen);
 286     if (fd < 0) {
 287         jack_error("Cannot accept new connection (%s)", strerror(errno));
 288         return 0;
 289     } else {
 290         return new JackClientSocket(fd);
 291     }
 292 }
 293
 294 int JackServerSocket::Close()
 295 {
 296     JackLog("JackServerSocket::Close %s\n", fName);
 297     //shutdown(fSocket, SHUT_RDWR);
 298     if (fSocket > 0) {
 299         //shutdown(fSocket, SHUT_RDWR);
 300         close(fSocket);
 301         unlink(fName);
 302         fSocket = -1;
 303         return 0;
 304     } else {
 305         return -1;
 306     }
 307 }
 308
 309 } // end of namespace
 310
 311