JackSocket.cpp

00001 /*
00002 Copyright (C) 2004-2006 Grame  
00003   
00004   This program is free software; you can redistribute it and/or modify
00005   it under the terms of the GNU Lesser General Public License as published by
00006   the Free Software Foundation; either version 2.1 of the License, or
00007   (at your option) any later version.
00008   
00009   This program is distributed in the hope that it will be useful,
00010   but WITHOUT ANY WARRANTY; without even the implied warranty of
00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012   GNU Lesser General Public License for more details.
00013   
00014   You should have received a copy of the GNU Lesser General Public License
00015   along with this program; if not, write to the Free Software 
00016   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00017 
00018 */
00019 
00020 #include "JackSocket.h"
00021 #include "JackError.h"
00022 #include <string.h>
00023 
00024 namespace Jack
00025 {
00026 
00027 JackClientSocket::JackClientSocket(int socket): fSocket(socket)
00028 {}
00029 
00030 void JackClientSocket::SetReadTimeOut(long sec)
00031 {
00032     struct timeval timout;
00033     timout.tv_sec = sec;
00034     timout.tv_usec = 0;
00035     if (setsockopt(fSocket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timout, sizeof(timeval)) < 0) {
00036         JackLog("setsockopt SO_RCVTIMEO fd = %ld err = (%s)\n", fSocket, strerror(errno));
00037     }
00038 }
00039 
00040 void JackClientSocket::SetWriteTimeOut(long sec)
00041 {
00042     struct timeval timout;
00043     timout.tv_sec = sec ;
00044     timout.tv_usec = 0;
00045     if (setsockopt(fSocket, SOL_SOCKET, SO_SNDTIMEO, (const char*)&timout, sizeof(timeval)) < 0) {
00046         JackLog("setsockopt SO_SNDTIMEO fd = %ld err = (%s)\n", fSocket, strerror(errno));
00047     }
00048 }
00049 
00050 int JackClientSocket::Connect(const char* dir, const char* name, int which) // A revoir : utilisation de "which"
00051 {
00052     struct sockaddr_un addr;
00053 
00054     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
00055         jack_error("Cannot create socket (%s)", strerror(errno));
00056         return -1;
00057     }
00058 
00059     addr.sun_family = AF_UNIX;
00060     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%s", dir, name);
00061 
00062     JackLog("Connect: addr.sun_path %s\n", addr.sun_path);
00063 
00064     if (connect(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
00065         jack_error("Cannot connect to server socket (%s)", strerror(errno));
00066         close(fSocket);
00067         return -1;
00068     }
00069 
00070 #ifdef __APPLE__
00071     int on = 1 ;
00072     if (setsockopt(fSocket, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&on, sizeof(on)) < 0) {
00073         JackLog("setsockopt SO_NOSIGPIPE fd = %ld err = %s\n", fSocket, strerror(errno));
00074     }
00075 #endif
00076 
00077     return 0;
00078 }
00079 
00080 int JackClientSocket::Connect(const char* dir, int which)
00081 {
00082     struct sockaddr_un addr;
00083 
00084     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
00085         jack_error("Cannot create socket (%s)", strerror(errno));
00086         return -1;
00087     }
00088 
00089     addr.sun_family = AF_UNIX;
00090     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%d", dir, which);
00091 
00092     JackLog("Connect: addr.sun_path %s\n", addr.sun_path);
00093 
00094     if (connect(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
00095         jack_error("Cannot connect to server socket (%s)", strerror(errno));
00096         close(fSocket);
00097         return -1;
00098     }
00099 
00100 #ifdef __APPLE__
00101     int on = 1 ;
00102     if (setsockopt(fSocket, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&on, sizeof(on)) < 0) {
00103         JackLog("setsockopt SO_NOSIGPIPE fd = %ld err = %s\n", fSocket, strerror(errno));
00104     }
00105 #endif
00106 
00107     return 0;
00108 }
00109 
00110 int JackClientSocket::Close()
00111 {
00112     JackLog("JackClientSocket::Close\n");
00113     //shutdown(fSocket, SHUT_RDWR);
00114     if (fSocket > 0) {
00115         close(fSocket);
00116         fSocket = -1;
00117         return 0;
00118     } else {
00119         return -1;
00120     }
00121 }
00122 
00123 int JackClientSocket::Read(void* data, int len)
00124 {
00125     int len1;
00126 
00127     if ((len1 = read(fSocket, data, len)) != len) {
00128         jack_error("Cannot read socket %d %d (%s)", len, len1, strerror(errno));
00129         if (errno == EWOULDBLOCK) {
00130             JackLog("JackClientSocket::Read time out\n");
00131             return 0;
00132         } else {
00133             return -1;
00134         }
00135     } else {
00136         return 0;
00137     }
00138 }
00139 
00140 int JackClientSocket::Write(void* data, int len)
00141 {
00142     if (write(fSocket, data, len) != len) {
00143         jack_error("Cannot write socket fd %ld (%s)", fSocket, strerror(errno));
00144         return -1;
00145     } else {
00146         return 0;
00147     }
00148 }
00149 
00150 /*
00151 void
00152 jack_cleanup_files ()
00153 {
00154         DIR *dir;
00155         struct dirent *dirent;
00156  
00157         // its important that we remove all files that jackd creates
00158         //   because otherwise subsequent attempts to start jackd will
00159         //   believe that an instance is already running.
00160         
00161  
00162         if ((dir = opendir (jack_server_dir)) == NULL) {
00163                 fprintf (stderr, "jack(%d): cannot open jack FIFO directory "
00164                          "(%s)\n", getpid(), strerror (errno));
00165                 return;
00166         }
00167  
00168         while ((dirent = readdir (dir)) != NULL) {
00169                 if (strncmp (dirent->d_name, "jack-", 5) == 0 ||
00170                     strncmp (dirent->d_name, "jack_", 5) == 0) {
00171                         char fullpath[PATH_MAX+1];
00172                         snprintf (fullpath, sizeof (fullpath), "%s/%s",
00173                                   jack_server_dir, dirent->d_name);
00174                         unlink (fullpath);
00175                 } 
00176         }
00177  
00178         closedir (dir);
00179 }
00180 */
00181 
00182 int JackServerSocket::Bind(const char* dir, const char* name, int which) // A revoir : utilisation de "which"
00183 {
00184     struct sockaddr_un addr;
00185 
00186     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
00187         jack_error("Cannot create server socket (%s)", strerror(errno));
00188         return -1;
00189     }
00190 
00191     addr.sun_family = AF_UNIX;
00192 
00193     // TO CORRECT: always reuse the same name for now...
00194     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%s", dir, name);
00195     snprintf(fName, sizeof(addr.sun_path) - 1, "%s/jack_%s", dir, name);
00196     /*
00197     if (access(addr.sun_path, F_OK) == 0) {
00198         goto error;
00199     }
00200     */
00201 
00202     JackLog("Bind: addr.sun_path %s\n", addr.sun_path);
00203     unlink(fName); // Security...
00204 
00205     JackLog("Bind: addr.sun_path %s\n", addr.sun_path);
00206     unlink(fName); // Security...
00207 
00208     if (bind(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
00209         jack_error("Cannot bind server to socket (%s)", strerror(errno));
00210         goto error;
00211     }
00212 
00213     if (listen(fSocket, 1) < 0) {
00214         jack_error("Cannot enable listen on server socket (%s)", strerror(errno));
00215         goto error;
00216     }
00217 
00218     return 0;
00219 
00220 error:
00221     unlink(fName);
00222     close(fSocket);
00223     return -1;
00224 }
00225 
00226 int JackServerSocket::Bind(const char* dir, int which) // A revoir : utilisation de "which"
00227 {
00228     struct sockaddr_un addr;
00229 
00230     if ((fSocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
00231         jack_error ("Cannot create server socket (%s)", strerror(errno));
00232         return -1;
00233     }
00234 
00235     addr.sun_family = AF_UNIX;
00236 
00237     /*
00238     for (int i = 0; i < 999; i++) {
00239         snprintf(addr.sun_path, sizeof(addr.sun_path) - 1,"%s/jack_%d", dir, i);
00240         snprintf(fName, sizeof(addr.sun_path) - 1,"%s/jack_%d", dir, i);
00241         if (access(addr.sun_path, F_OK) != 0) {
00242                 break;
00243         }
00244     }
00245     */
00246 
00247     // TO CORRECT: always reuse the same name for now...
00248     snprintf(addr.sun_path, sizeof(addr.sun_path) - 1, "%s/jack_%d", dir, which);
00249     snprintf(fName, sizeof(addr.sun_path) - 1, "%s/jack_%d", dir, which);
00250     /*
00251     if (access(addr.sun_path, F_OK) == 0) {
00252         goto error;
00253     }
00254     */
00255 
00256     JackLog("Bind: addr.sun_path %s\n", addr.sun_path);
00257     unlink(fName); // Security...
00258 
00259     if (bind(fSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
00260         jack_error("Cannot bind server to socket (%s)", strerror(errno));
00261         goto error;
00262     }
00263 
00264     if (listen(fSocket, 1) < 0) {
00265         jack_error("Cannot enable listen on server socket (%s)", strerror(errno));
00266         goto error;
00267     }
00268 
00269     return 0;
00270 
00271 error:
00272     unlink(fName);
00273     close(fSocket);
00274     return -1;
00275 }
00276 
00277 JackClientSocket* JackServerSocket::Accept()
00278 {
00279     struct sockaddr_un client_addr;
00280     socklen_t client_addrlen;
00281 
00282     memset(&client_addr, 0, sizeof(client_addr));
00283     client_addrlen = sizeof(client_addr);
00284 
00285     int fd = accept(fSocket, (struct sockaddr*) & client_addr, &client_addrlen);
00286     if (fd < 0) {
00287         jack_error("Cannot accept new connection (%s)", strerror(errno));
00288         return 0;
00289     } else {
00290         return new JackClientSocket(fd);
00291     }
00292 }
00293 
00294 int JackServerSocket::Close()
00295 {
00296     JackLog("JackServerSocket::Close %s\n", fName);
00297     //shutdown(fSocket, SHUT_RDWR);
00298     if (fSocket > 0) {
00299         //shutdown(fSocket, SHUT_RDWR);
00300         close(fSocket);
00301         unlink(fName);
00302         fSocket = -1;
00303         return 0;
00304     } else {
00305         return -1;
00306     }
00307 }
00308 
00309 } // end of namespace
00310 
00311 

Generated on Mon Oct 15 17:11:14 2007 for Jackdmp by  doxygen 1.5.1