First cut at fix for the EINTR problem... More needs to be done I think.

Jeremy.
(This used to be commit 48475a7a697242b9fd7b1aec24389afb112569c4)

diff --git a/source3/lib/system.c b/source3/lib/system.c
index 8c7eec939ea10228d3db9bff2000373a8678fa42..d97751eb4b8269128ff10229b5b18caeb26adaee 100644 (file)
--- a/source3/lib/system.c
+++ b/source3/lib/system.c
@@ -72,6 +72,51 @@ int sys_usleep(long usecs)
 #endif /* HAVE_USLEEP */
 }
 
+/*******************************************************************
+A read wrapper that will deal with EINTR.
+********************************************************************/
+
+ssize_t sys_read(int fd, void *buf, size_t count)
+{
+       ssize_t ret;
+
+       do {
+               errno = 0;
+               ret = read(fd, buf, count);
+       } while (ret == -1 && errno == EINTR);
+       return ret;
+}
+
+/*******************************************************************
+A write wrapper that will deal with EINTR.
+********************************************************************/
+
+ssize_t sys_write(int fd, const void *buf, size_t count)
+{
+       ssize_t ret;
+
+       do {
+               errno = 0;
+               ret = write(fd, buf, count);
+       } while (ret == -1 && errno == EINTR);
+       return ret;
+}
+
+/*******************************************************************
+A send wrapper that will deal with EINTR.
+********************************************************************/
+
+int sys_send(int s, const void *msg, size_t len, int flags)
+{
+       ssize_t ret;
+
+       do {
+               errno = 0;
+               ret = send(s, msg, len, flags);
+       } while (ret == -1 && errno == EINTR);
+       return ret;
+}
+
 /*******************************************************************
 A stat() wrapper that will deal with 64 bit filesizes.
 ********************************************************************/

