?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump for 3.6-28
[LibreOffice.git] / sal / osl / unx / file.cxx
blob3a5dac5f97410f594785dc3767fbfaa33e26cc85
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*************************************************************************
3 *
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * Copyright 2000, 2010 Oracle and/or its affiliates.
7 *
8 * OpenOffice.org - a multi-platform office productivity suite
9 *
10 * This file is part of OpenOffice.org.
11 *
12 * OpenOffice.org is free software: you can redistribute it and/or modify
13 * it under the terms of the GNU Lesser General Public License version 3
14 * only, as published by the Free Software Foundation.
15 *
16 * OpenOffice.org is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Lesser General Public License version 3 for more details
20 * (a copy is included in the LICENSE file that accompanied this code).
21 *
22 * You should have received a copy of the GNU Lesser General Public License
23 * version 3 along with OpenOffice.org. If not, see
24 * <http://www.openoffice.org/license.html>
25 * for a copy of the LGPLv3 License.
26 *
27 ************************************************************************/
28
29
30 #include "osl/file.hxx"
31 #include "osl/detail/file.h"
32
33 #include "osl/diagnose.h"
34 #include "rtl/alloc.h"
35
36 #include "system.h"
37 #include "createfilehandlefromfd.hxx"
38 #include "file_error_transl.h"
39 #include "file_url.h"
40
41 #include <algorithm>
42 #include <limits>
43
44 #include <string.h>
45 #include <pthread.h>
46 #include <sys/mman.h>
47
48 #if defined(MACOSX)
49
50 #include <sys/param.h>
51 #include <sys/mount.h>
52 #define HAVE_O_EXLOCK
53
54 // add MACOSX Time Value
55 #define TimeValue CFTimeValue
56 #include <CoreFoundation/CoreFoundation.h>
57 #undef TimeValue
58
59 #endif /* MACOSX */
60
61 #ifdef ANDROID
62 #include <osl/detail/android-bootstrap.h>
63 #endif
64
65 #ifdef DEBUG_OSL_FILE
66 # define OSL_FILE_TRACE osl_trace
67 # define PERROR( a, b ) perror( a ); fprintf( stderr, b )
68 #else
69 # define OSL_FILE_TRACE(fmt, ...)
70 # define PERROR( a, b )
71 #endif
72
73
74
75 /*******************************************************************
76 *
77 * FileHandle_Impl interface
78 *
79 ******************************************************************/
80 struct FileHandle_Impl
81 {
82 pthread_mutex_t m_mutex;
83 rtl_String * m_strFilePath; /* holds native file path */
84 int m_fd;
85
86 enum Kind
87 {
88 KIND_FD = 1,
89 KIND_MEM = 2
90 };
91 int m_kind;
92 /** State
93 */
94 enum StateBits
95 {
96 STATE_SEEKABLE = 1, /* default */
97 STATE_READABLE = 2, /* default */
98 STATE_WRITEABLE = 4, /* open() sets, write() requires, else osl_File_E_BADF */
99 STATE_MODIFIED = 8 /* write() sets, flush() resets */
100 };
101 int m_state;
102
103 sal_uInt64 m_size; /* file size */
104 off_t m_offset; /* physical offset from begin of file */
105 off_t m_fileptr; /* logical offset from begin of file */
106
107 off_t m_bufptr; /* buffer offset from begin of file */
108 size_t m_buflen; /* buffer filled [0, m_bufsiz - 1] */
109
110 size_t m_bufsiz;
111 sal_uInt8 * m_buffer;
112
113 explicit FileHandle_Impl (int fd, Kind kind = KIND_FD, char const * path = "<anon>");
114 ~FileHandle_Impl();
115
116 static void* operator new (size_t n);
117 static void operator delete (void * p);
118
119 static size_t getpagesize();
120
121 sal_uInt64 getPos() const;
122 oslFileError setPos (sal_uInt64 uPos);
123
124 sal_uInt64 getSize() const;
125 oslFileError setSize (sal_uInt64 uSize);
126
127 oslFileError readAt (
128 off_t nOffset,
129 void * pBuffer,
130 size_t nBytesRequested,
131 sal_uInt64 * pBytesRead);
132
133 oslFileError writeAt (
134 off_t nOffset,
135 void const * pBuffer,
136 size_t nBytesToWrite,
137 sal_uInt64 * pBytesWritten);
138
139 oslFileError readFileAt (
140 off_t nOffset,
141 void * pBuffer,
142 size_t nBytesRequested,
143 sal_uInt64 * pBytesRead);
144
145 oslFileError writeFileAt (
146 off_t nOffset,
147 void const * pBuffer,
148 size_t nBytesToWrite,
149 sal_uInt64 * pBytesWritten);
150
151 oslFileError readLineAt (
152 off_t nOffset,
153 sal_Sequence ** ppSequence,
154 sal_uInt64 * pBytesRead);
155
156 oslFileError writeSequence_Impl (
157 sal_Sequence ** ppSequence,
158 size_t * pnOffset,
159 const void * pBuffer,
160 size_t nBytes);
161
162 oslFileError syncFile();
163
164 /** Buffer cache / allocator.
165 */
166 class Allocator
167 {
168 rtl_cache_type * m_cache;
169 size_t m_bufsiz;
170
171 Allocator (Allocator const &);
172 Allocator & operator= (Allocator const &);
173
174 public:
175 static Allocator & get();
176
177 void allocate (sal_uInt8 ** ppBuffer, size_t * pnSize);
178 void deallocate (sal_uInt8 * pBuffer);
179
180 protected:
181 Allocator();
182 ~Allocator();
183 };
184
185 /** Guard.
186 */
187 class Guard
188 {
189 pthread_mutex_t * m_mutex;
190
191 public:
192 explicit Guard(pthread_mutex_t * pMutex);
193 ~Guard();
194 };
195 };
196
197 /*******************************************************************
198 *
199 * FileHandle_Impl implementation
200 *
201 ******************************************************************/
202
203 FileHandle_Impl::Allocator &
204 FileHandle_Impl::Allocator::get()
205 {
206 static Allocator g_aBufferAllocator;
207 return g_aBufferAllocator;
208 }
209
210 FileHandle_Impl::Allocator::Allocator()
211 : m_cache (0),
212 m_bufsiz (0)
213 {
214 size_t const pagesize = FileHandle_Impl::getpagesize();
215 if (size_t(-1) != pagesize)
216 {
217 m_cache = rtl_cache_create (
218 "osl_file_buffer_cache", pagesize, 0, 0, 0, 0, 0, 0, 0);
219 if (0 != m_cache)
220 m_bufsiz = pagesize;
221 }
222 }
223 FileHandle_Impl::Allocator::~Allocator()
224 {
225 rtl_cache_destroy (m_cache), m_cache = 0;
226 }
227
228 void FileHandle_Impl::Allocator::allocate (sal_uInt8 ** ppBuffer, size_t * pnSize)
229 {
230 OSL_PRECOND((0 != ppBuffer) && (0 != pnSize), "FileHandle_Impl::Allocator::allocate(): contract violation");
231 if ((0 != ppBuffer) && (0 != pnSize))
232 *ppBuffer = static_cast< sal_uInt8* >(rtl_cache_alloc(m_cache)), *pnSize = m_bufsiz;
233 }
234 void FileHandle_Impl::Allocator::deallocate (sal_uInt8 * pBuffer)
235 {
236 if (0 != pBuffer)
237 rtl_cache_free (m_cache, pBuffer);
238 }
239
240 FileHandle_Impl::Guard::Guard(pthread_mutex_t * pMutex)
241 : m_mutex (pMutex)
242 {
243 OSL_PRECOND (m_mutex != 0, "FileHandle_Impl::Guard::Guard(): null pointer.");
244 (void) pthread_mutex_lock (m_mutex); // ignoring EINVAL ...
245 }
246 FileHandle_Impl::Guard::~Guard()
247 {
248 OSL_PRECOND (m_mutex != 0, "FileHandle_Impl::Guard::~Guard(): null pointer.");
249 (void) pthread_mutex_unlock (m_mutex);
250 }
251
252 FileHandle_Impl::FileHandle_Impl (int fd, enum Kind kind, char const * path)
253 : m_strFilePath (0),
254 m_fd (fd),
255 m_kind (kind),
256 m_state (STATE_SEEKABLE | STATE_READABLE),
257 m_size (0),
258 m_offset (0),
259 m_fileptr (0),
260 m_bufptr (-1),
261 m_buflen (0),
262 m_bufsiz (0),
263 m_buffer (0)
264 {
265 (void) pthread_mutex_init(&m_mutex, 0);
266 rtl_string_newFromStr (&m_strFilePath, path);
267 if (m_kind == KIND_FD) {
268 Allocator::get().allocate (&m_buffer, &m_bufsiz);
269 if (0 != m_buffer)
270 memset (m_buffer, 0, m_bufsiz);
271 }
272 }
273 FileHandle_Impl::~FileHandle_Impl()
274 {
275 if (m_kind == KIND_FD)
276 Allocator::get().deallocate (m_buffer), m_buffer = 0;
277 rtl_string_release (m_strFilePath), m_strFilePath = 0;
278 (void) pthread_mutex_destroy(&m_mutex); // ignoring EBUSY ...
279 }
280
281 void* FileHandle_Impl::operator new (size_t n)
282 {
283 return rtl_allocateMemory(n);
284 }
285 void FileHandle_Impl::operator delete (void * p)
286 {
287 rtl_freeMemory(p);
288 }
289
290 size_t FileHandle_Impl::getpagesize()
291 {
292 #if defined(FREEBSD) || defined(NETBSD) || defined(MACOSX) || \
293 defined(OPENBSD) || defined(DRAGONFLY)
294 return sal::static_int_cast< size_t >(::getpagesize());
295 #else /* POSIX */
296 return sal::static_int_cast< size_t >(::sysconf(_SC_PAGESIZE));
297 #endif /* xBSD || POSIX */
298 }
299
300 sal_uInt64 FileHandle_Impl::getPos() const
301 {
302 return sal::static_int_cast< sal_uInt64 >(m_fileptr);
303 }
304
305 oslFileError FileHandle_Impl::setPos (sal_uInt64 uPos)
306 {
307 OSL_FILE_TRACE("FileHandle_Impl::setPos(%d, %lld) => %lld", m_fd, getPos(), uPos);
308 m_fileptr = sal::static_int_cast< off_t >(uPos);
309 return osl_File_E_None;
310 }
311
312 sal_uInt64 FileHandle_Impl::getSize() const
313 {
314 off_t const bufend = std::max((off_t)(0), m_bufptr) + m_buflen;
315 return std::max(m_size, sal::static_int_cast< sal_uInt64 >(bufend));
316 }
317
318 oslFileError FileHandle_Impl::setSize (sal_uInt64 uSize)
319 {
320 off_t const nSize = sal::static_int_cast< off_t >(uSize);
321 if (-1 == ftruncate (m_fd, nSize))
322 {
323 /* Failure. Save original result. Try fallback algorithm */
324 oslFileError result = oslTranslateFileError (OSL_FET_ERROR, errno);
325
326 /* Check against current size. Fail upon 'shrink' */
327 if (uSize <= getSize())
328 {
329 /* Failure upon 'shrink'. Return original result */
330 return (result);
331 }
332
333 /* Save current position */
334 off_t const nCurPos = (off_t)lseek (m_fd, (off_t)0, SEEK_CUR);
335 if (nCurPos == (off_t)(-1))
336 return (result);
337
338 /* Try 'expand' via 'lseek()' and 'write()' */
339 if (-1 == lseek (m_fd, (off_t)(nSize - 1), SEEK_SET))
340 return (result);
341
342 if (-1 == write (m_fd, (char*)"", (size_t)1))
343 {
344 /* Failure. Restore saved position */
345 (void) lseek (m_fd, (off_t)(nCurPos), SEEK_SET);
346 return (result);
347 }
348
349 /* Success. Restore saved position */
350 if (-1 == lseek (m_fd, (off_t)nCurPos, SEEK_SET))
351 return (result);
352 }
353
354 OSL_FILE_TRACE("osl_setFileSize(%d, %lld) => %ld", m_fd, getSize(), nSize);
355 m_size = sal::static_int_cast< sal_uInt64 >(nSize);
356 return osl_File_E_None;
357 }
358
359 oslFileError FileHandle_Impl::readAt (
360 off_t nOffset,
361 void * pBuffer,
362 size_t nBytesRequested,
363 sal_uInt64 * pBytesRead)
364 {
365 OSL_PRECOND((m_state & STATE_SEEKABLE), "FileHandle_Impl::readAt(): not seekable");
366 if (!(m_state & STATE_SEEKABLE))
367 return osl_File_E_SPIPE;
368
369 OSL_PRECOND((m_state & STATE_READABLE), "FileHandle_Impl::readAt(): not readable");
370 if (!(m_state & STATE_READABLE))
371 return osl_File_E_BADF;
372
373 if (m_kind == KIND_MEM)
374 {
375 ssize_t nBytes;
376
377 m_offset = nOffset;
378
379 if ((sal_uInt64) m_offset >= m_size)
380 nBytes = 0;
381 else
382 {
383 nBytes = std::min(nBytesRequested, (size_t) (m_size - m_offset));
384 memmove(pBuffer, m_buffer + m_offset, nBytes);
385 m_offset += nBytes;
386 }
387 *pBytesRead = nBytes;
388 return osl_File_E_None;
389 }
390
391 #if defined(LINUX) || defined(SOLARIS)
392
393 ssize_t nBytes = ::pread (m_fd, pBuffer, nBytesRequested, nOffset);
394 if ((-1 == nBytes) && (EOVERFLOW == errno))
395 {
396 /* Some 'pread()'s fail with EOVERFLOW when reading at (or past)
397 * end-of-file, different from 'lseek() + read()' behaviour.
398 * Returning '0 bytes read' and 'osl_File_E_None' instead.
399 */
400 nBytes = 0;
401 }
402 if (-1 == nBytes)
403 return oslTranslateFileError (OSL_FET_ERROR, errno);
404
405 #else /* !(LINUX || SOLARIS) */
406
407 if (nOffset != m_offset)
408 {
409 if (-1 == ::lseek (m_fd, nOffset, SEEK_SET))
410 return oslTranslateFileError (OSL_FET_ERROR, errno);
411 m_offset = nOffset;
412 }
413
414 ssize_t nBytes = ::read (m_fd, pBuffer, nBytesRequested);
415 if (-1 == nBytes)
416 return oslTranslateFileError (OSL_FET_ERROR, errno);
417 m_offset += nBytes;
418
419 #endif /* !(LINUX || SOLARIS) */
420
421 OSL_FILE_TRACE("FileHandle_Impl::readAt(%d, %lld, %ld)", m_fd, nOffset, nBytes);
422 *pBytesRead = nBytes;
423 return osl_File_E_None;
424 }
425
426 oslFileError FileHandle_Impl::writeAt (
427 off_t nOffset,
428 void const * pBuffer,
429 size_t nBytesToWrite,
430 sal_uInt64 * pBytesWritten)
431 {
432 OSL_PRECOND((m_state & STATE_SEEKABLE), "FileHandle_Impl::writeAt(): not seekable");
433 if (!(m_state & STATE_SEEKABLE))
434 return osl_File_E_SPIPE;
435
436 OSL_PRECOND((m_state & STATE_WRITEABLE), "FileHandle_Impl::writeAt(): not writeable");
437 if (!(m_state & STATE_WRITEABLE))
438 return osl_File_E_BADF;
439
440 #if defined(LINUX) || defined(SOLARIS)
441
442 ssize_t nBytes = ::pwrite (m_fd, pBuffer, nBytesToWrite, nOffset);
443 if (-1 == nBytes)
444 return oslTranslateFileError (OSL_FET_ERROR, errno);
445
446 #else /* !(LINUX || SOLARIS) */
447
448 if (nOffset != m_offset)
449 {
450 if (-1 == ::lseek (m_fd, nOffset, SEEK_SET))
451 return oslTranslateFileError (OSL_FET_ERROR, errno);
452 m_offset = nOffset;
453 }
454
455 ssize_t nBytes = ::write (m_fd, pBuffer, nBytesToWrite);
456 if (-1 == nBytes)
457 return oslTranslateFileError (OSL_FET_ERROR, errno);
458 m_offset += nBytes;
459
460 #endif /* !(LINUX || SOLARIS) */
461
462 OSL_FILE_TRACE("FileHandle_Impl::writeAt(%d, %lld, %ld)", m_fd, nOffset, nBytes);
463 m_size = std::max (m_size, sal::static_int_cast< sal_uInt64 >(nOffset + nBytes));
464
465 *pBytesWritten = nBytes;
466 return osl_File_E_None;
467 }
468
469 oslFileError FileHandle_Impl::readFileAt (
470 off_t nOffset,
471 void * pBuffer,
472 size_t nBytesRequested,
473 sal_uInt64 * pBytesRead)
474 {
475 if (0 == (m_state & STATE_SEEKABLE))
476 {
477 // not seekable (pipe)
478 ssize_t nBytes = ::read (m_fd, pBuffer, nBytesRequested);
479 if (-1 == nBytes)
480 return oslTranslateFileError (OSL_FET_ERROR, errno);
481 *pBytesRead = nBytes;
482 return osl_File_E_None;
483 }
484 else if (m_kind == KIND_MEM || 0 == m_buffer)
485 {
486 // not buffered
487 return readAt (nOffset, pBuffer, nBytesRequested, pBytesRead);
488 }
489 else
490 {
491 sal_uInt8 * buffer = static_cast<sal_uInt8*>(pBuffer);
492 for (*pBytesRead = 0; nBytesRequested > 0; )
493 {
494 off_t const bufptr = (nOffset / m_bufsiz) * m_bufsiz;
495 size_t const bufpos = (nOffset % m_bufsiz);
496
497 if (bufptr != m_bufptr)
498 {
499 // flush current buffer
500 oslFileError result = syncFile();
501 if (result != osl_File_E_None)
502 return (result);
503 m_bufptr = -1, m_buflen = 0;
504
505 if (nBytesRequested >= m_bufsiz)
506 {
507 // buffer too small, read through from file
508 sal_uInt64 uDone = 0;
509 result = readAt (nOffset, &(buffer[*pBytesRead]), nBytesRequested, &uDone);
510 if (result != osl_File_E_None)
511 return (result);
512
513 nBytesRequested -= uDone, *pBytesRead += uDone;
514 return osl_File_E_None;
515 }
516
517 // update buffer (pointer)
518 sal_uInt64 uDone = 0;
519 result = readAt (bufptr, m_buffer, m_bufsiz, &uDone);
520 if (result != osl_File_E_None)
521 return (result);
522 m_bufptr = bufptr, m_buflen = uDone;
523 }
524 if (bufpos >= m_buflen)
525 {
526 // end of file
527 return osl_File_E_None;
528 }
529
530 size_t const bytes = std::min (m_buflen - bufpos, nBytesRequested);
531 OSL_FILE_TRACE("FileHandle_Impl::readFileAt(%d, %lld, %ld)", m_fd, nOffset, bytes);
532
533 memcpy (&(buffer[*pBytesRead]), &(m_buffer[bufpos]), bytes);
534 nBytesRequested -= bytes, *pBytesRead += bytes, nOffset += bytes;
535 }
536 return osl_File_E_None;
537 }
538 }
539
540 oslFileError FileHandle_Impl::writeFileAt (
541 off_t nOffset,
542 void const * pBuffer,
543 size_t nBytesToWrite,
544 sal_uInt64 * pBytesWritten)
545 {
546 if (0 == (m_state & STATE_SEEKABLE))
547 {
548 // not seekable (pipe)
549 ssize_t nBytes = ::write (m_fd, pBuffer, nBytesToWrite);
550 if (-1 == nBytes)
551 return oslTranslateFileError (OSL_FET_ERROR, errno);
552 *pBytesWritten = nBytes;
553 return osl_File_E_None;
554 }
555 else if (0 == m_buffer)
556 {
557 // not buffered
558 return writeAt (nOffset, pBuffer, nBytesToWrite, pBytesWritten);
559 }
560 else
561 {
562 sal_uInt8 const * buffer = static_cast<sal_uInt8 const *>(pBuffer);
563 for (*pBytesWritten = 0; nBytesToWrite > 0; )
564 {
565 off_t const bufptr = (nOffset / m_bufsiz) * m_bufsiz;
566 size_t const bufpos = (nOffset % m_bufsiz);
567 if (bufptr != m_bufptr)
568 {
569 // flush current buffer
570 oslFileError result = syncFile();
571 if (result != osl_File_E_None)
572 return (result);
573 m_bufptr = -1, m_buflen = 0;
574
575 if (nBytesToWrite >= m_bufsiz)
576 {
577 // buffer to small, write through to file
578 sal_uInt64 uDone = 0;
579 result = writeAt (nOffset, &(buffer[*pBytesWritten]), nBytesToWrite, &uDone);
580 if (result != osl_File_E_None)
581 return (result);
582 if (uDone != nBytesToWrite)
583 return osl_File_E_IO;
584
585 nBytesToWrite -= uDone, *pBytesWritten += uDone;
586 return osl_File_E_None;
587 }
588
589 // update buffer (pointer)
590 sal_uInt64 uDone = 0;
591 result = readAt (bufptr, m_buffer, m_bufsiz, &uDone);
592 if (result != osl_File_E_None)
593 return (result);
594 m_bufptr = bufptr, m_buflen = uDone;
595 }
596
597 size_t const bytes = std::min (m_bufsiz - bufpos, nBytesToWrite);
598 OSL_FILE_TRACE("FileHandle_Impl::writeFileAt(%d, %lld, %ld)", m_fd, nOffset, bytes);
599
600 memcpy (&(m_buffer[bufpos]), &(buffer[*pBytesWritten]), bytes);
601 nBytesToWrite -= bytes, *pBytesWritten += bytes, nOffset += bytes;
602
603 m_buflen = std::max(m_buflen, bufpos + bytes);
604 m_state |= STATE_MODIFIED;
605 }
606 return osl_File_E_None;
607 }
608 }
609
610 oslFileError FileHandle_Impl::readLineAt (
611 off_t nOffset,
612 sal_Sequence ** ppSequence,
613 sal_uInt64 * pBytesRead)
614 {
615 oslFileError result = osl_File_E_None;
616
617 off_t bufptr = nOffset / m_bufsiz * m_bufsiz;
618 if (bufptr != m_bufptr)
619 {
620 /* flush current buffer */
621 result = syncFile();
622 if (result != osl_File_E_None)
623 return (result);
624
625 /* update buffer (pointer) */
626 sal_uInt64 uDone = 0;
627 result = readAt (bufptr, m_buffer, m_bufsiz, &uDone);
628 if (result != osl_File_E_None)
629 return (result);
630
631 m_bufptr = bufptr, m_buflen = uDone;
632 }
633
634 static int const LINE_STATE_BEGIN = 0;
635 static int const LINE_STATE_CR = 1;
636 static int const LINE_STATE_LF = 2;
637
638 size_t bufpos = nOffset - m_bufptr, curpos = bufpos, dstpos = 0;
639 int state = (bufpos >= m_buflen) ? LINE_STATE_LF : LINE_STATE_BEGIN;
640
641 for ( ; state != LINE_STATE_LF; )
642 {
643 if (curpos >= m_buflen)
644 {
645 /* buffer examined */
646 if (0 < (curpos - bufpos))
647 {
648 /* flush buffer to sequence */
649 result = writeSequence_Impl (
650 ppSequence, &dstpos, &(m_buffer[bufpos]), curpos - bufpos);
651 if (result != osl_File_E_None)
652 return (result);
653 *pBytesRead += curpos - bufpos, nOffset += curpos - bufpos;
654 }
655
656 bufptr = nOffset / m_bufsiz * m_bufsiz;
657 if (bufptr != m_bufptr)
658 {
659 /* update buffer (pointer) */
660 sal_uInt64 uDone = 0;
661 result = readAt (bufptr, m_buffer, m_bufsiz, &uDone);
662 if (result != osl_File_E_None)
663 return (result);
664 m_bufptr = bufptr, m_buflen = uDone;
665 }
666
667 bufpos = nOffset - m_bufptr, curpos = bufpos;
668 if (bufpos >= m_buflen)
669 break;
670 }
671 switch (state)
672 {
673 case LINE_STATE_CR:
674 state = LINE_STATE_LF;
675 switch (m_buffer[curpos])
676 {
677 case 0x0A: /* CRLF */
678 /* eat current char */
679 curpos++;
680 break;
681 default: /* single CR */
682 /* keep current char */
683 break;
684 }
685 break;
686 default:
687 /* determine next state */
688 switch (m_buffer[curpos])
689 {
690 case 0x0A: /* single LF */
691 state = LINE_STATE_LF;
692 break;
693 case 0x0D: /* CR */
694 state = LINE_STATE_CR;
695 break;
696 default: /* advance to next char */
697 curpos++;
698 break;
699 }
700 if (state != LINE_STATE_BEGIN)
701 {
702 /* skip the newline char */
703 curpos++;
704
705 /* flush buffer to sequence */
706 result = writeSequence_Impl (
707 ppSequence, &dstpos, &(m_buffer[bufpos]), curpos - bufpos - 1);
708 if (result != osl_File_E_None)
709 return (result);
710 *pBytesRead += curpos - bufpos, nOffset += curpos - bufpos;
711 }
712 break;
713 }
714 }
715
716 result = writeSequence_Impl (ppSequence, &dstpos, 0, 0);
717 if (result != osl_File_E_None)
718 return (result);
719 if (0 < dstpos)
720 return osl_File_E_None;
721 if (bufpos >= m_buflen)
722 return osl_File_E_AGAIN;
723 return osl_File_E_None;
724 }
725
726 oslFileError FileHandle_Impl::writeSequence_Impl (
727 sal_Sequence ** ppSequence,
728 size_t * pnOffset,
729 const void * pBuffer,
730 size_t nBytes)
731 {
732 sal_Int32 nElements = *pnOffset + nBytes;
733 if (!*ppSequence)
734 {
735 /* construct sequence */
736 rtl_byte_sequence_constructNoDefault(ppSequence, nElements);
737 }
738 else if (nElements != (*ppSequence)->nElements)
739 {
740 /* resize sequence */
741 rtl_byte_sequence_realloc(ppSequence, nElements);
742 }
743 if (*ppSequence != 0)
744 {
745 /* fill sequence */
746 memcpy(&((*ppSequence)->elements[*pnOffset]), pBuffer, nBytes), *pnOffset += nBytes;
747 }
748 return (*ppSequence != 0) ? osl_File_E_None : osl_File_E_NOMEM;
749 }
750
751 oslFileError FileHandle_Impl::syncFile()
752 {
753 oslFileError result = osl_File_E_None;
754 if (m_state & STATE_MODIFIED)
755 {
756 sal_uInt64 uDone = 0;
757 result = writeAt (m_bufptr, m_buffer, m_buflen, &uDone);
758 if (result != osl_File_E_None)
759 return (result);
760 if (uDone != m_buflen)
761 return osl_File_E_IO;
762 m_state &= ~STATE_MODIFIED;
763 }
764 return (result);
765 }
766
767 oslFileHandle osl::detail::createFileHandleFromFD( int fd )
768 {
769 if (-1 == fd)
770 return 0; // EINVAL
771
772 struct stat aFileStat;
773 if (-1 == fstat (fd, &aFileStat))
774 return 0; // EBADF
775
776 FileHandle_Impl * pImpl = new FileHandle_Impl (fd);
777 if (0 == pImpl)
778 return 0; // ENOMEM
779
780 // assume writeable
781 pImpl->m_state |= FileHandle_Impl::STATE_WRITEABLE;
782 if (!S_ISREG(aFileStat.st_mode))
783 {
784 /* not a regular file, mark not seekable */
785 pImpl->m_state &= ~FileHandle_Impl::STATE_SEEKABLE;
786 }
787 else
788 {
789 /* regular file, init current size */
790 pImpl->m_size = sal::static_int_cast< sal_uInt64 >(aFileStat.st_size);
791 }
792
793 OSL_FILE_TRACE("osl::detail::createFileHandleFromFD(%d, writeable) => %s",
794 pImpl->m_fd, rtl_string_getStr(pImpl->m_strFilePath));
795 return (oslFileHandle)(pImpl);
796 }
797
798 /*******************************************************************
799 * osl_file_adjustLockFlags
800 ******************************************************************/
801 static int osl_file_adjustLockFlags (const char * path, int flags)
802 {
803 #ifdef MACOSX
804 /*
805 * The AFP implementation of MacOS X 10.4 treats O_EXLOCK in a way
806 * that makes it impossible for OOo to create a backup copy of the
807 * file it keeps opened. OTOH O_SHLOCK for AFP behaves as desired by
808 * the OOo file handling, so we need to check the path of the file
809 * for the filesystem name.
810 */
811 struct statfs s;
812 if( 0 <= statfs( path, &s ) )
813 {
814 if( 0 == strncmp("afpfs", s.f_fstypename, 5) )
815 {
816 flags &= ~O_EXLOCK;
817 flags |= O_SHLOCK;
818 }
819 else
820 {
821 /* Needed flags to allow opening a webdav file */
822 flags &= ~(O_EXLOCK | O_SHLOCK | O_NONBLOCK);
823 }
824 }
825 #endif /* MACOSX */
826
827 (void) path;
828 return flags;
829 }
830
831 /****************************************************************************
832 * osl_file_queryLocking
833 ***************************************************************************/
834 struct Locking_Impl
835 {
836 int m_enabled;
837 Locking_Impl() : m_enabled(0)
838 {
839 #ifndef HAVE_O_EXLOCK
840 m_enabled = (getenv("SAL_ENABLE_FILE_LOCKING") != 0);
841 #endif /* HAVE_O_EXLOCK */
842 }
843 };
844 static int osl_file_queryLocking (sal_uInt32 uFlags)
845 {
846 if (!(uFlags & osl_File_OpenFlag_NoLock))
847 {
848 if ((uFlags & osl_File_OpenFlag_Write) || (uFlags & osl_File_OpenFlag_Create))
849 {
850 static Locking_Impl g_locking;
851 return (g_locking.m_enabled != 0);
852 }
853 }
854 return 0;
855 }
856
857 #ifdef UNX
858
859 static oslFileError
860 osl_openMemoryAsFile( void *address, size_t size, oslFileHandle *pHandle, const char *path )
861 {
862 oslFileError eRet;
863 FileHandle_Impl * pImpl = new FileHandle_Impl (-1, FileHandle_Impl::KIND_MEM, path);
864 if (!pImpl)
865 {
866 eRet = oslTranslateFileError (OSL_FET_ERROR, ENOMEM);
867 return eRet;
868 }
869 pImpl->m_size = sal::static_int_cast< sal_uInt64 >(size);
870
871 *pHandle = (oslFileHandle)(pImpl);
872
873 pImpl->m_bufptr = 0;
874 pImpl->m_buflen = size;
875
876 pImpl->m_bufsiz = size;
877 pImpl->m_buffer = (sal_uInt8*) address;
878
879 return osl_File_E_None;
880 }
881
882 oslFileError
883 SAL_CALL osl_openMemoryAsFile( void *address, size_t size, oslFileHandle *pHandle )
884 {
885 return osl_openMemoryAsFile( address, size, pHandle, "<anon>" );
886 }
887
888 #endif
889
890 /****************************************************************************
891 * osl_openFile
892 ***************************************************************************/
893 #ifdef HAVE_O_EXLOCK
894 #define OPEN_WRITE_FLAGS ( O_RDWR | O_EXLOCK | O_NONBLOCK )
895 #define OPEN_CREATE_FLAGS ( O_CREAT | O_RDWR | O_EXLOCK | O_NONBLOCK )
896 #else
897 #define OPEN_WRITE_FLAGS ( O_RDWR )
898 #define OPEN_CREATE_FLAGS ( O_CREAT | O_RDWR )
899 #endif
900
901 oslFileError
902 SAL_CALL osl_openFilePath( const char *cpFilePath, oslFileHandle* pHandle, sal_uInt32 uFlags )
903 {
904 oslFileError eRet;
905
906 #ifdef ANDROID
907 /* Opening a file from /assets read-only means
908 * we should mmap it from the .apk file
909 */
910 if (strncmp (cpFilePath, "/assets/", sizeof ("/assets/") - 1) == 0)
911 {
912 if (uFlags & osl_File_OpenFlag_Write)
913 {
914 // Or should we just silently "open" it read-only and let write
915 // attempts, if any, fail then later?
916 OSL_TRACE("osl_openFile(%s, writeable), not possible!", cpFilePath);
917 errno = EPERM;
918 return osl_File_E_PERM;
919 }
920 void *address;
921 size_t size;
922 address = lo_apkentry(cpFilePath, &size);
923 OSL_TRACE("osl_openFile(%s) => %p",
924 cpFilePath, address);
925 if (address == NULL)
926 {
927 errno = ENOENT;
928 return osl_File_E_NOENT;
929 }
930 return osl_openMemoryAsFile(address, size, pHandle, cpFilePath);
931 }
932 #endif
933
934 /* set mode and flags */
935 int mode = S_IRUSR | S_IRGRP | S_IROTH;
936 int flags = O_RDONLY;
937 if (uFlags & osl_File_OpenFlag_Write)
938 {
939 mode |= S_IWUSR | S_IWGRP | S_IWOTH;
940 flags = OPEN_WRITE_FLAGS;
941 }
942 if (uFlags & osl_File_OpenFlag_Create)
943 {
944 mode |= S_IWUSR | S_IWGRP | S_IWOTH;
945 flags = OPEN_CREATE_FLAGS;
946 }
947
948 /* Check for flags passed in from SvFileStream::Open() */
949 if (uFlags & osl_File_OpenFlag_Trunc)
950 flags |= O_TRUNC;
951 if (!(uFlags & osl_File_OpenFlag_NoExcl))
952 flags |= O_EXCL;
953
954 if (uFlags & osl_File_OpenFlag_NoLock)
955 {
956 #ifdef HAVE_O_EXLOCK
957 flags &= ~(O_EXLOCK | O_SHLOCK | O_NONBLOCK);
958 #endif /* HAVE_O_EXLOCK */
959 }
960 else
961 {
962 flags = osl_file_adjustLockFlags (cpFilePath, flags);
963 }
964
965 /* open the file */
966 int fd = open( cpFilePath, flags, mode );
967 if (-1 == fd)
968 {
969 int saved_errno = errno;
970 OSL_TRACE("osl_openFile(%s, %s) failed: %s",
971 cpFilePath,
972 flags & O_RDWR ? "writeable":"readonly",
973 strerror(saved_errno));
974 return oslTranslateFileError (OSL_FET_ERROR, saved_errno);
975 }
976
977 /* reset O_NONBLOCK flag */
978 if (flags & O_NONBLOCK)
979 {
980 int f = fcntl (fd, F_GETFL, 0);
981 if (-1 == f)
982 {
983 int saved_errno = errno;
984 OSL_TRACE("osl_openFile(%s, %s): fcntl(%d, F_GETFL) failed: %s",
985 cpFilePath,
986 flags & O_RDWR ? "writeable":"readonly",
987 fd,
988 strerror(saved_errno));
989 eRet = oslTranslateFileError (OSL_FET_ERROR, saved_errno);
990 (void) close(fd);
991 return eRet;
992 }
993 if (-1 == fcntl (fd, F_SETFL, (f & ~O_NONBLOCK)))
994 {
995 int saved_errno = errno;
996 OSL_TRACE("osl_openFile(%s, %s): fcntl(%d, F_SETFL) failed: %s",
997 cpFilePath,
998 flags & O_RDWR ? "writeable":"readonly",
999 fd,
1000 strerror(saved_errno));
1001 eRet = oslTranslateFileError (OSL_FET_ERROR, saved_errno);
1002 (void) close(fd);
1003 return eRet;
1004 }
1005 }
1006
1007 /* get file status (mode, size) */
1008 struct stat aFileStat;
1009 if (-1 == fstat (fd, &aFileStat))
1010 {
1011 int saved_errno = errno;
1012 OSL_TRACE("osl_openFile(%s, %s): fstat(%d) failed: %s",
1013 cpFilePath,
1014 flags & O_RDWR ? "writeable":"readonly",
1015 fd,
1016 strerror(saved_errno));
1017 eRet = oslTranslateFileError (OSL_FET_ERROR, saved_errno);
1018 (void) close(fd);
1019 return eRet;
1020 }
1021 if (!S_ISREG(aFileStat.st_mode))
1022 {
1023 /* we only open regular files here */
1024 OSL_TRACE("osl_openFile(%s): not a regular file",
1025 cpFilePath);
1026 (void) close(fd);
1027 return osl_File_E_INVAL;
1028 }
1029
1030 if (osl_file_queryLocking (uFlags))
1031 {
1032 #ifdef MACOSX
1033 if (-1 == flock (fd, LOCK_EX | LOCK_NB))
1034 {
1035 /* Mac OSX returns ENOTSUP for webdav drives. We should try read lock */
1036 if ((errno != ENOTSUP) || ((-1 == flock (fd, LOCK_SH | LOCK_NB)) && (errno != ENOTSUP)))
1037 {
1038 eRet = oslTranslateFileError (OSL_FET_ERROR, errno);
1039 (void) close(fd);
1040 return eRet;
1041 }
1042 }
1043 #else /* F_SETLK */
1044 {
1045 struct flock aflock;
1046
1047 aflock.l_type = F_WRLCK;
1048 aflock.l_whence = SEEK_SET;
1049 aflock.l_start = 0;
1050 aflock.l_len = 0;
1051
1052 if (-1 == fcntl (fd, F_SETLK, &aflock))
1053 {
1054 int saved_errno = errno;
1055 OSL_TRACE("osl_openFile(%s, %s): fcntl(%d, F_SETLK) failed: %s",
1056 cpFilePath,
1057 flags & O_RDWR ? "writeable":"readonly",
1058 fd,
1059 strerror(saved_errno));
1060 eRet = oslTranslateFileError (OSL_FET_ERROR, saved_errno);
1061 (void) close(fd);
1062 return eRet;
1063 }
1064 }
1065 #endif /* F_SETLK */
1066 }
1067
1068 /* allocate memory for impl structure */
1069 FileHandle_Impl * pImpl = new FileHandle_Impl (fd, FileHandle_Impl::KIND_FD, cpFilePath);
1070 if (!pImpl)
1071 {
1072 eRet = oslTranslateFileError (OSL_FET_ERROR, ENOMEM);
1073 (void) close(fd);
1074 return eRet;
1075 }
1076 if (flags & O_RDWR)
1077 pImpl->m_state |= FileHandle_Impl::STATE_WRITEABLE;
1078 pImpl->m_size = sal::static_int_cast< sal_uInt64 >(aFileStat.st_size);
1079
1080 OSL_TRACE("osl_openFile(%s, %s) => %d",
1081 rtl_string_getStr(pImpl->m_strFilePath),
1082 flags & O_RDWR ? "writeable":"readonly",
1083 pImpl->m_fd);
1084
1085 *pHandle = (oslFileHandle)(pImpl);
1086 return osl_File_E_None;
1087 }
1088
1089 oslFileError
1090 SAL_CALL osl_openFile( rtl_uString* ustrFileURL, oslFileHandle* pHandle, sal_uInt32 uFlags )
1091 {
1092 oslFileError eRet;
1093
1094 if ((ustrFileURL == 0) || (ustrFileURL->length == 0) || (pHandle == 0))
1095 return osl_File_E_INVAL;
1096
1097 /* convert file URL to system path */
1098 char buffer[PATH_MAX];
1099 eRet = FileURLToPath (buffer, sizeof(buffer), ustrFileURL);
1100 if (eRet != osl_File_E_None)
1101 return eRet;
1102
1103 #ifdef MACOSX
1104 if (macxp_resolveAlias (buffer, sizeof(buffer)) != 0)
1105 return oslTranslateFileError (OSL_FET_ERROR, errno);
1106 #endif /* MACOSX */
1107
1108 return osl_openFilePath (buffer, pHandle, uFlags);
1109 }
1110
1111 /****************************************************************************/
1112 /* osl_closeFile */
1113 /****************************************************************************/
1114 oslFileError
1115 SAL_CALL osl_closeFile( oslFileHandle Handle )
1116 {
1117 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1118
1119 if (pImpl == 0)
1120 return osl_File_E_INVAL;
1121
1122 OSL_TRACE("osl_closeFile(%s:%d)", rtl_string_getStr(pImpl->m_strFilePath), pImpl->m_fd);
1123
1124 if (pImpl->m_kind == FileHandle_Impl::KIND_MEM)
1125 {
1126 delete pImpl;
1127 return osl_File_E_None;
1128 }
1129
1130 if (pImpl->m_fd < 0)
1131 return osl_File_E_INVAL;
1132
1133 (void) pthread_mutex_lock (&(pImpl->m_mutex));
1134
1135 /* close(2) implicitly (and unconditionally) unlocks */
1136 oslFileError result = pImpl->syncFile();
1137 if (result != osl_File_E_None)
1138 {
1139 /* close, ignoring double failure */
1140 (void) close (pImpl->m_fd);
1141 }
1142 else if (-1 == close (pImpl->m_fd))
1143 {
1144 /* translate error code */
1145 result = oslTranslateFileError (OSL_FET_ERROR, errno);
1146 }
1147
1148 (void) pthread_mutex_unlock (&(pImpl->m_mutex));
1149 delete pImpl;
1150 return (result);
1151 }
1152
1153 /************************************************
1154 * osl_syncFile
1155 ***********************************************/
1156 oslFileError
1157 SAL_CALL osl_syncFile(oslFileHandle Handle)
1158 {
1159 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1160
1161 if ((0 == pImpl) || ((pImpl->m_kind == FileHandle_Impl::KIND_FD) && (-1 == pImpl->m_fd)))
1162 return osl_File_E_INVAL;
1163
1164 if (pImpl->m_kind == FileHandle_Impl::KIND_MEM)
1165 return osl_File_E_None;
1166
1167 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1168
1169 OSL_TRACE("osl_syncFile(%d)", pImpl->m_fd);
1170 oslFileError result = pImpl->syncFile();
1171 if (result != osl_File_E_None)
1172 return (result);
1173 if (-1 == fsync (pImpl->m_fd))
1174 return oslTranslateFileError (OSL_FET_ERROR, errno);
1175
1176 return osl_File_E_None;
1177 }
1178
1179 /************************************************
1180 * osl_fileGetOSHandle
1181 ***********************************************/
1182 oslFileError
1183 SAL_CALL osl_getFileOSHandle(
1184 oslFileHandle Handle,
1185 sal_IntPtr *piFileHandle )
1186 {
1187 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1188
1189 if (0 == pImpl || pImpl->m_kind != FileHandle_Impl::KIND_FD || -1 == pImpl->m_fd)
1190 return osl_File_E_INVAL;
1191
1192 *piFileHandle = pImpl->m_fd;
1193
1194 return osl_File_E_None;
1195 }
1196
1197 /*******************************************
1198 osl_mapFile
1199 ********************************************/
1200 oslFileError
1201 SAL_CALL osl_mapFile (
1202 oslFileHandle Handle,
1203 void** ppAddr,
1204 sal_uInt64 uLength,
1205 sal_uInt64 uOffset,
1206 sal_uInt32 uFlags
1207 )
1208 {
1209 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1210
1211 if ((0 == pImpl) || ((pImpl->m_kind == FileHandle_Impl::KIND_FD) && (-1 == pImpl->m_fd)) || (0 == ppAddr))
1212 return osl_File_E_INVAL;
1213 *ppAddr = 0;
1214
1215 static sal_uInt64 const g_limit_size_t = std::numeric_limits< size_t >::max();
1216 if (g_limit_size_t < uLength)
1217 return osl_File_E_OVERFLOW;
1218 size_t const nLength = sal::static_int_cast< size_t >(uLength);
1219
1220 static sal_uInt64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1221 if (g_limit_off_t < uOffset)
1222 return osl_File_E_OVERFLOW;
1223
1224 if (pImpl->m_kind == FileHandle_Impl::KIND_MEM)
1225 {
1226 *ppAddr = pImpl->m_buffer + uOffset;
1227 return osl_File_E_None;
1228 }
1229
1230 off_t const nOffset = sal::static_int_cast< off_t >(uOffset);
1231
1232 void* p = mmap(NULL, nLength, PROT_READ, MAP_SHARED, pImpl->m_fd, nOffset);
1233 if (MAP_FAILED == p)
1234 return oslTranslateFileError(OSL_FET_ERROR, errno);
1235 *ppAddr = p;
1236
1237 if (uFlags & osl_File_MapFlag_RandomAccess)
1238 {
1239 // Determine memory pagesize.
1240 size_t const nPageSize = FileHandle_Impl::getpagesize();
1241 if (size_t(-1) != nPageSize)
1242 {
1243 /*
1244 * Pagein, touching first byte of every memory page.
1245 * Note: volatile disables optimizing the loop away.
1246 */
1247 sal_uInt8 * pData (reinterpret_cast<sal_uInt8*>(*ppAddr));
1248 size_t nSize (nLength);
1249
1250 volatile sal_uInt8 c = 0;
1251 while (nSize > nPageSize)
1252 {
1253 c ^= pData[0];
1254 pData += nPageSize;
1255 nSize -= nPageSize;
1256 }
1257 if (nSize > 0)
1258 {
1259 c^= pData[0];
1260 }
1261 }
1262 }
1263 if (uFlags & osl_File_MapFlag_WillNeed)
1264 {
1265 // On Linux, madvise(..., MADV_WILLNEED) appears to have the undesirable
1266 // effect of not returning until the data has actually been paged in, so
1267 // that its net effect would typically be to slow down the process
1268 // (which could start processing at the beginning of the data while the
1269 // OS simultaneously pages in the rest); on other platforms, it remains
1270 // to be evaluated whether madvise or equivalent is available and
1271 // actually useful:
1272 #if defined MACOSX
1273 int e = posix_madvise(p, nLength, POSIX_MADV_WILLNEED);
1274 if (e != 0)
1275 {
1276 OSL_TRACE(
1277 "posix_madvise(..., POSIX_MADV_WILLNEED) failed with %d", e);
1278 }
1279 #elif defined SOLARIS
1280 if (madvise(static_cast< caddr_t >(p), nLength, MADV_WILLNEED) != 0)
1281 {
1282 OSL_TRACE("madvise(..., MADV_WILLNEED) failed with %d", errno);
1283 }
1284 #endif
1285 }
1286 return osl_File_E_None;
1287 }
1288
1289 static
1290 oslFileError
1291 unmapFile (void* pAddr, sal_uInt64 uLength)
1292 {
1293 if (0 == pAddr)
1294 return osl_File_E_INVAL;
1295
1296 static sal_uInt64 const g_limit_size_t = std::numeric_limits< size_t >::max();
1297 if (g_limit_size_t < uLength)
1298 return osl_File_E_OVERFLOW;
1299 size_t const nLength = sal::static_int_cast< size_t >(uLength);
1300
1301 if (-1 == munmap(static_cast<char*>(pAddr), nLength))
1302 return oslTranslateFileError(OSL_FET_ERROR, errno);
1303
1304 return osl_File_E_None;
1305 }
1306
1307 #ifndef ANDROID
1308
1309 // Note that osl_unmapFile() just won't work on Android in general
1310 // where for (uncompressed) files inside the .apk, in the /assets
1311 // folder osl_mapFile just returns a pointer to the file inside the
1312 // already mmapped .apk archive.
1313
1314 /*******************************************
1315 osl_unmapFile
1316 ********************************************/
1317 oslFileError
1318 SAL_CALL osl_unmapFile (void* pAddr, sal_uInt64 uLength)
1319 {
1320 return unmapFile (pAddr, uLength);
1321 }
1322
1323 #endif
1324
1325 /*******************************************
1326 osl_unmapMappedFile
1327 ********************************************/
1328 oslFileError
1329 SAL_CALL osl_unmapMappedFile (oslFileHandle Handle, void* pAddr, sal_uInt64 uLength)
1330 {
1331 FileHandle_Impl * pImpl = static_cast<FileHandle_Impl*>(Handle);
1332
1333 if (pImpl == 0)
1334 return osl_File_E_INVAL;
1335
1336 if (pImpl->m_kind == FileHandle_Impl::KIND_FD)
1337 return unmapFile (pAddr, uLength);
1338
1339 // For parts of already mmapped "parent" files, whose mapping we
1340 // can't change, not much we can or should do...
1341 return osl_File_E_None;
1342 }
1343
1344 /*******************************************
1345 osl_readLine
1346 ********************************************/
1347 oslFileError
1348 SAL_CALL osl_readLine (
1349 oslFileHandle Handle,
1350 sal_Sequence ** ppSequence)
1351 {
1352 FileHandle_Impl * pImpl = static_cast<FileHandle_Impl*>(Handle);
1353
1354 if ((0 == pImpl) || ((pImpl->m_kind == FileHandle_Impl::KIND_FD) && (-1 == pImpl->m_fd)) || (0 == ppSequence))
1355 return osl_File_E_INVAL;
1356 sal_uInt64 uBytesRead = 0;
1357
1358 // read at current fileptr; fileptr += uBytesRead;
1359 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1360 oslFileError result = pImpl->readLineAt (
1361 pImpl->m_fileptr, ppSequence, &uBytesRead);
1362 if (result == osl_File_E_None)
1363 pImpl->m_fileptr += uBytesRead;
1364 return (result);
1365 }
1366
1367 /*******************************************
1368 osl_readFile
1369 ********************************************/
1370 oslFileError
1371 SAL_CALL osl_readFile (
1372 oslFileHandle Handle,
1373 void * pBuffer,
1374 sal_uInt64 uBytesRequested,
1375 sal_uInt64 * pBytesRead)
1376 {
1377 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1378
1379 if ((0 == pImpl) || ((pImpl->m_kind == FileHandle_Impl::KIND_FD) && (-1 == pImpl->m_fd)) || (0 == pBuffer) || (0 == pBytesRead))
1380 return osl_File_E_INVAL;
1381
1382 static sal_uInt64 const g_limit_ssize_t = std::numeric_limits< ssize_t >::max();
1383 if (g_limit_ssize_t < uBytesRequested)
1384 return osl_File_E_OVERFLOW;
1385 size_t const nBytesRequested = sal::static_int_cast< size_t >(uBytesRequested);
1386
1387 // read at current fileptr; fileptr += *pBytesRead;
1388 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1389 oslFileError result = pImpl->readFileAt (
1390 pImpl->m_fileptr, pBuffer, nBytesRequested, pBytesRead);
1391 if (result == osl_File_E_None)
1392 pImpl->m_fileptr += *pBytesRead;
1393 return (result);
1394 }
1395
1396 /*******************************************
1397 osl_writeFile
1398 ********************************************/
1399 oslFileError
1400 SAL_CALL osl_writeFile (
1401 oslFileHandle Handle,
1402 const void * pBuffer,
1403 sal_uInt64 uBytesToWrite,
1404 sal_uInt64 * pBytesWritten)
1405 {
1406 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1407
1408 if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == pBuffer) || (0 == pBytesWritten))
1409 return osl_File_E_INVAL;
1410 if (0 == (pImpl->m_state & FileHandle_Impl::STATE_WRITEABLE))
1411 return osl_File_E_BADF;
1412
1413 static sal_uInt64 const g_limit_ssize_t = std::numeric_limits< ssize_t >::max();
1414 if (g_limit_ssize_t < uBytesToWrite)
1415 return osl_File_E_OVERFLOW;
1416 size_t const nBytesToWrite = sal::static_int_cast< size_t >(uBytesToWrite);
1417
1418 // write at current fileptr; fileptr += *pBytesWritten;
1419 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1420 oslFileError result = pImpl->writeFileAt (
1421 pImpl->m_fileptr, pBuffer, nBytesToWrite, pBytesWritten);
1422 if (result == osl_File_E_None)
1423 pImpl->m_fileptr += *pBytesWritten;
1424 return (result);
1425 }
1426
1427 /*******************************************
1428 osl_readFileAt
1429 ********************************************/
1430 oslFileError
1431 SAL_CALL osl_readFileAt (
1432 oslFileHandle Handle,
1433 sal_uInt64 uOffset,
1434 void* pBuffer,
1435 sal_uInt64 uBytesRequested,
1436 sal_uInt64* pBytesRead)
1437 {
1438 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1439
1440 if ((0 == pImpl) || ((pImpl->m_kind == FileHandle_Impl::KIND_FD) && (-1 == pImpl->m_fd)) || (0 == pBuffer) || (0 == pBytesRead))
1441 return osl_File_E_INVAL;
1442 if (0 == (pImpl->m_state & FileHandle_Impl::STATE_SEEKABLE))
1443 return osl_File_E_SPIPE;
1444
1445 static sal_uInt64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1446 if (g_limit_off_t < uOffset)
1447 return osl_File_E_OVERFLOW;
1448 off_t const nOffset = sal::static_int_cast< off_t >(uOffset);
1449
1450 static sal_uInt64 const g_limit_ssize_t = std::numeric_limits< ssize_t >::max();
1451 if (g_limit_ssize_t < uBytesRequested)
1452 return osl_File_E_OVERFLOW;
1453 size_t const nBytesRequested = sal::static_int_cast< size_t >(uBytesRequested);
1454
1455 // read at specified fileptr
1456 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1457 return pImpl->readFileAt (nOffset, pBuffer, nBytesRequested, pBytesRead);
1458 }
1459
1460 /*******************************************
1461 osl_writeFileAt
1462 ********************************************/
1463 oslFileError
1464 SAL_CALL osl_writeFileAt (
1465 oslFileHandle Handle,
1466 sal_uInt64 uOffset,
1467 const void* pBuffer,
1468 sal_uInt64 uBytesToWrite,
1469 sal_uInt64* pBytesWritten)
1470 {
1471 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1472
1473 if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == pBuffer) || (0 == pBytesWritten))
1474 return osl_File_E_INVAL;
1475 if (0 == (pImpl->m_state & FileHandle_Impl::STATE_SEEKABLE))
1476 return osl_File_E_SPIPE;
1477 if (0 == (pImpl->m_state & FileHandle_Impl::STATE_WRITEABLE))
1478 return osl_File_E_BADF;
1479
1480 static sal_uInt64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1481 if (g_limit_off_t < uOffset)
1482 return osl_File_E_OVERFLOW;
1483 off_t const nOffset = sal::static_int_cast< off_t >(uOffset);
1484
1485 static sal_uInt64 const g_limit_ssize_t = std::numeric_limits< ssize_t >::max();
1486 if (g_limit_ssize_t < uBytesToWrite)
1487 return osl_File_E_OVERFLOW;
1488 size_t const nBytesToWrite = sal::static_int_cast< size_t >(uBytesToWrite);
1489
1490 // write at specified fileptr
1491 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1492 return pImpl->writeFileAt (nOffset, pBuffer, nBytesToWrite, pBytesWritten);
1493 }
1494
1495 /****************************************************************************/
1496 /* osl_isEndOfFile */
1497 /****************************************************************************/
1498 oslFileError
1499 SAL_CALL osl_isEndOfFile( oslFileHandle Handle, sal_Bool *pIsEOF )
1500 {
1501 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1502
1503 if ((0 == pImpl) || ((pImpl->m_kind == FileHandle_Impl::KIND_FD) && (-1 == pImpl->m_fd)) || (0 == pIsEOF))
1504 return osl_File_E_INVAL;
1505
1506 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1507 *pIsEOF = (pImpl->getPos() == pImpl->getSize());
1508 return osl_File_E_None;
1509 }
1510
1511 /************************************************
1512 * osl_getFilePos
1513 ***********************************************/
1514 oslFileError
1515 SAL_CALL osl_getFilePos( oslFileHandle Handle, sal_uInt64* pPos )
1516 {
1517 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1518
1519 if ((0 == pImpl) || ((pImpl->m_kind == FileHandle_Impl::KIND_FD) && (-1 == pImpl->m_fd)) || (0 == pPos))
1520 return osl_File_E_INVAL;
1521
1522 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1523 *pPos = pImpl->getPos();
1524 return osl_File_E_None;
1525 }
1526
1527 /*******************************************
1528 osl_setFilePos
1529 ********************************************/
1530 oslFileError
1531 SAL_CALL osl_setFilePos (oslFileHandle Handle, sal_uInt32 uHow, sal_Int64 uOffset)
1532 {
1533 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1534
1535 if ((0 == pImpl) || ((pImpl->m_kind == FileHandle_Impl::KIND_FD) && (-1 == pImpl->m_fd)))
1536 return osl_File_E_INVAL;
1537
1538 static sal_Int64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1539 if (g_limit_off_t < uOffset)
1540 return osl_File_E_OVERFLOW;
1541 off_t nPos = 0, nOffset = sal::static_int_cast< off_t >(uOffset);
1542
1543 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1544 switch(uHow)
1545 {
1546 case osl_Pos_Absolut:
1547 if (0 > nOffset)
1548 return osl_File_E_INVAL;
1549 break;
1550
1551 case osl_Pos_Current:
1552 nPos = sal::static_int_cast< off_t >(pImpl->getPos());
1553 if ((0 > nOffset) && (-1*nOffset > nPos))
1554 return osl_File_E_INVAL;
1555 if (g_limit_off_t < nPos + nOffset)
1556 return osl_File_E_OVERFLOW;
1557 break;
1558
1559 case osl_Pos_End:
1560 nPos = sal::static_int_cast< off_t >(pImpl->getSize());
1561 if ((0 > nOffset) && (-1*nOffset > nPos))
1562 return osl_File_E_INVAL;
1563 if (g_limit_off_t < nPos + nOffset)
1564 return osl_File_E_OVERFLOW;
1565 break;
1566
1567 default:
1568 return osl_File_E_INVAL;
1569 }
1570
1571 return pImpl->setPos (nPos + nOffset);
1572 }
1573
1574 /****************************************************************************
1575 * osl_getFileSize
1576 ****************************************************************************/
1577 oslFileError
1578 SAL_CALL osl_getFileSize( oslFileHandle Handle, sal_uInt64* pSize )
1579 {
1580 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1581
1582 if ((0 == pImpl) || ((pImpl->m_kind == FileHandle_Impl::KIND_FD) && (-1 == pImpl->m_fd)) || (0 == pSize))
1583 return osl_File_E_INVAL;
1584
1585 FileHandle_Impl::Guard lock (&(pImpl->m_mutex));
1586 *pSize = pImpl->getSize();
1587 return osl_File_E_None;
1588 }
1589
1590 /************************************************
1591 * osl_setFileSize
1592 ***********************************************/
1593 oslFileError
1594 SAL_CALL osl_setFileSize( oslFileHandle Handle, sal_uInt64 uSize )
1595 {
1596 FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1597
1598 if ((0 == pImpl) || (-1 == pImpl->m_fd))
1599 return osl_File_E_INVAL;
1600 if (0 == (pImpl->m_state & FileHandle_Impl::STATE_WRITEABLE))
1601 return osl_File_E_BADF;
1602
1603 static sal_uInt64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1604 if (g_limit_off_t < uSize)
1605 return osl_File_E_OVERFLOW;
1606
1607 oslFileError result = pImpl->syncFile();
1608 if (result != osl_File_E_None)
1609 return (result);
1610 pImpl->m_bufptr = -1, pImpl->m_buflen = 0;
1611
1612 return pImpl->setSize (uSize);
1613 }
1614
1615 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE