Changeset 170 for branches


Ignore:
Timestamp:
Apr 14, 2009, 3:59:26 PM (16 years ago)
Author:
Herwig Bauernfeind
Message:

Fix for Ticket #69 and #71

Location:
branches/samba-3.0/source/lib
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • branches/samba-3.0/source/lib/system.c

    r164 r170  
    115115#endif /* HAVE_USLEEP */
    116116}
    117 
    118117/*******************************************************************
    119118A read wrapper that will deal with EINTR.
    120119********************************************************************/
    121 #ifndef __OS2__
    122120ssize_t sys_read(int fd, void *buf, size_t count)
    123121{
    124122        ssize_t ret;
    125 
    126123        do {
    127124                ret = read(fd, buf, count);
    … …  
    129126        return ret;
    130127}
    131 #else
    132 ssize_t sys_read(int fd, void *buf, size_t count)
     128/*******************************************************************
     129A write wrapper that will deal with EINTR.
     130********************************************************************/
     131ssize_t sys_write(int fd, const void *buf, size_t count)
    133132{
    134133        ssize_t ret;
    135         int fds, err = 0;
    136 
    137         int timeout=1000; /* Timeout for select */
    138         do {
    139                 if (err == EAGAIN && timeout != 0) {
    140                         fds = fd;
    141                         ret = os2_select(&fds, 1, 0, 0, timeout);
    142                         if (ret != 1) {
    143                                 err = errno;
    144                                 DEBUG(3,("sys_read: select ret: %d,%s\n", ret, strerror(errno)));
    145                                 if (ret == 0) {
    146                                         err = errno = EAGAIN;
    147                                         ret = -1;
    148                                         continue;
    149                                 }
    150                                 if (err == EINTR)
    151                                         continue;
    152                                 return -1;
    153                         }
    154                 }
    155                 ret = read(fd, buf, count);
    156                 err = errno;
    157         } while (ret == -1 && (errno == EINTR  || (errno == EAGAIN && timeout != 0)));
    158         return ret;
    159 }
    160 #endif
    161 
    162 /*******************************************************************
    163 A write wrapper that will deal with EINTR.
    164 ********************************************************************/
    165  
    166 #ifndef __OS2__
    167 ssize_t sys_write(int fd, const void *buf, size_t count)
    168 {
    169         ssize_t ret;
    170 
    171134        do {
    172135                ret = write(fd, buf, count);
    … …  
    174137        return ret;
    175138}
    176 
    177 #else
    178 ssize_t sys_write(int fd, const void *buf, size_t count)
    179 {
    180         ssize_t ret;
    181         int fds, err = 0;
    182 
    183         int timeout=1000; /* Timeout for select */
    184         do {
    185                 if (err == EAGAIN && timeout != 0) {
    186                         fds = fd;
    187                         ret = os2_select(&fds, 0, 1, 0, timeout);
    188                         if (ret != 1) {
    189                                 err = errno;
    190                                 DEBUG(3,("sys_write: select ret: %d,%s\n", ret, strerror(errno)));
    191                                 if (ret == 0) {
    192                                         err = errno = EAGAIN;
    193                                         ret = -1;
    194                                         continue;
    195                                 }
    196                                 if (err == EINTR)
    197                                         continue;
    198                                 return -1;
    199                         }
    200                 }
    201                 ret = write(fd, buf, count);
    202                 err = errno;   
    203         } while (ret == -1 && (errno == EINTR || (errno == EAGAIN && timeout != 0)));
    204         return ret;
    205 }
    206 #endif
    207 
    208139/*******************************************************************
    209140A pread wrapper that will deal with EINTR and 64-bit file offsets.
    210141********************************************************************/
    211 
    212142#if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
    213143ssize_t sys_pread(int fd, void *buf, size_t count, SMB_OFF_T off)
    214144{
    215145        ssize_t ret;
    216 
    217146        do {
    218147#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PREAD64)
    … …  
    221150                ret = pread(fd, buf, count, off);
    222151#endif
    223 #ifndef __OS2__
    224152        } while (ret == -1 && errno == EINTR);
    225 #else
    226 /* On OS/2 - we randomly get 'Resource Temporarily Unavailable' errors - ignore these */
    227         } while (ret == -1 && ((errno == EINTR)||(errno == EAGAIN)));
    228 #endif
    229153        return ret;
    230154}
    231155#endif
    232 
    233156/*******************************************************************
    234157A write wrapper that will deal with EINTR and 64-bit file offsets.
    235158********************************************************************/
    236 
    237159#if defined(HAVE_PWRITE) || defined(HAVE_PWRITE64)
    238160ssize_t sys_pwrite(int fd, const void *buf, size_t count, SMB_OFF_T off)
    239161{
    240162        ssize_t ret;
    241 
    242163        do {
    243164#if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_PWRITE64)
    … …  
    246167                ret = pwrite(fd, buf, count, off);
    247168#endif
    248 #ifndef __OS2__
    249169        } while (ret == -1 && errno == EINTR);
    250 #else
    251 /* On OS/2 - we randomly get 'Resource Temporarily Unavailable' errors - ignore these */
    252         } while (ret == -1 && ((errno == EINTR)||(errno == EAGAIN)));
    253 #endif
    254170        return ret;
    255171}
    256172#endif
    257 
    258173/*******************************************************************
    259174A send wrapper that will deal with EINTR.
    260175********************************************************************/
    261 
    262176ssize_t sys_send(int s, const void *msg, size_t len, int flags)
    263177{
    264178        ssize_t ret;
    265 
    266179        do {
    267180                ret = send(s, msg, len, flags);
    268 #ifndef __OS2__
    269181        } while (ret == -1 && errno == EINTR);
    270 #else
    271 /* On OS/2 - we randomly get 'Resource Temporarily Unavailable' errors - ignore these */
    272         } while (ret == -1 && ((errno == EINTR)||(errno == EAGAIN)));
    273 #endif
    274182        return ret;
    275183}
    276 
    277184/*******************************************************************
    278185A sendto wrapper that will deal with EINTR.
    279186********************************************************************/
    280 
    281187ssize_t sys_sendto(int s,  const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
    282188{
    283189        ssize_t ret;
    284 
    285190        do {
    286191                ret = sendto(s, msg, len, flags, to, tolen);
    287 #ifndef __OS2__
    288192        } while (ret == -1 && errno == EINTR);
    289 #else
    290 /* On OS/2 - we randomly get 'Resource Temporarily Unavailable' errors - ignore these */
    291         } while (ret == -1 && ((errno == EINTR)||(errno == EAGAIN)));
    292 #endif
    293193        return ret;
    294194}
    295 
    296195/*******************************************************************
    297196A recv wrapper that will deal with EINTR.
    298197********************************************************************/
    299 
    300198ssize_t sys_recv(int fd, void *buf, size_t count, int flags)
    301199{
    302200        ssize_t ret;
    303 
    304201        do {
    305202                ret = recv(fd, buf, count, flags);
    … …  
    307204        return ret;
    308205}
    309 
    310206/*******************************************************************
    311207A recvfrom wrapper that will deal with EINTR.
    312208********************************************************************/
    313 
    314209ssize_t sys_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
    315210{
    316211        ssize_t ret;
    317 
    318212        do {
    319213                ret = recvfrom(s, buf, len, flags, from, fromlen);
    320 #ifndef __OS2__
    321214        } while (ret == -1 && errno == EINTR);
    322 #else
    323 /* On OS/2 - we randomly get 'Resource Temporarily Unavailable' errors - ignore these */
    324         } while (ret == -1 && ((errno == EINTR)||(errno == EAGAIN)));
    325 #endif
    326215        return ret;
    327216}
    328 
    329217/*******************************************************************
    330218A fcntl wrapper that will deal with EINTR.
    331219********************************************************************/
    332 
    333220int sys_fcntl_ptr(int fd, int cmd, void *arg)
    334221{
    335222        int ret;
    336 
    337223        do {
    338224                ret = fcntl(fd, cmd, arg);
    339 #ifndef __OS2__
    340225        } while (ret == -1 && errno == EINTR);
    341 #else
    342 /* On OS/2 - we randomly get 'Resource Temporarily Unavailable' errors - ignore these */
    343         } while (ret == -1 && ((errno == EINTR)||(errno == EAGAIN)));
    344 #endif
    345226        return ret;
    346227}
    347 
    348228/*******************************************************************
    349229A fcntl wrapper that will deal with EINTR.
    350230********************************************************************/
    351 
    352231int sys_fcntl_long(int fd, int cmd, long arg)
    353232{
    354233        int ret;
    355 
    356234        do {
    357235                ret = fcntl(fd, cmd, arg);
    358 #ifndef __OS2__
    359236        } while (ret == -1 && errno == EINTR);
    360 #else
    361 /* On OS/2 - we randomly get 'Resource Temporarily Unavailable' errors - ignore these */
    362         } while (ret == -1 && ((errno == EINTR)||(errno == EAGAIN)));
    363 #endif
    364 
    365237        return ret;
    366238}

  • branches/samba-3.0/source/lib/util.c

    r165 r170  
    747747        if((val = sys_fcntl_long(fd, F_GETFL, 0)) == -1)
    748748                return -1;
     749#ifndef __OS2__
    749750        if(set) /* Turn blocking on - ie. clear nonblock flag */
    750751                val &= ~FLAG_TO_SET;
    … …  
    752753                val |= FLAG_TO_SET;
    753754        return sys_fcntl_long( fd, F_SETFL, val);
     755#else
     756        if(set) /* turn blocking on - ie. clear nonblock flag */
     757                val = 0;
     758        else
     759                val = 1;
     760        return os2_ioctl(fd, FIONBIO, (char *) &val, sizeof(val));
     761#endif
     762
    754763#undef FLAG_TO_SET
    755764}
Note: See TracChangeset for help on using the changeset viewer.