diff --git a/source3/lib/util.c b/source3/lib/util.c
index 7e2ad4963954e845ab5c00f9e228278757fd844e..c524adaa7af4fb9a49958c95265c2dcff1c8ecf8 100644 (file)
--- a/source3/lib/util.c
+++ b/source3/lib/util.c
@@ -1353,11 +1353,12 @@ BOOL fcntl_lock(int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
   lock.l_len = count;
   lock.l_pid = 0;
 
-  errno = 0;
+  do {
+         errno = 0;
+         ret = fcntl(fd,op,&lock);
+  } while (ret == -1 && errno == EINTR);
 
-  ret = fcntl(fd,op,&lock);
-
-  if (errno != 0)
+  if (ret == -1 && errno != 0)
     DEBUG(3,("fcntl_lock: fcntl lock gave errno %d (%s)\n",errno,strerror(errno)));
 
   /* a lock query */

diff --git a/source3/lib/util_sock.c b/source3/lib/util_sock.c
index af3182264d51c3c2293f2b097c5e0b036ee6ff1d..1c7f9ce11522b0bd8184e9068e4916d0a03a809f 100644 (file)
--- a/source3/lib/util_sock.c
+++ b/source3/lib/util_sock.c
@@ -247,10 +247,10 @@ static ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t ma
                        if (fd == sslFd) {
                                readret = SSL_read(ssl, buf + nread, maxcnt - nread);
                        } else {
-                               readret = read(fd, buf + nread, maxcnt - nread);
+                               readret = sys_read(fd, buf + nread, maxcnt - nread);
                        }
 #else /* WITH_SSL */
-                       readret = read(fd, buf + nread, maxcnt - nread);
+                       readret = sys_read(fd, buf + nread, maxcnt - nread);
 #endif /* WITH_SSL */
                        
                        if (readret == 0) {
@@ -304,10 +304,10 @@ static ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t ma
                if (fd == sslFd) {
                        readret = SSL_read(ssl, buf + nread, maxcnt - nread);
                }else{
-                       readret = read(fd, buf + nread, maxcnt - nread);
+                       readret = sys_read(fd, buf + nread, maxcnt - nread);
                }
 #else /* WITH_SSL */
-               readret = read(fd, buf+nread, maxcnt-nread);
+               readret = sys_read(fd, buf+nread, maxcnt-nread);
 #endif /* WITH_SSL */
                
                if (readret == 0) {
@@ -357,10 +357,10 @@ ssize_t read_with_timeout(int fd, char *buf, size_t mincnt, size_t maxcnt,
                        if(fd == sslFd){
                                readret = SSL_read(ssl, buf + nread, maxcnt - nread);
                        }else{
-                               readret = read(fd, buf + nread, maxcnt - nread);
+                               readret = sys_read(fd, buf + nread, maxcnt - nread);
                        }
 #else /* WITH_SSL */
-                       readret = read(fd, buf + nread, maxcnt - nread);
+                       readret = sys_read(fd, buf + nread, maxcnt - nread);
 #endif /* WITH_SSL */
                        
                        if (readret <= 0)
@@ -387,10 +387,10 @@ ssize_t read_with_timeout(int fd, char *buf, size_t mincnt, size_t maxcnt,
                if(fd == sslFd){
                        readret = SSL_read(ssl, buf + nread, maxcnt - nread);
                }else{
-                       readret = read(fd, buf + nread, maxcnt - nread);
+                       readret = sys_read(fd, buf + nread, maxcnt - nread);
                }
 #else /* WITH_SSL */
-               readret = read(fd, buf+nread, maxcnt-nread);
+               readret = sys_read(fd, buf+nread, maxcnt-nread);
 #endif /* WITH_SSL */
                
                if (readret <= 0)
@@ -409,12 +409,12 @@ send a keepalive packet (rfc1002)
 
 BOOL send_keepalive(int client)
 {
-  unsigned char buf[4];
+       unsigned char buf[4];
 
-  buf[0] = SMBkeepalive;
-  buf[1] = buf[2] = buf[3] = 0;
+       buf[0] = SMBkeepalive;
+       buf[1] = buf[2] = buf[3] = 0;
 
-  return(write_socket_data(client,(char *)buf,4) == 4);
+       return(write_socket_data(client,(char *)buf,4) == 4);
 }
 
 /****************************************************************************
@@ -423,38 +423,36 @@ BOOL send_keepalive(int client)
 
 ssize_t read_data(int fd,char *buffer,size_t N)
 {
-  ssize_t  ret;
-  size_t total=0;  
+       ssize_t ret;
+       size_t total=0;  
  
-  smb_read_error = 0;
+       smb_read_error = 0;
 
-  while (total < N)
-  {
+       while (total < N) {
 #ifdef WITH_SSL
-    if(fd == sslFd){
-      ret = SSL_read(ssl, buffer + total, N - total);
-    }else{
-      ret = read(fd,buffer + total,N - total);
-    }
+               if(fd == sslFd){
+                       ret = SSL_read(ssl, buffer + total, N - total);
+               }else{
+                       ret = sys_read(fd,buffer + total,N - total);
+               }
 #else /* WITH_SSL */
-    ret = read(fd,buffer + total,N - total);
+               ret = sys_read(fd,buffer + total,N - total);
 #endif /* WITH_SSL */
 
-    if (ret == 0)
-    {
-      DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
-      smb_read_error = READ_EOF;
-      return 0;
-    }
-    if (ret == -1)
-    {
-      DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
-      smb_read_error = READ_ERROR;
-      return -1;
-    }
-    total += ret;
-  }
-  return (ssize_t)total;
+               if (ret == 0) {
+                       DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
+                       smb_read_error = READ_EOF;
+                       return 0;
+               }
+
+               if (ret == -1) {
+                       DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
+                       smb_read_error = READ_ERROR;
+                       return -1;
+               }
+               total += ret;
+       }
+       return (ssize_t)total;
 }
 
 /****************************************************************************
@@ -463,38 +461,36 @@ ssize_t read_data(int fd,char *buffer,size_t N)
 
 static ssize_t read_socket_data(int fd,char *buffer,size_t N)
 {
-  ssize_t  ret;
-  size_t total=0;  
+       ssize_t ret;
+       size_t total=0;  
  
-  smb_read_error = 0;
+       smb_read_error = 0;
 
-  while (total < N)
-  {
+       while (total < N) {
 #ifdef WITH_SSL
-    if(fd == sslFd){
-      ret = SSL_read(ssl, buffer + total, N - total);
-    }else{
-      ret = read(fd,buffer + total,N - total);
+               if(fd == sslFd){
+                       ret = SSL_read(ssl, buffer + total, N - total);
+               }else{
+                       ret = sys_read(fd,buffer + total,N - total);
     }
 #else /* WITH_SSL */
-    ret = read(fd,buffer + total,N - total);
+               ret = sys_read(fd,buffer + total,N - total);
 #endif /* WITH_SSL */
 
-    if (ret == 0)
-    {
-      DEBUG(10,("read_socket_data: recv of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
-      smb_read_error = READ_EOF;
-      return 0;
-    }
-    if (ret == -1)
-    {
-      DEBUG(0,("read_socket_data: recv failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
-      smb_read_error = READ_ERROR;
-      return -1;
-    }
-    total += ret;
-  }
-  return (ssize_t)total;
+               if (ret == 0) {
+                       DEBUG(10,("read_socket_data: recv of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
+                       smb_read_error = READ_EOF;
+                       return 0;
+               }
+
+               if (ret == -1) {
+                       DEBUG(0,("read_socket_data: recv failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
+                       smb_read_error = READ_ERROR;
+                       return -1;
+               }
+               total += ret;
+       }
+       return (ssize_t)total;
 }
 
 /****************************************************************************
@@ -503,30 +499,30 @@ static ssize_t read_socket_data(int fd,char *buffer,size_t N)
 
 ssize_t write_data(int fd,char *buffer,size_t N)
 {
-  size_t total=0;
-  ssize_t ret;
+       size_t total=0;
+       ssize_t ret;
 
-  while (total < N)
-  {
+       while (total < N) {
 #ifdef WITH_SSL
-    if(fd == sslFd){
-      ret = SSL_write(ssl,buffer + total,N - total);
-    }else{
-      ret = write(fd,buffer + total,N - total);
-    }
+               if(fd == sslFd){
+                       ret = SSL_write(ssl,buffer + total,N - total);
+               }else{
+                       ret = sys_write(fd,buffer + total,N - total);
+               }
 #else /* WITH_SSL */
-    ret = write(fd,buffer + total,N - total);
+               ret = sys_write(fd,buffer + total,N - total);
 #endif /* WITH_SSL */
 
-    if (ret == -1) {
-      DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
-      return -1;
-    }
-    if (ret == 0) return total;
+               if (ret == -1) {
+                       DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
+                       return -1;
+               }
+               if (ret == 0)
+                       return total;
 
-    total += ret;
-  }
-  return (ssize_t)total;
+               total += ret;
+       }
+       return (ssize_t)total;
 }
 
 /****************************************************************************
@@ -535,30 +531,30 @@ ssize_t write_data(int fd,char *buffer,size_t N)
 
 ssize_t write_socket_data(int fd,char *buffer,size_t N)
 {
-  size_t total=0;
-  ssize_t ret;
+       size_t total=0;
+       ssize_t ret;
 
-  while (total < N)
-  {
+       while (total < N) {
 #ifdef WITH_SSL
-    if(fd == sslFd){
-      ret = SSL_write(ssl,buffer + total,N - total);
-    }else{
-      ret = send(fd,buffer + total,N - total, 0);
+               if(fd == sslFd){
+                       ret = SSL_write(ssl,buffer + total,N - total);
+               }else{
+                       ret = sys_send(fd,buffer + total,N - total, 0);
     }
 #else /* WITH_SSL */
-    ret = send(fd,buffer + total,N - total,0);
+               ret = sys_send(fd,buffer + total,N - total,0);
 #endif /* WITH_SSL */
 
-    if (ret == -1) {
-      DEBUG(0,("write_socket_data: write failure. Error = %s\n", strerror(errno) ));
-      return -1;
-    }
-    if (ret == 0) return total;
+               if (ret == -1) {
+                       DEBUG(0,("write_socket_data: write failure. Error = %s\n", strerror(errno) ));
+                       return -1;
+               }
+               if (ret == 0)
+                       return total;
 
-    total += ret;
-  }
-  return (ssize_t)total;
+               total += ret;
+       }
+       return (ssize_t)total;
 }
 
 /****************************************************************************
@@ -567,17 +563,17 @@ write to a socket
 
 ssize_t write_socket(int fd,char *buf,size_t len)
 {
-  ssize_t ret=0;
+       ssize_t ret=0;
 
-  DEBUG(6,("write_socket(%d,%d)\n",fd,(int)len));
-  ret = write_socket_data(fd,buf,len);
+       DEBUG(6,("write_socket(%d,%d)\n",fd,(int)len));
+       ret = write_socket_data(fd,buf,len);
       
-  DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,(int)len,(int)ret));
-  if(ret <= 0)
-    DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n", 
-       (int)len, fd, strerror(errno) ));
+       DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,(int)len,(int)ret));
+       if(ret <= 0)
+               DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n", 
+                       (int)len, fd, strerror(errno) ));
 
-  return(ret);
+       return(ret);
 }
 
 /****************************************************************************
@@ -590,30 +586,29 @@ timeout is in milliseconds.
 
 static ssize_t read_smb_length_return_keepalive(int fd,char *inbuf,unsigned int timeout)
 {
-  ssize_t len=0;
-  int msg_type;
-  BOOL ok = False;
+       ssize_t len=0;
+       int msg_type;
+       BOOL ok = False;
 
-  while (!ok)
-  {
-    if (timeout > 0)
-      ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
-    else 
-      ok = (read_socket_data(fd,inbuf,4) == 4);
+       while (!ok) {
+               if (timeout > 0)
+                       ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
+               else 
+                       ok = (read_socket_data(fd,inbuf,4) == 4);
 
-    if (!ok)
-      return(-1);
+               if (!ok)
+                       return(-1);
 
-    len = smb_len(inbuf);
-    msg_type = CVAL(inbuf,0);
+               len = smb_len(inbuf);
+               msg_type = CVAL(inbuf,0);
 
-    if (msg_type == SMBkeepalive) 
-      DEBUG(5,("Got keepalive packet\n"));
-  }
+               if (msg_type == SMBkeepalive) 
+                       DEBUG(5,("Got keepalive packet\n"));
+       }
 
-  DEBUG(10,("got smb length of %d\n",len));
+       DEBUG(10,("got smb length of %d\n",len));
 
-  return(len);
+       return(len);
 }
 
 /****************************************************************************
@@ -625,23 +620,22 @@ timeout is in milliseconds.
 
 ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout)
 {
-  ssize_t len;
+       ssize_t len;
 
-  for(;;)
-  {
-    len = read_smb_length_return_keepalive(fd, inbuf, timeout);
+       for(;;) {
+               len = read_smb_length_return_keepalive(fd, inbuf, timeout);
 
-    if(len < 0)
-      return len;
+               if(len < 0)
+                       return len;
 
-    /* Ignore session keepalives. */
-    if(CVAL(inbuf,0) != SMBkeepalive)
-      break;
-  }
+               /* Ignore session keepalives. */
+               if(CVAL(inbuf,0) != SMBkeepalive)
+                       break;
+       }
 
