rubbos/app/httpd-2.0.64/srclib/apr/network_io/os2/sendrecv.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "apr_arch_networkio.h"
  18 #include "apr_errno.h"
  19 #include "apr_general.h"
  20 #include "apr_network_io.h"
  21 #include "apr_lib.h"
  22 #include <sys/time.h>
  23
  24 APR_DECLARE(apr_status_t) apr_socket_send(apr_socket_t *sock, const char *buf,
  25                                           apr_size_t *len)
  26 {
  27     apr_ssize_t rv;
  28     int fds, err = 0;
  29
  30     if (*len > 65536) {
  31         *len = 65536;
  32     }
  33
  34     do {
  35         if (!sock->nonblock || err == SOCEWOULDBLOCK) {
  36             fds = sock->socketdes;
  37             rv = select(&fds, 0, 1, 0, sock->timeout >= 0 ? sock->timeout/1000 : -1);
  38
  39             if (rv != 1) {
  40                 *len = 0;
  41                 err = sock_errno();
  42
  43                 if (rv == 0)
  44                     return APR_TIMEUP;
  45
  46                 if (err == SOCEINTR)
  47                     continue;
  48
  49                 return APR_OS2_STATUS(err);
  50             }
  51         }
  52
  53         rv = send(sock->socketdes, buf, (*len), 0);
  54         err = rv < 0 ? sock_errno() : 0;
  55     } while (err == SOCEINTR || err == SOCEWOULDBLOCK);
  56
  57     if (err) {
  58         *len = 0;
  59         return APR_OS2_STATUS(err);
  60     }
  61
  62     (*len) = rv;
  63     return APR_SUCCESS;
  64 }
  65
  66
  67
  68 APR_DECLARE(apr_status_t) apr_socket_recv(apr_socket_t *sock, char *buf,
  69                                           apr_size_t *len)
  70 {
  71     apr_ssize_t rv;
  72     int fds, err = 0;
  73
  74     do {
  75         if (!sock->nonblock || (err == SOCEWOULDBLOCK && sock->timeout != 0)) {
  76             fds = sock->socketdes;
  77             rv = select(&fds, 1, 0, 0, sock->timeout >= 0 ? sock->timeout/1000 : -1);
  78
  79             if (rv != 1) {
  80                 *len = 0;
  81                 err = sock_errno();
  82
  83                 if (rv == 0)
  84                     return APR_TIMEUP;
  85
  86                 if (err == SOCEINTR)
  87                     continue;
  88
  89                 return APR_OS2_STATUS(err);
  90             }
  91         }
  92
  93         rv = recv(sock->socketdes, buf, (*len), 0);
  94         err = rv < 0 ? sock_errno() : 0;
  95     } while (err == SOCEINTR || (err == SOCEWOULDBLOCK && sock->timeout != 0));
  96
  97     if (err) {
  98         *len = 0;
  99         return APR_OS2_STATUS(err);
 100     }
 101
 102     (*len) = rv;
 103     return rv == 0 ? APR_EOF : APR_SUCCESS;
 104 }
 105
 106
 107
 108 APR_DECLARE(apr_status_t) apr_socket_sendv(apr_socket_t *sock,
 109                                            const struct iovec *vec,
 110                                            apr_int32_t nvec, apr_size_t *len)
 111 {
 112     apr_status_t rv;
 113     struct iovec *tmpvec;
 114     int fds, err = 0;
 115     int nv_tosend, total = 0;
 116
 117     /* Make sure writev() only gets fed 64k at a time */
 118     for ( nv_tosend = 0; nv_tosend < nvec && total + vec[nv_tosend].iov_len < 65536; nv_tosend++ ) {
 119         total += vec[nv_tosend].iov_len;
 120     }
 121
 122     tmpvec = alloca(sizeof(struct iovec) * nv_tosend);
 123     memcpy(tmpvec, vec, sizeof(struct iovec) * nv_tosend);
 124
 125     do {
 126         if (!sock->nonblock || err == SOCEWOULDBLOCK) {
 127             fds = sock->socketdes;
 128             rv = select(&fds, 0, 1, 0, sock->timeout >= 0 ? sock->timeout/1000 : -1);
 129
 130             if (rv != 1) {
 131                 *len = 0;
 132                 err = sock_errno();
 133
 134                 if (rv == 0)
 135                     return APR_TIMEUP;
 136
 137                 if (err == SOCEINTR)
 138                     continue;
 139
 140                 return APR_OS2_STATUS(err);
 141             }
 142         }
 143
 144         rv = writev(sock->socketdes, tmpvec, nv_tosend);
 145         err = rv < 0 ? sock_errno() : 0;
 146     } while (err == SOCEINTR || err == SOCEWOULDBLOCK);
 147
 148     if (err) {
 149         *len = 0;
 150         return APR_OS2_STATUS(err);
 151     }
 152
 153     *len = rv;
 154     return APR_SUCCESS;
 155 }
 156
 157 /* deprecated */
 158 APR_DECLARE(apr_status_t) apr_send(apr_socket_t *sock, const char *buf,
 159                                    apr_size_t *len)
 160 {
 161     return apr_socket_send(sock, buf, len);
 162 }
 163
 164 /* deprecated */
 165 APR_DECLARE(apr_status_t) apr_sendv(apr_socket_t *sock,
 166                                     const struct iovec *vec,
 167                                     apr_int32_t nvec, apr_size_t *len)
 168 {
 169     return apr_socket_sendv(sock, vec, nvec, len);
 170 }
 171
 172 /* deprecated */
 173 APR_DECLARE(apr_status_t) apr_recv(apr_socket_t *sock, char *buf,
 174                                    apr_size_t *len)
 175 {
 176     return apr_socket_recv(sock, buf, len);
 177 }