import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / lib / sendfile.c
1 /*
2  Unix SMB/Netbios implementation.
3  Version 2.2.x / 3.0.x
4  sendfile implementations.
5  Copyright (C) Jeremy Allison 2002.
6
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 2 of the License, or
10  (at your option) any later version.
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  GNU General Public License for more details.
15
16  You should have received a copy of the GNU General Public License
17  along with this program; if not, write to the Free Software
18  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 /*
22  * This file handles the OS dependent sendfile implementations.
23  * The API is such that it returns -1 on error, else returns the
24  * number of bytes written.
25  */
26
27 #include "includes.h"
28
29 #if defined(LINUX_SENDFILE_API)
30
31 #include <sys/sendfile.h>
32
33 #ifndef MSG_MORE
34 #define MSG_MORE 0x8000
35 #endif
36
37 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
38 {
39         size_t total=0;
40         ssize_t ret;
41         size_t hdr_len = 0;
42
43         /*
44          * Send the header first.
45          * Use MSG_MORE to cork the TCP output until sendfile is called.
46          */
47
48         if (header) {
49                 hdr_len = header->length;
50                 while (total < hdr_len) {
51                         ret = sys_send(tofd, header->data + total,hdr_len - total, MSG_MORE);
52                         if (ret == -1)
53                                 return -1;
54                         total += ret;
55                 }
56         }
57
58         total = count;
59         while (total) {
60                 ssize_t nwritten;
61                 do {
62 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_SENDFILE64)
63                         nwritten = sendfile64(tofd, fromfd, &offset, total);
64 #else
65                         nwritten = sendfile(tofd, fromfd, &offset, total);
66 #endif
67                 } while (nwritten == -1 && errno == EINTR);
68                 if (nwritten == -1)
69                         return -1;
70                 if (nwritten == 0)
71                         return -1; /* I think we're at EOF here... */
72                 total -= nwritten;
73         }
74         return count + hdr_len;
75 }
76
77 #elif defined(LINUX_BROKEN_SENDFILE_API)
78
79 /*
80  * We must use explicit 32 bit types here. This code path means Linux
81  * won't do proper 64-bit sendfile. JRA.
82  */
83
84 extern int32 sendfile (int out_fd, int in_fd, int32 *offset, uint32 count);
85
86
87 #ifndef MSG_MORE
88 #define MSG_MORE 0x8000
89 #endif
90
91 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
92 {
93         size_t total=0;
94         ssize_t ret;
95         ssize_t hdr_len = 0;
96         uint32 small_total = 0;
97         int32 small_offset;
98
99         /* 
100          * Fix for broken Linux 2.4 systems with no working sendfile64().
101          * If the offset+count > 2 GB then pretend we don't have the
102          * system call sendfile at all. The upper layer catches this
103          * and uses a normal read. JRA.
104          */
105
106         if ((sizeof(SMB_OFF_T) >= 8) && (offset + count > (SMB_OFF_T)0x7FFFFFFF)) {
107                 errno = ENOSYS;
108                 return -1;
109         }
110
111         /*
112          * Send the header first.
113          * Use MSG_MORE to cork the TCP output until sendfile is called.
114          */
115
116         if (header) {
117                 hdr_len = header->length;
118                 while (total < hdr_len) {
119                         ret = sys_send(tofd, header->data + total,hdr_len - total, MSG_MORE);
120                         if (ret == -1)
121                                 return -1;
122                         total += ret;
123                 }
124         }
125
126         small_total = (uint32)count;
127         small_offset = (int32)offset;
128
129         while (small_total) {
130                 int32 nwritten;
131                 do {
132                         nwritten = sendfile(tofd, fromfd, &small_offset, small_total);
133                 } while (nwritten == -1 && errno == EINTR);
134                 if (nwritten == -1)
135                         return -1;
136                 if (nwritten == 0)
137                         return -1; /* I think we're at EOF here... */
138                 small_total -= nwritten;
139         }
140         return count + hdr_len;
141 }
142
143
144 #elif defined(SOLARIS_SENDFILE_API)
145
146 /*
147  * Solaris sendfile code written by Pierre Belanger <belanger@pobox.com>.
148  */
149
150 #include <sys/sendfile.h>
151
152 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
153 {
154         int sfvcnt;
155         size_t total, xferred;
156         struct sendfilevec vec[2];
157         ssize_t hdr_len = 0;
158
159         if (header) {
160                 sfvcnt = 2;
161
162                 vec[0].sfv_fd = SFV_FD_SELF;
163                 vec[0].sfv_flag = 0;
164                 vec[0].sfv_off = (off_t)header->data;
165                 vec[0].sfv_len = hdr_len = header->length;
166
167                 vec[1].sfv_fd = fromfd;
168                 vec[1].sfv_flag = 0;
169                 vec[1].sfv_off = offset;
170                 vec[1].sfv_len = count;
171
172         } else {
173                 sfvcnt = 1;
174
175                 vec[0].sfv_fd = fromfd;
176                 vec[0].sfv_flag = 0;
177                 vec[0].sfv_off = offset;
178                 vec[0].sfv_len = count;
179         }
180
181         total = count + hdr_len;
182
183         while (total) {
184                 ssize_t nwritten;
185
186                 /*
187                  * Although not listed in the API error returns, this is almost certainly
188                  * a slow system call and will be interrupted by a signal with EINTR. JRA.
189                  */
190
191                 xferred = 0;
192
193 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_SENDFILEV64)
194                         nwritten = sendfilev64(tofd, vec, sfvcnt, &xferred);
195 #else
196                         nwritten = sendfilev(tofd, vec, sfvcnt, &xferred);
197 #endif
198                 if (nwritten == -1 && errno == EINTR) {
199                         if (xferred == 0)
200                                 continue; /* Nothing written yet. */
201                         else
202                                 nwritten = xferred;
203                 }
204
205                 if (nwritten == -1)
206                         return -1;
207                 if (nwritten == 0)
208                         return -1; /* I think we're at EOF here... */
209
210                 /*
211                  * If this was a short (signal interrupted) write we may need
212                  * to subtract it from the header data, or null out the header
213                  * data altogether if we wrote more than vec[0].sfv_len bytes.
214                  * We move vec[1].* to vec[0].* and set sfvcnt to 1
215                  */
216
217                 if (sfvcnt == 2 && nwritten >= vec[0].sfv_len) {
218                         vec[1].sfv_off += nwritten - vec[0].sfv_len;
219                         vec[1].sfv_len -= nwritten - vec[0].sfv_len;
220
221                         /* Move vec[1].* to vec[0].* and set sfvcnt to 1 */
222                         vec[0] = vec[1];
223                         sfvcnt = 1;
224                 } else {
225                         vec[0].sfv_off += nwritten;
226                         vec[0].sfv_len -= nwritten;
227                 }
228                 total -= nwritten;
229         }
230         return count + hdr_len;
231 }
232
233 #elif defined(HPUX_SENDFILE_API)
234
235 #include <sys/socket.h>
236 #include <sys/uio.h>
237
238 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
239 {
240         size_t total=0;
241         struct iovec hdtrl[2];
242         size_t hdr_len = 0;
243
244         if (header) {
245                 /* Set up the header/trailer iovec. */
246                 hdtrl[0].iov_base = header->data;
247                 hdtrl[0].iov_len = hdr_len = header->length;
248         } else {
249                 hdtrl[0].iov_base = NULL;
250                 hdtrl[0].iov_len = hdr_len = 0;
251         }
252         hdtrl[1].iov_base = NULL;
253         hdtrl[1].iov_base = 0;
254
255         total = count;
256         while (total + hdtrl[0].iov_len) {
257                 ssize_t nwritten;
258
259                 /*
260                  * HPUX guarantees that if any data was written before
261                  * a signal interrupt then sendfile returns the number of
262                  * bytes written (which may be less than requested) not -1.
263                  * nwritten includes the header data sent.
264                  */
265
266                 do {
267 #if defined(HAVE_EXPLICIT_LARGEFILE_SUPPORT) && defined(HAVE_OFF64_T) && defined(HAVE_SENDFILE64)
268                         nwritten = sendfile64(tofd, fromfd, offset, total, &hdtrl[0], 0);
269 #else
270                         nwritten = sendfile(tofd, fromfd, offset, total, &hdtrl[0], 0);
271 #endif
272                 } while (nwritten == -1 && errno == EINTR);
273                 if (nwritten == -1)
274                         return -1;
275                 if (nwritten == 0)
276                         return -1; /* I think we're at EOF here... */
277
278                 /*
279                  * If this was a short (signal interrupted) write we may need
280                  * to subtract it from the header data, or null out the header
281                  * data altogether if we wrote more than hdtrl[0].iov_len bytes.
282                  * We change nwritten to be the number of file bytes written.
283                  */
284
285                 if (hdtrl[0].iov_base && hdtrl[0].iov_len) {
286                         if (nwritten >= hdtrl[0].iov_len) {
287                                 nwritten -= hdtrl[0].iov_len;
288                                 hdtrl[0].iov_base = NULL;
289                                 hdtrl[0].iov_len = 0;
290                         } else {
291                                 /* iov_base is defined as a void *... */
292                                 hdtrl[0].iov_base = ((char *)hdtrl[0].iov_base) + nwritten;
293                                 hdtrl[0].iov_len -= nwritten;
294                                 nwritten = 0;
295                         }
296                 }
297                 total -= nwritten;
298                 offset += nwritten;
299         }
300         return count + hdr_len;
301 }
302
303 #elif defined(FREEBSD_SENDFILE_API)
304
305 #include <sys/types.h>
306 #include <sys/socket.h>
307 #include <sys/uio.h>
308
309 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
310 {
311         size_t total=0;
312         struct sf_hdtr hdr;
313         struct iovec hdtrl;
314         size_t hdr_len = 0;
315
316         hdr.headers = &hdtrl;
317         hdr.hdr_cnt = 1;
318         hdr.trailers = NULL;
319         hdr.trl_cnt = 0;
320
321         /* Set up the header iovec. */
322         if (header) {
323                 hdtrl.iov_base = header->data;
324                 hdtrl.iov_len = hdr_len = header->length;
325         } else {
326                 hdtrl.iov_base = NULL;
327                 hdtrl.iov_len = 0;
328         }
329
330         total = count;
331         while (total + hdtrl.iov_len) {
332                 SMB_OFF_T nwritten;
333                 int ret;
334
335                 /*
336                  * FreeBSD sendfile returns 0 on success, -1 on error.
337                  * Remember, the tofd and fromfd are reversed..... :-).
338                  * nwritten includes the header data sent.
339                  */
340
341                 do {
342                         ret = sendfile(fromfd, tofd, offset, total, &hdr, &nwritten, 0);
343                 } while (ret == -1 && errno == EINTR);
344                 if (ret == -1)
345                         return -1;
346
347                 if (nwritten == 0)
348                         return -1; /* I think we're at EOF here... */
349
350                 /*
351                  * If this was a short (signal interrupted) write we may need
352                  * to subtract it from the header data, or null out the header
353                  * data altogether if we wrote more than hdtrl.iov_len bytes.
354                  * We change nwritten to be the number of file bytes written.
355                  */
356
357                 if (hdtrl.iov_base && hdtrl.iov_len) {
358                         if (nwritten >= hdtrl.iov_len) {
359                                 nwritten -= hdtrl.iov_len;
360                                 hdtrl.iov_base = NULL;
361                                 hdtrl.iov_len = 0;
362                         } else {
363                                 hdtrl.iov_base += nwritten;
364                                 hdtrl.iov_len -= nwritten;
365                                 nwritten = 0;
366                         }
367                 }
368                 total -= nwritten;
369                 offset += nwritten;
370         }
371         return count + hdr_len;
372 }
373
374 #else /* No sendfile implementation. Return error. */
375
376 ssize_t sys_sendfile(int tofd, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count)
377 {
378         /* No sendfile syscall. */
379         errno = ENOSYS;
380         return -1;
381 }
382 #endif