-  DEBUG(10,("read_smb_length: got smb length of %d\n",len));
+       DEBUG(10,("read_smb_length: got smb length of %d\n",len));
 
-  return len;
+       return len;
 }
 
 /****************************************************************************

diff --git a/source3/tdb/tdb.c b/source3/tdb/tdb.c
index 98caca82a100ba702cdbe6d03ad9ce2532058397..e3ba1db0d2a8f5d97e72cffb99693a9e89a1ed3d 100644 (file)
--- a/source3/tdb/tdb.c
+++ b/source3/tdb/tdb.c
@@ -169,6 +169,7 @@ static int tdb_brlock(TDB_CONTEXT *tdb, tdb_off offset,
                      int rw_type, int lck_type, int probe)
 {
        struct flock fl;
+       int ret;
 
        if (tdb->flags & TDB_NOLOCK)
                return 0;
@@ -183,7 +184,12 @@ static int tdb_brlock(TDB_CONTEXT *tdb, tdb_off offset,
        fl.l_len = 1;
        fl.l_pid = 0;
 
-       if (fcntl(tdb->fd,lck_type,&fl) == -1) {
+       do {
+               errno = 0;
+               ret = fcntl(tdb->fd,lck_type,&fl);
+       } while (ret == -1 && errno == EINTR);
+
+       if (ret == -1) {
                if (!probe) {
                        TDB_LOG((tdb, 5,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d\n", 
                                 tdb->fd, offset, rw_type, lck_type));