posix/JackSocket.cpp

   1 /*
   2 Copyright (C) 2004-2008 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 #if defined(HAVE_CONFIG_H)
  21 #include "config.h"
  22 #endif
  23
  24 #include "JackSocket.h"
  25 #include "JackError.h"
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <pthread.h>
  29
  30 namespace Jack
  31 {
  32
  33 JackClientSocket::JackClientSocket(int socket): fSocket(socket)
  34 {}
  35
  36 void JackClientSocket::SetReadTimeOut(long sec)
  37 {
  38     struct timeval timout;
  39     timout.tv_sec = sec;
  40     timout.tv_usec = 0;
  41     if (setsockopt(fSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timout, sizeof(timeval)) < 0) {
  42         jack_error("SetReadTimeOut fd = %ld err = %s", fSocket, strerror(errno));
  43     }
  44 }
  45
  46 void JackClientSocket::SetWriteTimeOut(long sec)
  47 {
  48     struct timeval timout;
  49     timout.tv_sec = sec ;
  50     timout.tv_usec = 0;
  51     if (setsockopt(fSocket, SOL_SOCKET, SO_SNDTIMEO, (const char*)&timout, sizeof(timeval)) < 0) {
  52         jack_error("SetWriteTimeOut fd = %ld err = %s", fSocket, strerror(errno));
  53     }
  54 }
  55
  56 void JackClientSocket::SetNonBlocking(bool onoff)
  57 {
  58     int flag = (onoff) ? 1 : 0;
  59     if (ioctl(fSocket, FIONBIO, &flag) < 0) {
  60         jack_error("SetNonBlocking fd = %ld err = %s", fSocket, strerror(errno));
  61     }
  62 }
  63
  64 int JackClientSocket::Connect(const char* dir, const char* name, int which) // A revoir : utilisation de "which"
  65 {
  66     struct sockaddr_un addr;
  67
  68     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
  69         jack_error("Cannot create socket err = %s", strerror(errno));
  70         return -1;
  71     }
  72
  73     addr.sun_family = AF_UNIX;
  74     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%s_%d", dir, name, which);
  75     jack_log("Connect: addr.sun_path %s", addr.sun_path);
  76
  77     if (connect(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
  78         jack_error("Cannot connect to server socket err = %s", strerror(errno));
  79         close(fSocket);
  80         return -1;
  81     }
  82
  83 #ifdef __APPLE__
  84     int on = 1 ;
  85     if (setsockopt(fSocket, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&on, sizeof(on)) < 0) {
  86         jack_log("setsockopt SO_NOSIGPIPE fd = %ld err = %s", fSocket, strerror(errno));
  87     }
  88 #endif
  89
  90     return 0;
  91 }
  92
  93 int JackClientSocket::Connect(const char* dir, int which)
  94 {
  95     struct sockaddr_un addr;
  96
  97     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
  98         jack_error("Cannot create socket err = %s", strerror(errno));
  99         return -1;
 100     }
 101
 102     addr.sun_family = AF_UNIX;
 103     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%d", dir, which);
 104     jack_log("Connect: addr.sun_path %s", addr.sun_path);
 105
 106     if (connect(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
 107         jack_error("Cannot connect to server socket err = %s", strerror(errno));
 108         close(fSocket);
 109         return -1;
 110     }
 111
 112 #ifdef __APPLE__
 113     int on = 1 ;
 114     if (setsockopt(fSocket, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&on, sizeof(on)) < 0) {
 115         jack_log("setsockopt SO_NOSIGPIPE fd = %ld err = %s", fSocket, strerror(errno));
 116     }
 117 #endif
 118
 119     return 0;
 120 }
 121
 122 int JackClientSocket::Close()
 123 {
 124     jack_log("JackClientSocket::Close");
 125     if (fSocket > 0) {
 126         shutdown(fSocket, SHUT_RDWR);
 127         close(fSocket);
 128         fSocket = -1;
 129         return 0;
 130     } else {
 131         return -1;
 132     }
 133 }
 134
 135 int JackClientSocket::Read(void* data, int len)
 136 {
 137     if (read(fSocket, data, len) != len) {
 138         jack_error("Cannot read socket fd = %d err = %s", fSocket, strerror(errno));
 139         if (errno == EWOULDBLOCK) {
 140             jack_error("JackClientSocket::Read time out");
 141             return 0;  // For a non blocking socket, a read failure is not considered as an error
 142         } else {
 143             return -1;
 144         }
 145     } else {
 146         return 0;
 147     }
 148 }
 149
 150 int JackClientSocket::Write(void* data, int len)
 151 {
 152     if (write(fSocket, data, len) != len) {
 153         jack_error("Cannot write socket fd = %ld err = %s", fSocket, strerror(errno));
 154         if (errno == EWOULDBLOCK) {
 155             jack_log("JackClientSocket::Write time out");
 156             return 0;  // For a non blocking socket, a write failure is not considered as an error
 157         } else {
 158             return -1;
 159         }
 160     } else {
 161         return 0;
 162     }
 163 }
 164
 165 int JackServerSocket::Bind(const char* dir, const char* name, int which) // A revoir : utilisation de "which"
 166 {
 167     struct sockaddr_un addr;
 168
 169     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
 170         jack_error("Cannot create server socket err = %s", strerror(errno));
 171         return -1;
 172     }
 173
 174     addr.sun_family = AF_UNIX;
 175
 176     // TO CORRECT: always reuse the same name for now...
 177     snprintf(fName, sizeof(addr.sun_path) - 1, "%s/jack_%s_%d", dir, name, which);
 178     strncpy(addr.sun_path, fName, sizeof(addr.sun_path) - 1);
 179     /*
 180     if (access(addr.sun_path, F_OK) == 0) {
 181         goto error;
 182     }
 183     */
 184
 185     jack_log("Bind: addr.sun_path %s", addr.sun_path);
 186     unlink(fName); // Security...
 187
 188     if (bind(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
 189         jack_error("Cannot bind server to socket err = %s", strerror(errno));
 190         goto error;
 191     }
 192
 193     if (listen(fSocket, 1) < 0) {
 194         jack_error("Cannot enable listen on server socket err = %s", strerror(errno));
 195         goto error;
 196     }
 197
 198     return 0;
 199
 200 error:
 201     unlink(fName);
 202     close(fSocket);
 203     return -1;
 204 }
 205
 206 int JackServerSocket::Bind(const char* dir, int which) // A revoir : utilisation de "which"
 207 {
 208     struct sockaddr_un addr;
 209
 210     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
 211         jack_error("Cannot create server socket err = %s", strerror(errno));
 212         return -1;
 213     }
 214
 215     addr.sun_family = AF_UNIX;
 216
 217     /*
 218     for (int i = 0; i < 999; i++) {
 219         snprintf(addr.sun_path, sizeof(addr.sun_path) - 1,"%s/jack_%d", dir, i);
 220         snprintf(fName, sizeof(addr.sun_path) - 1,"%s/jack_%d", dir, i);
 221         if (access(addr.sun_path, F_OK) != 0) {
 222                 break;
 223         }
 224     }
 225     */
 226
 227     // TO CORRECT: always reuse the same name for now...
 228     snprintf(fName, sizeof(addr.sun_path) - 1, "%s/jack_%d", dir, which);
 229     strncpy(addr.sun_path, fName, sizeof(addr.sun_path) - 1);
 230     /*
 231     if (access(addr.sun_path, F_OK) == 0) {
 232         goto error;
 233     }
 234     */
 235
 236     jack_log("Bind: addr.sun_path %s", addr.sun_path);
 237     unlink(fName); // Security...
 238
 239     if (bind(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
 240         jack_error("Cannot bind server to socket err = %s", strerror(errno));
 241         goto error;
 242     }
 243
 244     if (listen(fSocket, 1) < 0) {
 245         jack_error("Cannot enable listen on server socket err = %s", strerror(errno));
 246         goto error;
 247     }
 248
 249     return 0;
 250
 251 error:
 252     unlink(fName);
 253     close(fSocket);
 254     return -1;
 255 }
 256
 257 JackClientSocket* JackServerSocket::Accept()
 258 {
 259     struct sockaddr_un client_addr;
 260     socklen_t client_addrlen;
 261
 262     memset(&client_addr, 0, sizeof(client_addr));
 263     client_addrlen = sizeof(client_addr);
 264
 265     int fd = accept(fSocket, (struct sockaddr*) & client_addr, &client_addrlen);
 266     if (fd < 0) {
 267         jack_error("Cannot accept new connection err = %s", strerror(errno));
 268         return 0;
 269     } else {
 270         return new JackClientSocket(fd);
 271     }
 272 }
 273
 274 int JackServerSocket::Close()
 275 {
 276     if (fSocket > 0) {
 277         jack_log("JackServerSocket::Close %s", fName);
 278         shutdown(fSocket, SHUT_RDWR);
 279         close(fSocket);
 280         unlink(fName);
 281         fSocket = -1;
 282         return 0;
 283     } else {
 284         return -1;
 285     }
 286 }
 287
 288 } // end of namespace
 289
 290