187d2adbcSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
387d2adbcSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
487d2adbcSAndrew Rist * or more contributor license agreements. See the NOTICE file
587d2adbcSAndrew Rist * distributed with this work for additional information
687d2adbcSAndrew Rist * regarding copyright ownership. The ASF licenses this file
787d2adbcSAndrew Rist * to you under the Apache License, Version 2.0 (the
887d2adbcSAndrew Rist * "License"); you may not use this file except in compliance
987d2adbcSAndrew Rist * with the License. You may obtain a copy of the License at
1087d2adbcSAndrew Rist *
1187d2adbcSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
1287d2adbcSAndrew Rist *
1387d2adbcSAndrew Rist * Unless required by applicable law or agreed to in writing,
1487d2adbcSAndrew Rist * software distributed under the License is distributed on an
1587d2adbcSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
1687d2adbcSAndrew Rist * KIND, either express or implied. See the License for the
1787d2adbcSAndrew Rist * specific language governing permissions and limitations
1887d2adbcSAndrew Rist * under the License.
1987d2adbcSAndrew Rist *
2087d2adbcSAndrew Rist *************************************************************/
2187d2adbcSAndrew Rist
2287d2adbcSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir
25cdf0e10cSrcweir /************************************************************************
26cdf0e10cSrcweir * ToDo
27cdf0e10cSrcweir *
28cdf0e10cSrcweir * Fix osl_getCanonicalName
29cdf0e10cSrcweir *
30cdf0e10cSrcweir * - Fix: check for corresponding struct sizes in exported functions
31cdf0e10cSrcweir * - check size/use of oslDirectory
32cdf0e10cSrcweir * - check size/use of oslDirectoryItem
33cdf0e10cSrcweir * - check size/use of oslFileStatus
34cdf0e10cSrcweir * - check size/use of oslVolumeDeviceHandle
35cdf0e10cSrcweir * - check size/use of oslVolumeInfo
36cdf0e10cSrcweir * - check size/use of oslFileHandle
37cdf0e10cSrcweir ***********************************************************************/
38cdf0e10cSrcweir
39cdf0e10cSrcweir #define INCL_DOSDEVIOCTL // OS2 device definitions
40cdf0e10cSrcweir
41cdf0e10cSrcweir #include "system.h"
42cdf0e10cSrcweir #include <rtl/alloc.h>
43cdf0e10cSrcweir
44cdf0e10cSrcweir #include "osl/file.hxx"
45cdf0e10cSrcweir
46cdf0e10cSrcweir
47cdf0e10cSrcweir #include <sal/types.h>
48cdf0e10cSrcweir #include <osl/thread.h>
49cdf0e10cSrcweir #include <osl/diagnose.h>
50cdf0e10cSrcweir #include "file_error_transl.h"
51cdf0e10cSrcweir #include <osl/time.h>
52cdf0e10cSrcweir
53cdf0e10cSrcweir #ifndef _FILE_URL_H_
54cdf0e10cSrcweir #include "file_url.h"
55cdf0e10cSrcweir #endif
56cdf0e10cSrcweir
57cdf0e10cSrcweir #include "file_path_helper.hxx"
58cdf0e10cSrcweir #include "uunxapi.hxx"
59cdf0e10cSrcweir
60cdf0e10cSrcweir #ifndef _STRING_H_
61cdf0e10cSrcweir #include <string.h>
62cdf0e10cSrcweir #endif
63cdf0e10cSrcweir
64cdf0e10cSrcweir #ifndef _CTYPE_H_
65cdf0e10cSrcweir #include <ctype.h>
66cdf0e10cSrcweir #endif
67cdf0e10cSrcweir
68cdf0e10cSrcweir #ifndef _WCHAR_H_
69cdf0e10cSrcweir #include <wchar.h>
70cdf0e10cSrcweir #endif
71cdf0e10cSrcweir
72dcc6e752SPedro Giffuni #include <algorithm>
73dcc6e752SPedro Giffuni
74dcc6e752SPedro Giffuni #include <limits>
75dcc6e752SPedro Giffuni #include <sys/mman.h>
76dcc6e752SPedro Giffuni
77cdf0e10cSrcweir #if OSL_DEBUG_LEVEL > 1
78cdf0e10cSrcweir extern void debug_ustring(rtl_uString*);
79cdf0e10cSrcweir #endif
80cdf0e10cSrcweir
81cdf0e10cSrcweir
82cdf0e10cSrcweir #ifdef DEBUG_OSL_FILE
83cdf0e10cSrcweir # define PERROR( a, b ) perror( a ); fprintf( stderr, b )
84cdf0e10cSrcweir #else
85cdf0e10cSrcweir # define PERROR( a, b )
86cdf0e10cSrcweir #endif
87cdf0e10cSrcweir
88cdf0e10cSrcweir extern "C" oslFileHandle osl_createFileHandleFromFD( int fd );
89cdf0e10cSrcweir
90cdf0e10cSrcweir struct errentry errtable[] = {
91cdf0e10cSrcweir { NO_ERROR, osl_File_E_None }, /* 0 */
92cdf0e10cSrcweir { ERROR_INVALID_FUNCTION, osl_File_E_INVAL }, /* 1 */
93cdf0e10cSrcweir { ERROR_FILE_NOT_FOUND, osl_File_E_NOENT }, /* 2 */
94cdf0e10cSrcweir { ERROR_PATH_NOT_FOUND, osl_File_E_NOENT }, /* 3 */
95cdf0e10cSrcweir { ERROR_TOO_MANY_OPEN_FILES, osl_File_E_MFILE }, /* 4 */
96cdf0e10cSrcweir { ERROR_ACCESS_DENIED, osl_File_E_ACCES }, /* 5 */
97cdf0e10cSrcweir { ERROR_INVALID_HANDLE, osl_File_E_BADF }, /* 6 */
98cdf0e10cSrcweir { ERROR_ARENA_TRASHED, osl_File_E_NOMEM }, /* 7 */
99cdf0e10cSrcweir { ERROR_NOT_ENOUGH_MEMORY, osl_File_E_NOMEM }, /* 8 */
100cdf0e10cSrcweir { ERROR_INVALID_BLOCK, osl_File_E_NOMEM }, /* 9 */
101cdf0e10cSrcweir { ERROR_BAD_ENVIRONMENT, osl_File_E_2BIG }, /* 10 */
102cdf0e10cSrcweir { ERROR_BAD_FORMAT, osl_File_E_NOEXEC }, /* 11 */
103cdf0e10cSrcweir { ERROR_INVALID_ACCESS, osl_File_E_INVAL }, /* 12 */
104cdf0e10cSrcweir { ERROR_INVALID_DATA, osl_File_E_INVAL }, /* 13 */
105cdf0e10cSrcweir { ERROR_INVALID_DRIVE, osl_File_E_NOENT }, /* 15 */
106cdf0e10cSrcweir { ERROR_CURRENT_DIRECTORY, osl_File_E_ACCES }, /* 16 */
107cdf0e10cSrcweir { ERROR_NOT_SAME_DEVICE, osl_File_E_XDEV }, /* 17 */
108cdf0e10cSrcweir { ERROR_NO_MORE_FILES, osl_File_E_NOENT }, /* 18 */
109cdf0e10cSrcweir { ERROR_NOT_READY, osl_File_E_NOTREADY }, /* 21 */
110cdf0e10cSrcweir { ERROR_LOCK_VIOLATION, osl_File_E_ACCES }, /* 33 */
111cdf0e10cSrcweir { ERROR_BAD_NETPATH, osl_File_E_NOENT }, /* 53 */
112cdf0e10cSrcweir { ERROR_NETWORK_ACCESS_DENIED, osl_File_E_ACCES }, /* 65 */
113cdf0e10cSrcweir { ERROR_BAD_NET_NAME, osl_File_E_NOENT }, /* 67 */
114cdf0e10cSrcweir { ERROR_FILE_EXISTS, osl_File_E_EXIST }, /* 80 */
115cdf0e10cSrcweir { ERROR_CANNOT_MAKE, osl_File_E_ACCES }, /* 82 */
116cdf0e10cSrcweir { ERROR_FAIL_I24, osl_File_E_ACCES }, /* 83 */
117cdf0e10cSrcweir { ERROR_INVALID_PARAMETER, osl_File_E_INVAL }, /* 87 */
118cdf0e10cSrcweir { ERROR_NO_PROC_SLOTS, osl_File_E_AGAIN }, /* 89 */
119cdf0e10cSrcweir { ERROR_DRIVE_LOCKED, osl_File_E_ACCES }, /* 108 */
120cdf0e10cSrcweir { ERROR_BROKEN_PIPE, osl_File_E_PIPE }, /* 109 */
121cdf0e10cSrcweir { ERROR_DISK_FULL, osl_File_E_NOSPC }, /* 112 */
122cdf0e10cSrcweir { ERROR_INVALID_TARGET_HANDLE, osl_File_E_BADF }, /* 114 */
123cdf0e10cSrcweir { ERROR_INVALID_HANDLE, osl_File_E_INVAL }, /* 124 */
124cdf0e10cSrcweir { ERROR_WAIT_NO_CHILDREN, osl_File_E_CHILD }, /* 128 */
125cdf0e10cSrcweir { ERROR_CHILD_NOT_COMPLETE, osl_File_E_CHILD }, /* 129 */
126cdf0e10cSrcweir { ERROR_DIRECT_ACCESS_HANDLE, osl_File_E_BADF }, /* 130 */
127cdf0e10cSrcweir { ERROR_NEGATIVE_SEEK, osl_File_E_INVAL }, /* 131 */
128cdf0e10cSrcweir { ERROR_SEEK_ON_DEVICE, osl_File_E_ACCES }, /* 132 */
129cdf0e10cSrcweir { ERROR_DIR_NOT_EMPTY, osl_File_E_NOTEMPTY }, /* 145 */
130cdf0e10cSrcweir { ERROR_NOT_LOCKED, osl_File_E_ACCES }, /* 158 */
131cdf0e10cSrcweir { ERROR_BAD_PATHNAME, osl_File_E_NOENT }, /* 161 */
132cdf0e10cSrcweir { ERROR_MAX_THRDS_REACHED, osl_File_E_AGAIN }, /* 164 */
133cdf0e10cSrcweir { ERROR_LOCK_FAILED, osl_File_E_ACCES }, /* 167 */
134cdf0e10cSrcweir { ERROR_ALREADY_EXISTS, osl_File_E_EXIST }, /* 183 */
135cdf0e10cSrcweir { ERROR_FILENAME_EXCED_RANGE, osl_File_E_NOENT }, /* 206 */
136cdf0e10cSrcweir { ERROR_NESTING_NOT_ALLOWED, osl_File_E_AGAIN }, /* 215 */
137cdf0e10cSrcweir { ERROR_DIRECTORY, osl_File_E_NOENT }, /* 267 */
138cdf0e10cSrcweir //{ ERROR_NOT_ENOUGH_QUOTA, osl_File_E_NOMEM } /* 1816 */
139cdf0e10cSrcweir };
140cdf0e10cSrcweir
141cdf0e10cSrcweir #define ELEMENTS_OF_ARRAY(arr) (sizeof(arr)/(sizeof((arr)[0])))
142cdf0e10cSrcweir
143cdf0e10cSrcweir //#####################################################
MapError(APIRET dwError)144cdf0e10cSrcweir oslFileError MapError(APIRET dwError)
145cdf0e10cSrcweir {
146cdf0e10cSrcweir for (int i = 0; i < ELEMENTS_OF_ARRAY(errtable); ++i )
147cdf0e10cSrcweir {
148cdf0e10cSrcweir if (dwError == errtable[i].oscode)
149cdf0e10cSrcweir return static_cast<oslFileError>(errtable[i].errnocode);
150cdf0e10cSrcweir }
151cdf0e10cSrcweir return osl_File_E_INVAL;
152cdf0e10cSrcweir }
153cdf0e10cSrcweir
154dcc6e752SPedro Giffuni #ifdef DEBUG_OSL_FILE
155dcc6e752SPedro Giffuni # define OSL_FILE_TRACE 0 ? (void)(0) : osl_trace
156dcc6e752SPedro Giffuni # define PERROR( a, b ) perror( a ); fprintf( stderr, b )
157dcc6e752SPedro Giffuni #else
158dcc6e752SPedro Giffuni # define OSL_FILE_TRACE 1 ? (void)(0) : osl_trace
159dcc6e752SPedro Giffuni # define PERROR( a, b )
160dcc6e752SPedro Giffuni #endif
161dcc6e752SPedro Giffuni
162dcc6e752SPedro Giffuni //##################################################################
163dcc6e752SPedro Giffuni // File handle implementation
164dcc6e752SPedro Giffuni //##################################################################
165dcc6e752SPedro Giffuni struct FileHandle_Impl
166dcc6e752SPedro Giffuni {
167dcc6e752SPedro Giffuni rtl_String * m_strFilePath; /* holds native file path */
168dcc6e752SPedro Giffuni int m_fd;
169dcc6e752SPedro Giffuni
170dcc6e752SPedro Giffuni /** State
171dcc6e752SPedro Giffuni */
172dcc6e752SPedro Giffuni enum StateBits
173dcc6e752SPedro Giffuni {
174dcc6e752SPedro Giffuni STATE_SEEKABLE = 1, /* default */
175dcc6e752SPedro Giffuni STATE_READABLE = 2, /* default */
176dcc6e752SPedro Giffuni STATE_WRITEABLE = 4, /* open() sets, write() requires, else osl_File_E_BADF */
177dcc6e752SPedro Giffuni STATE_MODIFIED = 8 /* write() sets, flush() resets */
178dcc6e752SPedro Giffuni };
179dcc6e752SPedro Giffuni int m_state;
180dcc6e752SPedro Giffuni
181dcc6e752SPedro Giffuni sal_uInt64 m_size; /* file size */
182dcc6e752SPedro Giffuni off_t m_offset; /* physical offset from begin of file */
183dcc6e752SPedro Giffuni //off_t m_filepos; /* logical offset from begin of file */
184dcc6e752SPedro Giffuni off_t m_fileptr; /* logical offset from begin of file */
185dcc6e752SPedro Giffuni
186dcc6e752SPedro Giffuni off_t m_bufptr; /* buffer offset from begin of file */
187dcc6e752SPedro Giffuni size_t m_buflen; /* buffer filled [0, m_bufsiz - 1] */
188dcc6e752SPedro Giffuni
189dcc6e752SPedro Giffuni size_t m_bufsiz;
190dcc6e752SPedro Giffuni sal_uInt8 * m_buffer;
191dcc6e752SPedro Giffuni
192dcc6e752SPedro Giffuni explicit FileHandle_Impl (int fd, char const * path = "<anon>");
193dcc6e752SPedro Giffuni ~FileHandle_Impl();
194dcc6e752SPedro Giffuni
195dcc6e752SPedro Giffuni static void* operator new(size_t n);
196dcc6e752SPedro Giffuni static void operator delete(void * p, size_t);
197dcc6e752SPedro Giffuni static size_t getpagesize();
198dcc6e752SPedro Giffuni
199dcc6e752SPedro Giffuni sal_uInt64 getPos() const;
200dcc6e752SPedro Giffuni oslFileError setPos (sal_uInt64 uPos);
201dcc6e752SPedro Giffuni
202dcc6e752SPedro Giffuni sal_uInt64 getSize() const;
203dcc6e752SPedro Giffuni oslFileError setSize (sal_uInt64 uPos);
204dcc6e752SPedro Giffuni
205dcc6e752SPedro Giffuni oslFileError readAt (
206dcc6e752SPedro Giffuni off_t nOffset,
207dcc6e752SPedro Giffuni void * pBuffer,
208dcc6e752SPedro Giffuni size_t nBytesRequested,
209dcc6e752SPedro Giffuni sal_uInt64 * pBytesRead);
210dcc6e752SPedro Giffuni
211dcc6e752SPedro Giffuni oslFileError writeAt (
212dcc6e752SPedro Giffuni off_t nOffset,
213dcc6e752SPedro Giffuni void const * pBuffer,
214dcc6e752SPedro Giffuni size_t nBytesToWrite,
215dcc6e752SPedro Giffuni sal_uInt64 * pBytesWritten);
216dcc6e752SPedro Giffuni
217dcc6e752SPedro Giffuni oslFileError readFileAt (
218dcc6e752SPedro Giffuni off_t nOffset,
219dcc6e752SPedro Giffuni void * pBuffer,
220dcc6e752SPedro Giffuni size_t nBytesRequested,
221dcc6e752SPedro Giffuni sal_uInt64 * pBytesRead);
222dcc6e752SPedro Giffuni
223dcc6e752SPedro Giffuni oslFileError writeFileAt (
224dcc6e752SPedro Giffuni off_t nOffset,
225dcc6e752SPedro Giffuni void const * pBuffer,
226dcc6e752SPedro Giffuni size_t nBytesToWrite,
227dcc6e752SPedro Giffuni sal_uInt64 * pBytesWritten);
228dcc6e752SPedro Giffuni
229dcc6e752SPedro Giffuni oslFileError readLineAt (
230dcc6e752SPedro Giffuni LONGLONG nOffset,
231dcc6e752SPedro Giffuni sal_Sequence ** ppSequence,
232dcc6e752SPedro Giffuni sal_uInt64 * pBytesRead);
233dcc6e752SPedro Giffuni
234dcc6e752SPedro Giffuni oslFileError writeSequence_Impl (
235dcc6e752SPedro Giffuni sal_Sequence ** ppSequence,
236dcc6e752SPedro Giffuni size_t * pnOffset,
237dcc6e752SPedro Giffuni const void * pBuffer,
238dcc6e752SPedro Giffuni size_t nBytes);
239dcc6e752SPedro Giffuni
240dcc6e752SPedro Giffuni oslFileError syncFile();
241dcc6e752SPedro Giffuni
242dcc6e752SPedro Giffuni /** Buffer cache / allocator.
243dcc6e752SPedro Giffuni */
244dcc6e752SPedro Giffuni class Allocator
245dcc6e752SPedro Giffuni {
246dcc6e752SPedro Giffuni rtl_cache_type * m_cache;
247dcc6e752SPedro Giffuni size_t m_bufsiz;
248dcc6e752SPedro Giffuni
249dcc6e752SPedro Giffuni Allocator (Allocator const &);
250dcc6e752SPedro Giffuni Allocator & operator= (Allocator const &);
251dcc6e752SPedro Giffuni
252dcc6e752SPedro Giffuni public:
253dcc6e752SPedro Giffuni static Allocator & get();
254dcc6e752SPedro Giffuni
255dcc6e752SPedro Giffuni void allocate (sal_uInt8 ** ppBuffer, size_t * pnSize);
256dcc6e752SPedro Giffuni void deallocate (sal_uInt8 * pBuffer);
257dcc6e752SPedro Giffuni
258dcc6e752SPedro Giffuni protected:
259dcc6e752SPedro Giffuni Allocator();
260dcc6e752SPedro Giffuni ~Allocator();
261dcc6e752SPedro Giffuni };
262dcc6e752SPedro Giffuni };
263dcc6e752SPedro Giffuni
264dcc6e752SPedro Giffuni FileHandle_Impl::Allocator &
get()265dcc6e752SPedro Giffuni FileHandle_Impl::Allocator::get()
266dcc6e752SPedro Giffuni {
267dcc6e752SPedro Giffuni static Allocator g_aBufferAllocator;
268dcc6e752SPedro Giffuni return g_aBufferAllocator;
269dcc6e752SPedro Giffuni }
270dcc6e752SPedro Giffuni
Allocator()271dcc6e752SPedro Giffuni FileHandle_Impl::Allocator::Allocator()
272dcc6e752SPedro Giffuni : m_cache (0),
273dcc6e752SPedro Giffuni m_bufsiz (0)
274dcc6e752SPedro Giffuni {
275dcc6e752SPedro Giffuni size_t const pagesize = FileHandle_Impl::getpagesize();
276dcc6e752SPedro Giffuni m_cache = rtl_cache_create (
277dcc6e752SPedro Giffuni "osl_file_buffer_cache", pagesize, 0, 0, 0, 0, 0, 0, 0);
278dcc6e752SPedro Giffuni if (0 != m_cache)
279dcc6e752SPedro Giffuni m_bufsiz = pagesize;
280dcc6e752SPedro Giffuni }
281dcc6e752SPedro Giffuni
~Allocator()282dcc6e752SPedro Giffuni FileHandle_Impl::Allocator::~Allocator()
283dcc6e752SPedro Giffuni {
284dcc6e752SPedro Giffuni rtl_cache_destroy(m_cache), m_cache = 0;
285dcc6e752SPedro Giffuni }
286dcc6e752SPedro Giffuni
allocate(sal_uInt8 ** ppBuffer,size_t * pnSize)287dcc6e752SPedro Giffuni void FileHandle_Impl::Allocator::allocate (sal_uInt8 ** ppBuffer, size_t * pnSize)
288dcc6e752SPedro Giffuni {
289dcc6e752SPedro Giffuni OSL_PRECOND((0 != ppBuffer) && (0 != pnSize), "FileHandle_Impl::Allocator::allocate(): contract violation");
290dcc6e752SPedro Giffuni *ppBuffer = static_cast< sal_uInt8* >(rtl_cache_alloc(m_cache)), *pnSize = m_bufsiz;
291dcc6e752SPedro Giffuni }
292dcc6e752SPedro Giffuni
deallocate(sal_uInt8 * pBuffer)293dcc6e752SPedro Giffuni void FileHandle_Impl::Allocator::deallocate (sal_uInt8 * pBuffer)
294dcc6e752SPedro Giffuni {
295dcc6e752SPedro Giffuni if (0 != pBuffer)
296dcc6e752SPedro Giffuni rtl_cache_free (m_cache, pBuffer);
297dcc6e752SPedro Giffuni }
298dcc6e752SPedro Giffuni
FileHandle_Impl(int fd,char const * path)299dcc6e752SPedro Giffuni FileHandle_Impl::FileHandle_Impl (int fd, char const * path)
300dcc6e752SPedro Giffuni : m_strFilePath (0),
301dcc6e752SPedro Giffuni m_fd (fd),
302dcc6e752SPedro Giffuni m_state (STATE_SEEKABLE | STATE_READABLE),
303dcc6e752SPedro Giffuni m_size (0),
304dcc6e752SPedro Giffuni m_offset (0),
305dcc6e752SPedro Giffuni m_fileptr (0),
306dcc6e752SPedro Giffuni m_bufptr (-1),
307dcc6e752SPedro Giffuni m_buflen (0),
308dcc6e752SPedro Giffuni m_bufsiz (0),
309dcc6e752SPedro Giffuni m_buffer (0)
310dcc6e752SPedro Giffuni {
311dcc6e752SPedro Giffuni rtl_string_newFromStr (&m_strFilePath, path);
312dcc6e752SPedro Giffuni Allocator::get().allocate (&m_buffer, &m_bufsiz);
313dcc6e752SPedro Giffuni if (m_buffer != 0)
314dcc6e752SPedro Giffuni memset (m_buffer, 0, m_bufsiz);
315dcc6e752SPedro Giffuni }
316dcc6e752SPedro Giffuni
~FileHandle_Impl()317dcc6e752SPedro Giffuni FileHandle_Impl::~FileHandle_Impl()
318dcc6e752SPedro Giffuni {
319dcc6e752SPedro Giffuni Allocator::get().deallocate (m_buffer), m_buffer = 0;
320dcc6e752SPedro Giffuni rtl_string_release (m_strFilePath), m_strFilePath = 0;
321dcc6e752SPedro Giffuni }
322dcc6e752SPedro Giffuni
operator new(size_t n)323dcc6e752SPedro Giffuni void * FileHandle_Impl::operator new(size_t n)
324dcc6e752SPedro Giffuni {
325dcc6e752SPedro Giffuni return rtl_allocateMemory(n);
326dcc6e752SPedro Giffuni }
327dcc6e752SPedro Giffuni
operator delete(void * p,size_t)328dcc6e752SPedro Giffuni void FileHandle_Impl::operator delete(void * p, size_t)
329dcc6e752SPedro Giffuni {
330dcc6e752SPedro Giffuni rtl_freeMemory(p);
331dcc6e752SPedro Giffuni }
332dcc6e752SPedro Giffuni
getpagesize()333dcc6e752SPedro Giffuni size_t FileHandle_Impl::getpagesize()
334dcc6e752SPedro Giffuni {
335dcc6e752SPedro Giffuni ULONG ulPageSize;
336dcc6e752SPedro Giffuni DosQuerySysInfo(QSV_PAGE_SIZE, QSV_PAGE_SIZE, &ulPageSize, sizeof(ULONG));
337dcc6e752SPedro Giffuni return sal::static_int_cast< size_t >(ulPageSize);
338dcc6e752SPedro Giffuni }
339dcc6e752SPedro Giffuni
getPos() const340dcc6e752SPedro Giffuni sal_uInt64 FileHandle_Impl::getPos() const
341dcc6e752SPedro Giffuni {
342dcc6e752SPedro Giffuni return sal::static_int_cast< sal_uInt64 >(m_fileptr);
343dcc6e752SPedro Giffuni }
344dcc6e752SPedro Giffuni
setPos(sal_uInt64 uPos)345dcc6e752SPedro Giffuni oslFileError FileHandle_Impl::setPos (sal_uInt64 uPos)
346dcc6e752SPedro Giffuni {
347dcc6e752SPedro Giffuni m_fileptr = sal::static_int_cast< LONGLONG >(uPos);
348dcc6e752SPedro Giffuni return osl_File_E_None;
349dcc6e752SPedro Giffuni }
350dcc6e752SPedro Giffuni
getSize() const351dcc6e752SPedro Giffuni sal_uInt64 FileHandle_Impl::getSize() const
352dcc6e752SPedro Giffuni {
353dcc6e752SPedro Giffuni LONGLONG bufend = std::max((LONGLONG)(0), m_bufptr) + m_buflen;
354dcc6e752SPedro Giffuni return std::max(m_size, sal::static_int_cast< sal_uInt64 >(bufend));
355dcc6e752SPedro Giffuni }
356dcc6e752SPedro Giffuni
setSize(sal_uInt64 uSize)357dcc6e752SPedro Giffuni oslFileError FileHandle_Impl::setSize (sal_uInt64 uSize)
358dcc6e752SPedro Giffuni {
359dcc6e752SPedro Giffuni off_t const nSize = sal::static_int_cast< off_t >(uSize);
360dcc6e752SPedro Giffuni if (-1 == ftruncate (m_fd, nSize))
361dcc6e752SPedro Giffuni {
362dcc6e752SPedro Giffuni /* Failure. Save original result. Try fallback algorithm */
363dcc6e752SPedro Giffuni oslFileError result = oslTranslateFileError (OSL_FET_ERROR, errno);
364dcc6e752SPedro Giffuni
365dcc6e752SPedro Giffuni /* Check against current size. Fail upon 'shrink' */
366dcc6e752SPedro Giffuni if (uSize <= getSize())
367dcc6e752SPedro Giffuni {
368dcc6e752SPedro Giffuni /* Failure upon 'shrink'. Return original result */
369dcc6e752SPedro Giffuni return (result);
370dcc6e752SPedro Giffuni }
371dcc6e752SPedro Giffuni
372dcc6e752SPedro Giffuni /* Save current position */
373dcc6e752SPedro Giffuni off_t const nCurPos = (off_t)lseek (m_fd, (off_t)0, SEEK_CUR);
374dcc6e752SPedro Giffuni if (nCurPos == (off_t)(-1))
375dcc6e752SPedro Giffuni return (result);
376dcc6e752SPedro Giffuni
377dcc6e752SPedro Giffuni /* Try 'expand' via 'lseek()' and 'write()' */
378dcc6e752SPedro Giffuni if (-1 == lseek (m_fd, (off_t)(nSize - 1), SEEK_SET))
379dcc6e752SPedro Giffuni return (result);
380dcc6e752SPedro Giffuni
381dcc6e752SPedro Giffuni if (-1 == write (m_fd, (char*)"", (size_t)1))
382dcc6e752SPedro Giffuni {
383dcc6e752SPedro Giffuni /* Failure. Restore saved position */
384dcc6e752SPedro Giffuni (void) lseek (m_fd, (off_t)(nCurPos), SEEK_SET);
385dcc6e752SPedro Giffuni return (result);
386dcc6e752SPedro Giffuni }
387dcc6e752SPedro Giffuni
388dcc6e752SPedro Giffuni /* Success. Restore saved position */
389dcc6e752SPedro Giffuni if (-1 == lseek (m_fd, (off_t)nCurPos, SEEK_SET))
390dcc6e752SPedro Giffuni return (result);
391dcc6e752SPedro Giffuni }
392dcc6e752SPedro Giffuni
393dcc6e752SPedro Giffuni OSL_FILE_TRACE("osl_setFileSize(%d, %lld) => %ld", m_fd, getSize(), nSize);
394dcc6e752SPedro Giffuni m_size = sal::static_int_cast< sal_uInt64 >(nSize);
395dcc6e752SPedro Giffuni return osl_File_E_None;
396dcc6e752SPedro Giffuni }
397dcc6e752SPedro Giffuni
readAt(off_t nOffset,void * pBuffer,size_t nBytesRequested,sal_uInt64 * pBytesRead)398dcc6e752SPedro Giffuni oslFileError FileHandle_Impl::readAt (
399dcc6e752SPedro Giffuni off_t nOffset,
400dcc6e752SPedro Giffuni void * pBuffer,
401dcc6e752SPedro Giffuni size_t nBytesRequested,
402dcc6e752SPedro Giffuni sal_uInt64 * pBytesRead)
403dcc6e752SPedro Giffuni {
404dcc6e752SPedro Giffuni OSL_PRECOND((m_state & STATE_SEEKABLE), "FileHandle_Impl::readAt(): not seekable");
405dcc6e752SPedro Giffuni if (!(m_state & STATE_SEEKABLE))
406dcc6e752SPedro Giffuni return osl_File_E_SPIPE;
407dcc6e752SPedro Giffuni
408dcc6e752SPedro Giffuni OSL_PRECOND((m_state & STATE_READABLE), "FileHandle_Impl::readAt(): not readable");
409dcc6e752SPedro Giffuni if (!(m_state & STATE_READABLE))
410dcc6e752SPedro Giffuni return osl_File_E_BADF;
411dcc6e752SPedro Giffuni
412dcc6e752SPedro Giffuni if (nOffset != m_offset)
413dcc6e752SPedro Giffuni {
414dcc6e752SPedro Giffuni if (-1 == ::lseek (m_fd, nOffset, SEEK_SET))
415dcc6e752SPedro Giffuni return oslTranslateFileError (OSL_FET_ERROR, errno);
416dcc6e752SPedro Giffuni m_offset = nOffset;
417dcc6e752SPedro Giffuni }
418dcc6e752SPedro Giffuni
419dcc6e752SPedro Giffuni ssize_t nBytes = ::read (m_fd, pBuffer, nBytesRequested);
420dcc6e752SPedro Giffuni if (-1 == nBytes)
421dcc6e752SPedro Giffuni return oslTranslateFileError (OSL_FET_ERROR, errno);
422dcc6e752SPedro Giffuni m_offset += nBytes;
423dcc6e752SPedro Giffuni
424dcc6e752SPedro Giffuni OSL_FILE_TRACE("FileHandle_Impl::readAt(%d, %lld, %ld)", m_fd, nOffset, nBytes);
425dcc6e752SPedro Giffuni *pBytesRead = nBytes;
426dcc6e752SPedro Giffuni return osl_File_E_None;
427dcc6e752SPedro Giffuni }
428dcc6e752SPedro Giffuni
writeAt(off_t nOffset,void const * pBuffer,size_t nBytesToWrite,sal_uInt64 * pBytesWritten)429dcc6e752SPedro Giffuni oslFileError FileHandle_Impl::writeAt (
430dcc6e752SPedro Giffuni off_t nOffset,
431dcc6e752SPedro Giffuni void const * pBuffer,
432dcc6e752SPedro Giffuni size_t nBytesToWrite,
433dcc6e752SPedro Giffuni sal_uInt64 * pBytesWritten)
434dcc6e752SPedro Giffuni {
435dcc6e752SPedro Giffuni OSL_PRECOND((m_state & STATE_SEEKABLE), "FileHandle_Impl::writeAt(): not seekable");
436dcc6e752SPedro Giffuni if (!(m_state & STATE_SEEKABLE))
437dcc6e752SPedro Giffuni return osl_File_E_SPIPE;
438dcc6e752SPedro Giffuni
439dcc6e752SPedro Giffuni OSL_PRECOND((m_state & STATE_WRITEABLE), "FileHandle_Impl::writeAt(): not writeable");
440dcc6e752SPedro Giffuni if (!(m_state & STATE_WRITEABLE))
441dcc6e752SPedro Giffuni return osl_File_E_BADF;
442dcc6e752SPedro Giffuni
443dcc6e752SPedro Giffuni if (nOffset != m_offset)
444dcc6e752SPedro Giffuni {
445dcc6e752SPedro Giffuni if (-1 == ::lseek (m_fd, nOffset, SEEK_SET))
446dcc6e752SPedro Giffuni return oslTranslateFileError (OSL_FET_ERROR, errno);
447dcc6e752SPedro Giffuni m_offset = nOffset;
448dcc6e752SPedro Giffuni }
449dcc6e752SPedro Giffuni
450dcc6e752SPedro Giffuni ssize_t nBytes = ::write (m_fd, pBuffer, nBytesToWrite);
451dcc6e752SPedro Giffuni if (-1 == nBytes)
452dcc6e752SPedro Giffuni return oslTranslateFileError (OSL_FET_ERROR, errno);
453dcc6e752SPedro Giffuni m_offset += nBytes;
454dcc6e752SPedro Giffuni
455dcc6e752SPedro Giffuni OSL_FILE_TRACE("FileHandle_Impl::writeAt(%d, %lld, %ld)", m_fd, nOffset, nBytes);
456dcc6e752SPedro Giffuni m_size = std::max (m_size, sal::static_int_cast< sal_uInt64 >(nOffset + nBytes));
457dcc6e752SPedro Giffuni
458dcc6e752SPedro Giffuni *pBytesWritten = nBytes;
459dcc6e752SPedro Giffuni return osl_File_E_None;
460dcc6e752SPedro Giffuni }
461dcc6e752SPedro Giffuni
readFileAt(off_t nOffset,void * pBuffer,size_t nBytesRequested,sal_uInt64 * pBytesRead)462dcc6e752SPedro Giffuni oslFileError FileHandle_Impl::readFileAt (
463dcc6e752SPedro Giffuni off_t nOffset,
464dcc6e752SPedro Giffuni void * pBuffer,
465dcc6e752SPedro Giffuni size_t nBytesRequested,
466dcc6e752SPedro Giffuni sal_uInt64 * pBytesRead)
467dcc6e752SPedro Giffuni {
468dcc6e752SPedro Giffuni if (0 == (m_state & STATE_SEEKABLE))
469dcc6e752SPedro Giffuni {
470dcc6e752SPedro Giffuni // not seekable (pipe)
471dcc6e752SPedro Giffuni ssize_t nBytes = ::read (m_fd, pBuffer, nBytesRequested);
472dcc6e752SPedro Giffuni if (-1 == nBytes)
473dcc6e752SPedro Giffuni return oslTranslateFileError (OSL_FET_ERROR, errno);
474dcc6e752SPedro Giffuni *pBytesRead = nBytes;
475dcc6e752SPedro Giffuni return osl_File_E_None;
476dcc6e752SPedro Giffuni }
477dcc6e752SPedro Giffuni else if (0 == m_buffer)
478dcc6e752SPedro Giffuni {
479dcc6e752SPedro Giffuni // not buffered
480dcc6e752SPedro Giffuni return readAt (nOffset, pBuffer, nBytesRequested, pBytesRead);
481dcc6e752SPedro Giffuni }
482dcc6e752SPedro Giffuni else
483dcc6e752SPedro Giffuni {
484dcc6e752SPedro Giffuni sal_uInt8 * buffer = static_cast<sal_uInt8*>(pBuffer);
485dcc6e752SPedro Giffuni for (*pBytesRead = 0; nBytesRequested > 0; )
486dcc6e752SPedro Giffuni {
487dcc6e752SPedro Giffuni off_t const bufptr = (nOffset / m_bufsiz) * m_bufsiz;
488dcc6e752SPedro Giffuni size_t const bufpos = (nOffset % m_bufsiz);
489dcc6e752SPedro Giffuni
490dcc6e752SPedro Giffuni if (bufptr != m_bufptr)
491dcc6e752SPedro Giffuni {
492dcc6e752SPedro Giffuni // flush current buffer
493dcc6e752SPedro Giffuni oslFileError result = syncFile();
494dcc6e752SPedro Giffuni if (result != osl_File_E_None)
495dcc6e752SPedro Giffuni return (result);
496dcc6e752SPedro Giffuni
497dcc6e752SPedro Giffuni if (nBytesRequested >= m_bufsiz)
498dcc6e752SPedro Giffuni {
499dcc6e752SPedro Giffuni // buffer too small, read through from file
500dcc6e752SPedro Giffuni sal_uInt64 uDone = 0;
501dcc6e752SPedro Giffuni result = readAt (nOffset, &(buffer[*pBytesRead]), nBytesRequested, &uDone);
502dcc6e752SPedro Giffuni if (result != osl_File_E_None)
503dcc6e752SPedro Giffuni return (result);
504dcc6e752SPedro Giffuni
505dcc6e752SPedro Giffuni nBytesRequested -= uDone, *pBytesRead += uDone;
506dcc6e752SPedro Giffuni return osl_File_E_None;
507dcc6e752SPedro Giffuni }
508dcc6e752SPedro Giffuni
509dcc6e752SPedro Giffuni // update buffer (pointer)
510dcc6e752SPedro Giffuni sal_uInt64 uDone = 0;
511dcc6e752SPedro Giffuni result = readAt (bufptr, m_buffer, m_bufsiz, &uDone);
512dcc6e752SPedro Giffuni if (result != osl_File_E_None)
513dcc6e752SPedro Giffuni return (result);
514dcc6e752SPedro Giffuni m_bufptr = bufptr, m_buflen = uDone;
515dcc6e752SPedro Giffuni }
516dcc6e752SPedro Giffuni if (bufpos >= m_buflen)
517dcc6e752SPedro Giffuni {
518dcc6e752SPedro Giffuni // end of file
519dcc6e752SPedro Giffuni return osl_File_E_None;
520dcc6e752SPedro Giffuni }
521dcc6e752SPedro Giffuni
522dcc6e752SPedro Giffuni size_t const bytes = std::min (m_buflen - bufpos, nBytesRequested);
523dcc6e752SPedro Giffuni OSL_FILE_TRACE("FileHandle_Impl::readFileAt(%d, %lld, %ld)", m_fd, nOffset, bytes);
524dcc6e752SPedro Giffuni
525dcc6e752SPedro Giffuni memcpy (&(buffer[*pBytesRead]), &(m_buffer[bufpos]), bytes);
526dcc6e752SPedro Giffuni nBytesRequested -= bytes, *pBytesRead += bytes, nOffset += bytes;
527dcc6e752SPedro Giffuni }
528dcc6e752SPedro Giffuni return osl_File_E_None;
529dcc6e752SPedro Giffuni }
530dcc6e752SPedro Giffuni }
531dcc6e752SPedro Giffuni
writeFileAt(off_t nOffset,void const * pBuffer,size_t nBytesToWrite,sal_uInt64 * pBytesWritten)532dcc6e752SPedro Giffuni oslFileError FileHandle_Impl::writeFileAt (
533dcc6e752SPedro Giffuni off_t nOffset,
534dcc6e752SPedro Giffuni void const * pBuffer,
535dcc6e752SPedro Giffuni size_t nBytesToWrite,
536dcc6e752SPedro Giffuni sal_uInt64 * pBytesWritten)
537dcc6e752SPedro Giffuni {
538dcc6e752SPedro Giffuni if (0 == (m_state & STATE_SEEKABLE))
539dcc6e752SPedro Giffuni {
540dcc6e752SPedro Giffuni // not seekable (pipe)
541dcc6e752SPedro Giffuni ssize_t nBytes = ::write (m_fd, pBuffer, nBytesToWrite);
542dcc6e752SPedro Giffuni if (-1 == nBytes)
543dcc6e752SPedro Giffuni return oslTranslateFileError (OSL_FET_ERROR, errno);
544dcc6e752SPedro Giffuni *pBytesWritten = nBytes;
545dcc6e752SPedro Giffuni return osl_File_E_None;
546dcc6e752SPedro Giffuni }
547dcc6e752SPedro Giffuni else if (0 == m_buffer)
548dcc6e752SPedro Giffuni {
549dcc6e752SPedro Giffuni // not buffered
550dcc6e752SPedro Giffuni return writeAt (nOffset, pBuffer, nBytesToWrite, pBytesWritten);
551dcc6e752SPedro Giffuni }
552dcc6e752SPedro Giffuni else
553dcc6e752SPedro Giffuni {
554dcc6e752SPedro Giffuni sal_uInt8 const * buffer = static_cast<sal_uInt8 const *>(pBuffer);
555dcc6e752SPedro Giffuni for (*pBytesWritten = 0; nBytesToWrite > 0; )
556dcc6e752SPedro Giffuni {
557dcc6e752SPedro Giffuni off_t const bufptr = (nOffset / m_bufsiz) * m_bufsiz;
558dcc6e752SPedro Giffuni size_t const bufpos = (nOffset % m_bufsiz);
559dcc6e752SPedro Giffuni if (bufptr != m_bufptr)
560dcc6e752SPedro Giffuni {
561dcc6e752SPedro Giffuni // flush current buffer
562dcc6e752SPedro Giffuni oslFileError result = syncFile();
563dcc6e752SPedro Giffuni if (result != osl_File_E_None)
564dcc6e752SPedro Giffuni return (result);
565dcc6e752SPedro Giffuni
566dcc6e752SPedro Giffuni if (nBytesToWrite >= m_bufsiz)
567dcc6e752SPedro Giffuni {
568dcc6e752SPedro Giffuni // buffer to small, write through to file
569dcc6e752SPedro Giffuni sal_uInt64 uDone = 0;
570dcc6e752SPedro Giffuni result = writeAt (nOffset, &(buffer[*pBytesWritten]), nBytesToWrite, &uDone);
571dcc6e752SPedro Giffuni if (result != osl_File_E_None)
572dcc6e752SPedro Giffuni return (result);
573dcc6e752SPedro Giffuni if (uDone != nBytesToWrite)
574dcc6e752SPedro Giffuni return osl_File_E_IO;
575dcc6e752SPedro Giffuni
576dcc6e752SPedro Giffuni nBytesToWrite -= uDone, *pBytesWritten += uDone;
577dcc6e752SPedro Giffuni return osl_File_E_None;
578dcc6e752SPedro Giffuni }
579dcc6e752SPedro Giffuni
580dcc6e752SPedro Giffuni // update buffer (pointer)
581dcc6e752SPedro Giffuni sal_uInt64 uDone = 0;
582dcc6e752SPedro Giffuni result = readAt (bufptr, m_buffer, m_bufsiz, &uDone);
583dcc6e752SPedro Giffuni if (result != osl_File_E_None)
584dcc6e752SPedro Giffuni return (result);
585dcc6e752SPedro Giffuni m_bufptr = bufptr, m_buflen = uDone;
586dcc6e752SPedro Giffuni }
587dcc6e752SPedro Giffuni
588dcc6e752SPedro Giffuni size_t const bytes = std::min (m_bufsiz - bufpos, nBytesToWrite);
589dcc6e752SPedro Giffuni OSL_FILE_TRACE("FileHandle_Impl::writeFileAt(%d, %lld, %ld)", m_fd, nOffset, bytes);
590dcc6e752SPedro Giffuni
591dcc6e752SPedro Giffuni memcpy (&(m_buffer[bufpos]), &(buffer[*pBytesWritten]), bytes);
592dcc6e752SPedro Giffuni nBytesToWrite -= bytes, *pBytesWritten += bytes, nOffset += bytes;
593dcc6e752SPedro Giffuni
594dcc6e752SPedro Giffuni m_buflen = std::max(m_buflen, bufpos + bytes);
595dcc6e752SPedro Giffuni m_state |= STATE_MODIFIED;
596dcc6e752SPedro Giffuni }
597dcc6e752SPedro Giffuni return osl_File_E_None;
598dcc6e752SPedro Giffuni }
599dcc6e752SPedro Giffuni }
600dcc6e752SPedro Giffuni
readLineAt(LONGLONG nOffset,sal_Sequence ** ppSequence,sal_uInt64 * pBytesRead)601dcc6e752SPedro Giffuni oslFileError FileHandle_Impl::readLineAt (
602dcc6e752SPedro Giffuni LONGLONG nOffset,
603dcc6e752SPedro Giffuni sal_Sequence ** ppSequence,
604dcc6e752SPedro Giffuni sal_uInt64 * pBytesRead)
605dcc6e752SPedro Giffuni {
606dcc6e752SPedro Giffuni oslFileError result = osl_File_E_None;
607dcc6e752SPedro Giffuni
608dcc6e752SPedro Giffuni LONGLONG bufptr = (nOffset / m_bufsiz) * m_bufsiz;
609dcc6e752SPedro Giffuni if (bufptr != m_bufptr)
610dcc6e752SPedro Giffuni {
611dcc6e752SPedro Giffuni /* flush current buffer */
612dcc6e752SPedro Giffuni result = syncFile();
613dcc6e752SPedro Giffuni if (result != osl_File_E_None)
614dcc6e752SPedro Giffuni return (result);
615dcc6e752SPedro Giffuni
616dcc6e752SPedro Giffuni /* update buffer (pointer) */
617dcc6e752SPedro Giffuni sal_uInt64 uDone = 0;
618dcc6e752SPedro Giffuni result = readAt (bufptr, m_buffer, m_bufsiz, &uDone);
619dcc6e752SPedro Giffuni if (result != osl_File_E_None)
620dcc6e752SPedro Giffuni return (result);
621dcc6e752SPedro Giffuni
622dcc6e752SPedro Giffuni m_bufptr = bufptr, m_buflen = sal::static_int_cast< size_t >(uDone);
623dcc6e752SPedro Giffuni }
624dcc6e752SPedro Giffuni
625dcc6e752SPedro Giffuni static int const LINE_STATE_BEGIN = 0;
626dcc6e752SPedro Giffuni static int const LINE_STATE_CR = 1;
627dcc6e752SPedro Giffuni static int const LINE_STATE_LF = 2;
628dcc6e752SPedro Giffuni
629dcc6e752SPedro Giffuni size_t bufpos = sal::static_int_cast< size_t >(nOffset - m_bufptr), curpos = bufpos, dstpos = 0;
630dcc6e752SPedro Giffuni int state = (bufpos >= m_buflen) ? LINE_STATE_LF : LINE_STATE_BEGIN;
631dcc6e752SPedro Giffuni
632dcc6e752SPedro Giffuni for ( ; state != LINE_STATE_LF; )
633dcc6e752SPedro Giffuni {
634dcc6e752SPedro Giffuni if (curpos >= m_buflen)
635dcc6e752SPedro Giffuni {
636dcc6e752SPedro Giffuni /* buffer examined */
637dcc6e752SPedro Giffuni if (0 < (curpos - bufpos))
638dcc6e752SPedro Giffuni {
639dcc6e752SPedro Giffuni /* flush buffer to sequence */
640dcc6e752SPedro Giffuni result = writeSequence_Impl (
641dcc6e752SPedro Giffuni ppSequence, &dstpos, &(m_buffer[bufpos]), curpos - bufpos);
642dcc6e752SPedro Giffuni if (result != osl_File_E_None)
643dcc6e752SPedro Giffuni return (result);
644dcc6e752SPedro Giffuni *pBytesRead += curpos - bufpos, nOffset += curpos - bufpos;
645dcc6e752SPedro Giffuni }
646dcc6e752SPedro Giffuni
647dcc6e752SPedro Giffuni bufptr = nOffset / m_bufsiz * m_bufsiz;
648dcc6e752SPedro Giffuni if (bufptr != m_bufptr)
649dcc6e752SPedro Giffuni {
650dcc6e752SPedro Giffuni /* update buffer (pointer) */
651dcc6e752SPedro Giffuni sal_uInt64 uDone = 0;
652dcc6e752SPedro Giffuni result = readAt (bufptr, m_buffer, m_bufsiz, &uDone);
653dcc6e752SPedro Giffuni if (result != osl_File_E_None)
654dcc6e752SPedro Giffuni return (result);
655dcc6e752SPedro Giffuni m_bufptr = bufptr, m_buflen = sal::static_int_cast< size_t >(uDone);
656dcc6e752SPedro Giffuni }
657dcc6e752SPedro Giffuni
658dcc6e752SPedro Giffuni bufpos = sal::static_int_cast< size_t >(nOffset - m_bufptr), curpos = bufpos;
659dcc6e752SPedro Giffuni if (bufpos >= m_buflen)
660dcc6e752SPedro Giffuni break;
661dcc6e752SPedro Giffuni }
662dcc6e752SPedro Giffuni switch (state)
663dcc6e752SPedro Giffuni {
664dcc6e752SPedro Giffuni case LINE_STATE_CR:
665dcc6e752SPedro Giffuni state = LINE_STATE_LF;
666dcc6e752SPedro Giffuni switch (m_buffer[curpos])
667dcc6e752SPedro Giffuni {
668dcc6e752SPedro Giffuni case 0x0A: /* CRLF */
669dcc6e752SPedro Giffuni /* eat current char */
670dcc6e752SPedro Giffuni curpos++;
671dcc6e752SPedro Giffuni break;
672dcc6e752SPedro Giffuni default: /* single CR */
673dcc6e752SPedro Giffuni /* keep current char */
674dcc6e752SPedro Giffuni break;
675dcc6e752SPedro Giffuni }
676dcc6e752SPedro Giffuni break;
677dcc6e752SPedro Giffuni default:
678dcc6e752SPedro Giffuni /* determine next state */
679dcc6e752SPedro Giffuni switch (m_buffer[curpos])
680dcc6e752SPedro Giffuni {
681dcc6e752SPedro Giffuni case 0x0A: /* single LF */
682dcc6e752SPedro Giffuni state = LINE_STATE_LF;
683dcc6e752SPedro Giffuni break;
684dcc6e752SPedro Giffuni case 0x0D: /* CR */
685dcc6e752SPedro Giffuni state = LINE_STATE_CR;
686dcc6e752SPedro Giffuni break;
687dcc6e752SPedro Giffuni default: /* advance to next char */
688dcc6e752SPedro Giffuni curpos++;
689dcc6e752SPedro Giffuni break;
690dcc6e752SPedro Giffuni }
691dcc6e752SPedro Giffuni if (state != LINE_STATE_BEGIN)
692dcc6e752SPedro Giffuni {
693dcc6e752SPedro Giffuni /* store (and eat) the newline char */
694dcc6e752SPedro Giffuni m_buffer[curpos] = 0x0A, curpos++;
695dcc6e752SPedro Giffuni
696dcc6e752SPedro Giffuni /* flush buffer to sequence */
697dcc6e752SPedro Giffuni result = writeSequence_Impl (
698dcc6e752SPedro Giffuni ppSequence, &dstpos, &(m_buffer[bufpos]), curpos - bufpos - 1);
699dcc6e752SPedro Giffuni if (result != osl_File_E_None)
700dcc6e752SPedro Giffuni return (result);
701dcc6e752SPedro Giffuni *pBytesRead += curpos - bufpos, nOffset += curpos - bufpos;
702dcc6e752SPedro Giffuni }
703dcc6e752SPedro Giffuni break;
704dcc6e752SPedro Giffuni }
705dcc6e752SPedro Giffuni }
706dcc6e752SPedro Giffuni
707dcc6e752SPedro Giffuni result = writeSequence_Impl (ppSequence, &dstpos, 0, 0);
708dcc6e752SPedro Giffuni if (result != osl_File_E_None)
709dcc6e752SPedro Giffuni return (result);
710dcc6e752SPedro Giffuni if (0 < dstpos)
711dcc6e752SPedro Giffuni return osl_File_E_None;
712dcc6e752SPedro Giffuni if (bufpos >= m_buflen)
713dcc6e752SPedro Giffuni return osl_File_E_AGAIN;
714dcc6e752SPedro Giffuni return osl_File_E_None;
715dcc6e752SPedro Giffuni }
716dcc6e752SPedro Giffuni
writeSequence_Impl(sal_Sequence ** ppSequence,size_t * pnOffset,const void * pBuffer,size_t nBytes)717dcc6e752SPedro Giffuni oslFileError FileHandle_Impl::writeSequence_Impl (
718dcc6e752SPedro Giffuni sal_Sequence ** ppSequence,
719dcc6e752SPedro Giffuni size_t * pnOffset,
720dcc6e752SPedro Giffuni const void * pBuffer,
721dcc6e752SPedro Giffuni size_t nBytes)
722dcc6e752SPedro Giffuni {
723dcc6e752SPedro Giffuni sal_Int32 nElements = *pnOffset + nBytes;
724dcc6e752SPedro Giffuni if (!*ppSequence)
725dcc6e752SPedro Giffuni {
726dcc6e752SPedro Giffuni /* construct sequence */
727dcc6e752SPedro Giffuni rtl_byte_sequence_constructNoDefault(ppSequence, nElements);
728dcc6e752SPedro Giffuni }
729dcc6e752SPedro Giffuni else if (nElements != (*ppSequence)->nElements)
730dcc6e752SPedro Giffuni {
731dcc6e752SPedro Giffuni /* resize sequence */
732dcc6e752SPedro Giffuni rtl_byte_sequence_realloc(ppSequence, nElements);
733dcc6e752SPedro Giffuni }
734dcc6e752SPedro Giffuni if (*ppSequence != 0)
735dcc6e752SPedro Giffuni {
736dcc6e752SPedro Giffuni /* fill sequence */
737dcc6e752SPedro Giffuni memcpy(&((*ppSequence)->elements[*pnOffset]), pBuffer, nBytes), *pnOffset += nBytes;
738dcc6e752SPedro Giffuni }
739dcc6e752SPedro Giffuni return (*ppSequence != 0) ? osl_File_E_None : osl_File_E_NOMEM;
740dcc6e752SPedro Giffuni }
741dcc6e752SPedro Giffuni
syncFile()742dcc6e752SPedro Giffuni oslFileError FileHandle_Impl::syncFile()
743dcc6e752SPedro Giffuni {
744dcc6e752SPedro Giffuni oslFileError result = osl_File_E_None;
745dcc6e752SPedro Giffuni if (m_state & STATE_MODIFIED)
746dcc6e752SPedro Giffuni {
747dcc6e752SPedro Giffuni sal_uInt64 uDone = 0;
748dcc6e752SPedro Giffuni result = writeAt (m_bufptr, m_buffer, m_buflen, &uDone);
749dcc6e752SPedro Giffuni if (result != osl_File_E_None)
750dcc6e752SPedro Giffuni return (result);
751dcc6e752SPedro Giffuni if (uDone != m_buflen)
752dcc6e752SPedro Giffuni return osl_File_E_IO;
753dcc6e752SPedro Giffuni m_state &= ~STATE_MODIFIED;
754dcc6e752SPedro Giffuni }
755dcc6e752SPedro Giffuni return (result);
756dcc6e752SPedro Giffuni }
757dcc6e752SPedro Giffuni
758dcc6e752SPedro Giffuni
759cdf0e10cSrcweir /******************************************************************************
760cdf0e10cSrcweir *
761cdf0e10cSrcweir * static members
762cdf0e10cSrcweir *
763cdf0e10cSrcweir *****************************************************************************/
764cdf0e10cSrcweir
765cdf0e10cSrcweir static const char * pFileLockEnvVar = (char *) -1;
766cdf0e10cSrcweir
767cdf0e10cSrcweir
768cdf0e10cSrcweir /******************************************************************************
769cdf0e10cSrcweir *
770cdf0e10cSrcweir * C-String Function Declarations
771cdf0e10cSrcweir *
772cdf0e10cSrcweir *****************************************************************************/
773cdf0e10cSrcweir
774cdf0e10cSrcweir static oslFileError osl_psz_getVolumeInformation(const sal_Char* , oslVolumeInfo* pInfo, sal_uInt32 uFieldMask);
775cdf0e10cSrcweir static oslFileError osl_psz_removeFile(const sal_Char* pszPath);
776cdf0e10cSrcweir static oslFileError osl_psz_createDirectory(const sal_Char* pszPath);
777cdf0e10cSrcweir static oslFileError osl_psz_removeDirectory(const sal_Char* pszPath);
778cdf0e10cSrcweir static oslFileError osl_psz_copyFile(const sal_Char* pszPath, const sal_Char* pszDestPath);
779cdf0e10cSrcweir static oslFileError osl_psz_moveFile(const sal_Char* pszPath, const sal_Char* pszDestPath);
780cdf0e10cSrcweir static oslFileError osl_psz_setFileTime(const sal_Char* strFilePath, const TimeValue* pCreationTime, const TimeValue* pLastAccessTime, const TimeValue* pLastWriteTime);
781cdf0e10cSrcweir
782cdf0e10cSrcweir
783cdf0e10cSrcweir /******************************************************************************
784cdf0e10cSrcweir *
785cdf0e10cSrcweir * Static Module Utility Function Declarations
786cdf0e10cSrcweir *
787cdf0e10cSrcweir *****************************************************************************/
788cdf0e10cSrcweir
789cdf0e10cSrcweir static oslFileError oslDoCopy(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, mode_t nMode, size_t nSourceSize, int DestFileExists);
790cdf0e10cSrcweir static oslFileError oslChangeFileModes(const sal_Char* pszFileName, mode_t nMode, time_t nAcTime, time_t nModTime, uid_t nUID, gid_t nGID);
791cdf0e10cSrcweir static int oslDoCopyLink(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName);
792cdf0e10cSrcweir static int oslDoCopyFile(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, size_t nSourceSize, mode_t mode);
793cdf0e10cSrcweir static oslFileError oslDoMoveFile(const sal_Char* pszPath, const sal_Char* pszDestPath);
794cdf0e10cSrcweir rtl_uString* oslMakeUStrFromPsz(const sal_Char* pszStr,rtl_uString** uStr);
795cdf0e10cSrcweir
796cdf0e10cSrcweir /******************************************************************************
797cdf0e10cSrcweir *
798cdf0e10cSrcweir * Non-Static Utility Function Declarations
799cdf0e10cSrcweir *
800cdf0e10cSrcweir *****************************************************************************/
801cdf0e10cSrcweir
802cdf0e10cSrcweir extern "C" int UnicodeToText( char *, size_t, const sal_Unicode *, sal_Int32 );
803cdf0e10cSrcweir extern "C" int TextToUnicode(
804cdf0e10cSrcweir const char* text, size_t text_buffer_size, sal_Unicode* unic_text, sal_Int32 unic_text_buffer_size);
805cdf0e10cSrcweir
806cdf0e10cSrcweir /******************************************************************************
807cdf0e10cSrcweir *
808cdf0e10cSrcweir * 'removeable device' aka floppy functions
809cdf0e10cSrcweir *
810cdf0e10cSrcweir *****************************************************************************/
811cdf0e10cSrcweir
812cdf0e10cSrcweir static oslVolumeDeviceHandle osl_isFloppyDrive(const sal_Char* pszPath);
813cdf0e10cSrcweir static oslFileError osl_mountFloppy(oslVolumeDeviceHandle hFloppy);
814cdf0e10cSrcweir static oslFileError osl_unmountFloppy(oslVolumeDeviceHandle hFloppy);
815cdf0e10cSrcweir
816cdf0e10cSrcweir #ifdef DEBUG_OSL_FILE
817cdf0e10cSrcweir static void osl_printFloppyHandle(oslVolumeDeviceHandleImpl* hFloppy);
818cdf0e10cSrcweir #endif
819cdf0e10cSrcweir
820cdf0e10cSrcweir /**********************************************
821cdf0e10cSrcweir * _osl_openLocalRoot
822cdf0e10cSrcweir * enumerate available drives
823cdf0e10cSrcweir *********************************************/
_osl_openLocalRoot(rtl_uString * strDirectoryPath,oslDirectory * pDirectory)824cdf0e10cSrcweir static oslFileError _osl_openLocalRoot( rtl_uString *strDirectoryPath, oslDirectory *pDirectory)
825cdf0e10cSrcweir {
826cdf0e10cSrcweir rtl_uString *ustrSystemPath = NULL;
827cdf0e10cSrcweir oslFileError error;
828cdf0e10cSrcweir
829cdf0e10cSrcweir if ( !pDirectory )
830cdf0e10cSrcweir return osl_File_E_INVAL;
831cdf0e10cSrcweir
832cdf0e10cSrcweir *pDirectory = NULL;
833cdf0e10cSrcweir
834cdf0e10cSrcweir error = osl_getSystemPathFromFileURL_Ex( strDirectoryPath, &ustrSystemPath, sal_False );
835cdf0e10cSrcweir
836cdf0e10cSrcweir if ( osl_File_E_None == error )
837cdf0e10cSrcweir {
838cdf0e10cSrcweir /* create and initialize impl structure */
839cdf0e10cSrcweir DirectoryImpl* pDirImpl = (DirectoryImpl*) rtl_allocateMemory( sizeof(DirectoryImpl) );
840cdf0e10cSrcweir if( pDirImpl )
841cdf0e10cSrcweir {
842cdf0e10cSrcweir ULONG ulDriveNum;
843cdf0e10cSrcweir APIRET rc;
844cdf0e10cSrcweir pDirImpl->uType = DIRECTORYTYPE_LOCALROOT;
845cdf0e10cSrcweir pDirImpl->ustrPath = ustrSystemPath;
846cdf0e10cSrcweir rc = DosQueryCurrentDisk (&ulDriveNum, &pDirImpl->ulDriveMap);
847cdf0e10cSrcweir pDirImpl->pDirStruct = 0;
848cdf0e10cSrcweir pDirImpl->ulNextDrive = 1;
849cdf0e10cSrcweir pDirImpl->ulNextDriveMask = 1;
850cdf0e10cSrcweir
851cdf0e10cSrcweir // determine number of floppy-drives
852cdf0e10cSrcweir BYTE nFloppies;
853cdf0e10cSrcweir rc = DosDevConfig( (void*) &nFloppies, DEVINFO_FLOPPY );
854cdf0e10cSrcweir if (nFloppies == 0) {
855cdf0e10cSrcweir // if no floppies, start with 3rd drive (C:)
856cdf0e10cSrcweir pDirImpl->ulNextDrive = 3;
857cdf0e10cSrcweir pDirImpl->ulNextDriveMask <<= 2;
858cdf0e10cSrcweir } else if (nFloppies == 1) {
859cdf0e10cSrcweir // mask drive B (second bit) in this case
860cdf0e10cSrcweir pDirImpl->ulDriveMap &= ~0x02;
861cdf0e10cSrcweir }
862cdf0e10cSrcweir *pDirectory = (oslDirectory) pDirImpl;
863cdf0e10cSrcweir return osl_File_E_None;
864cdf0e10cSrcweir }
865cdf0e10cSrcweir else
866cdf0e10cSrcweir {
867cdf0e10cSrcweir errno = osl_File_E_NOMEM;
868cdf0e10cSrcweir }
869cdf0e10cSrcweir
870cdf0e10cSrcweir }
871cdf0e10cSrcweir
872cdf0e10cSrcweir rtl_uString_release( ustrSystemPath );
873cdf0e10cSrcweir return error;
874cdf0e10cSrcweir }
875cdf0e10cSrcweir
876cdf0e10cSrcweir /**********************************************
877cdf0e10cSrcweir * _osl_getNextDrive
878cdf0e10cSrcweir *********************************************/
_osl_getNextDrive(oslDirectory Directory,oslDirectoryItem * pItem,sal_uInt32 uHint)879cdf0e10cSrcweir static oslFileError SAL_CALL _osl_getNextDrive(
880cdf0e10cSrcweir oslDirectory Directory, oslDirectoryItem *pItem, sal_uInt32 uHint )
881cdf0e10cSrcweir {
882cdf0e10cSrcweir DirectoryImpl *pDirImpl = (DirectoryImpl *)Directory;
883cdf0e10cSrcweir DirectoryItem_Impl *pItemImpl = NULL;
884cdf0e10cSrcweir rtl_uString * ustrDrive = NULL;
885cdf0e10cSrcweir BOOL fSuccess;
886cdf0e10cSrcweir char buffer[3];
887cdf0e10cSrcweir
888cdf0e10cSrcweir uHint = uHint; /* avoid warnings */
889cdf0e10cSrcweir
890cdf0e10cSrcweir if ( !pItem )
891cdf0e10cSrcweir return osl_File_E_INVAL;
892cdf0e10cSrcweir
893cdf0e10cSrcweir *pItem = NULL;
894cdf0e10cSrcweir
895cdf0e10cSrcweir if ( !pDirImpl )
896cdf0e10cSrcweir return osl_File_E_INVAL;
897cdf0e10cSrcweir
898cdf0e10cSrcweir while( pDirImpl->ulNextDrive <= 26)
899cdf0e10cSrcweir {
900cdf0e10cSrcweir // exit if bit==1 -> drive found
901cdf0e10cSrcweir if (pDirImpl->ulDriveMap & pDirImpl->ulNextDriveMask) {
902cdf0e10cSrcweir
903cdf0e10cSrcweir /* convert file name to unicode */
904cdf0e10cSrcweir buffer[0] = '@' + pDirImpl->ulNextDrive;
905cdf0e10cSrcweir buffer[1] = ':';
906cdf0e10cSrcweir buffer[2] = 0;
907cdf0e10cSrcweir
908cdf0e10cSrcweir pItemImpl = (DirectoryItem_Impl*) rtl_allocateMemory(sizeof(DirectoryItem_Impl));
909cdf0e10cSrcweir if ( !pItemImpl )
910cdf0e10cSrcweir return osl_File_E_NOMEM;
911cdf0e10cSrcweir
912cdf0e10cSrcweir memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
913cdf0e10cSrcweir pItemImpl->uType = DIRECTORYITEM_DRIVE;
914cdf0e10cSrcweir pItemImpl->nRefCount = 1;
915cdf0e10cSrcweir
916cdf0e10cSrcweir rtl_string2UString( &pItemImpl->ustrDrive, buffer, 3,
917cdf0e10cSrcweir osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS );
918cdf0e10cSrcweir OSL_ASSERT(pItemImpl->ustrDrive != 0);
919cdf0e10cSrcweir
920cdf0e10cSrcweir /* use drive as directory item */
921cdf0e10cSrcweir *pItem = (oslDirectoryItem) pItemImpl;
922cdf0e10cSrcweir }
923cdf0e10cSrcweir // scan next bit position
924cdf0e10cSrcweir pDirImpl->ulNextDrive++;
925cdf0e10cSrcweir pDirImpl->ulNextDriveMask <<= 1;
926cdf0e10cSrcweir
927cdf0e10cSrcweir if (*pItem) // item assigned, return now.
928cdf0e10cSrcweir return osl_File_E_None;
929cdf0e10cSrcweir }
930cdf0e10cSrcweir
931cdf0e10cSrcweir // no more items
932cdf0e10cSrcweir return osl_File_E_NOENT;
933cdf0e10cSrcweir }
934cdf0e10cSrcweir
935cdf0e10cSrcweir /**********************************************
936cdf0e10cSrcweir * _osl_readdir_impl_
937cdf0e10cSrcweir *
938cdf0e10cSrcweir * readdir wrapper, filters out "." and ".."
939cdf0e10cSrcweir * on request
940cdf0e10cSrcweir *********************************************/
941cdf0e10cSrcweir
_osl_readdir_impl_(DIR * pdir,sal_Bool bFilterLocalAndParentDir)942cdf0e10cSrcweir static struct dirent* _osl_readdir_impl_(DIR* pdir, sal_Bool bFilterLocalAndParentDir)
943cdf0e10cSrcweir {
944cdf0e10cSrcweir struct dirent* pdirent;
945cdf0e10cSrcweir
946cdf0e10cSrcweir while ((pdirent = readdir(pdir)) != NULL)
947cdf0e10cSrcweir {
948cdf0e10cSrcweir if (bFilterLocalAndParentDir &&
949cdf0e10cSrcweir ((0 == strcmp(pdirent->d_name, ".")) || (0 == strcmp(pdirent->d_name, ".."))))
950cdf0e10cSrcweir continue;
951cdf0e10cSrcweir else
952cdf0e10cSrcweir break;
953cdf0e10cSrcweir }
954cdf0e10cSrcweir
955cdf0e10cSrcweir return pdirent;
956cdf0e10cSrcweir }
957cdf0e10cSrcweir
958cdf0e10cSrcweir /*******************************************************************
959cdf0e10cSrcweir * osl_openDirectory
960cdf0e10cSrcweir ******************************************************************/
961cdf0e10cSrcweir
osl_openDirectory(rtl_uString * ustrDirectoryURL,oslDirectory * pDirectory)962cdf0e10cSrcweir oslFileError SAL_CALL osl_openDirectory(rtl_uString* ustrDirectoryURL, oslDirectory* pDirectory)
963cdf0e10cSrcweir {
964cdf0e10cSrcweir rtl_uString* ustrSystemPath = NULL;
965cdf0e10cSrcweir oslFileError eRet;
966cdf0e10cSrcweir
967cdf0e10cSrcweir char path[PATH_MAX];
968cdf0e10cSrcweir
969cdf0e10cSrcweir OSL_ASSERT(ustrDirectoryURL && (ustrDirectoryURL->length > 0));
970cdf0e10cSrcweir OSL_ASSERT(pDirectory);
971cdf0e10cSrcweir
972cdf0e10cSrcweir if (0 == ustrDirectoryURL->length )
973cdf0e10cSrcweir return osl_File_E_INVAL;
974cdf0e10cSrcweir
975cdf0e10cSrcweir if ( 0 == rtl_ustr_compareIgnoreAsciiCase( ustrDirectoryURL->buffer, (const sal_Unicode*)L"file:///" ) )
976cdf0e10cSrcweir return _osl_openLocalRoot( ustrDirectoryURL, pDirectory );
977cdf0e10cSrcweir
978cdf0e10cSrcweir /* convert file URL to system path */
979cdf0e10cSrcweir eRet = osl_getSystemPathFromFileURL_Ex(ustrDirectoryURL, &ustrSystemPath, sal_False);
980cdf0e10cSrcweir
981cdf0e10cSrcweir if( osl_File_E_None != eRet )
982cdf0e10cSrcweir return eRet;
983cdf0e10cSrcweir
984cdf0e10cSrcweir osl_systemPathRemoveSeparator(ustrSystemPath);
985cdf0e10cSrcweir
986cdf0e10cSrcweir /* convert unicode path to text */
987cdf0e10cSrcweir if ( UnicodeToText( path, PATH_MAX, ustrSystemPath->buffer, ustrSystemPath->length ) )
988cdf0e10cSrcweir {
989cdf0e10cSrcweir // if only the drive is specified (x:), add a \ (x:\) otherwise current
990cdf0e10cSrcweir // directory is browsed instead of root.
991cdf0e10cSrcweir if (strlen( path) == 2 && path[1] == ':')
992cdf0e10cSrcweir strcat( path, "\\");
993cdf0e10cSrcweir /* open directory */
994cdf0e10cSrcweir DIR *pdir = opendir( path );
995cdf0e10cSrcweir
996cdf0e10cSrcweir if( pdir )
997cdf0e10cSrcweir {
998cdf0e10cSrcweir /* create and initialize impl structure */
999cdf0e10cSrcweir DirectoryImpl* pDirImpl = (DirectoryImpl*) rtl_allocateMemory( sizeof(DirectoryImpl) );
1000cdf0e10cSrcweir
1001cdf0e10cSrcweir if( pDirImpl )
1002cdf0e10cSrcweir {
1003cdf0e10cSrcweir pDirImpl->uType = DIRECTORYTYPE_FILESYSTEM;
1004cdf0e10cSrcweir pDirImpl->pDirStruct = pdir;
1005cdf0e10cSrcweir pDirImpl->ustrPath = ustrSystemPath;
1006cdf0e10cSrcweir
1007cdf0e10cSrcweir *pDirectory = (oslDirectory) pDirImpl;
1008cdf0e10cSrcweir return osl_File_E_None;
1009cdf0e10cSrcweir }
1010cdf0e10cSrcweir else
1011cdf0e10cSrcweir {
1012cdf0e10cSrcweir errno = ENOMEM;
1013cdf0e10cSrcweir closedir( pdir );
1014cdf0e10cSrcweir }
1015cdf0e10cSrcweir }
1016cdf0e10cSrcweir else
1017cdf0e10cSrcweir /* should be removed by optimizer in product version */
1018cdf0e10cSrcweir PERROR( "osl_openDirectory", path );
1019cdf0e10cSrcweir }
1020cdf0e10cSrcweir
1021cdf0e10cSrcweir rtl_uString_release( ustrSystemPath );
1022cdf0e10cSrcweir
1023cdf0e10cSrcweir return oslTranslateFileError(OSL_FET_ERROR, errno);
1024cdf0e10cSrcweir }
1025cdf0e10cSrcweir
1026cdf0e10cSrcweir
1027cdf0e10cSrcweir /****************************************************************************
1028cdf0e10cSrcweir * osl_getNextDirectoryItem
1029cdf0e10cSrcweir ***************************************************************************/
1030cdf0e10cSrcweir
osl_getNextDirectoryItem(oslDirectory Directory,oslDirectoryItem * pItem,sal_uInt32 uHint)1031cdf0e10cSrcweir oslFileError SAL_CALL osl_getNextDirectoryItem(oslDirectory Directory, oslDirectoryItem* pItem, sal_uInt32 uHint)
1032cdf0e10cSrcweir {
1033cdf0e10cSrcweir DirectoryImpl* pDirImpl = (DirectoryImpl*)Directory;
1034cdf0e10cSrcweir DirectoryItem_Impl *pItemImpl = NULL;
1035cdf0e10cSrcweir rtl_uString* ustrFileName = NULL;
1036cdf0e10cSrcweir rtl_uString* ustrFilePath = NULL;
1037cdf0e10cSrcweir struct dirent* pEntry;
1038cdf0e10cSrcweir
1039cdf0e10cSrcweir OSL_ASSERT(Directory);
1040cdf0e10cSrcweir OSL_ASSERT(pItem);
1041cdf0e10cSrcweir
1042cdf0e10cSrcweir if ((NULL == Directory) || (NULL == pItem))
1043cdf0e10cSrcweir return osl_File_E_INVAL;
1044cdf0e10cSrcweir
1045cdf0e10cSrcweir if ( pDirImpl->uType == DIRECTORYTYPE_LOCALROOT)
1046cdf0e10cSrcweir return _osl_getNextDrive( Directory, pItem, uHint );
1047cdf0e10cSrcweir
1048cdf0e10cSrcweir pEntry = _osl_readdir_impl_(pDirImpl->pDirStruct, sal_True);
1049cdf0e10cSrcweir
1050cdf0e10cSrcweir if (NULL == pEntry)
1051cdf0e10cSrcweir return osl_File_E_NOENT;
1052cdf0e10cSrcweir
1053cdf0e10cSrcweir pItemImpl = (DirectoryItem_Impl*) rtl_allocateMemory(sizeof(DirectoryItem_Impl));
1054cdf0e10cSrcweir if ( !pItemImpl )
1055cdf0e10cSrcweir return osl_File_E_NOMEM;
1056cdf0e10cSrcweir
1057cdf0e10cSrcweir memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
1058cdf0e10cSrcweir pItemImpl->uType = DIRECTORYITEM_FILE;
1059cdf0e10cSrcweir pItemImpl->nRefCount = 1;
1060cdf0e10cSrcweir pItemImpl->d_attr = pEntry->d_attr;
1061cdf0e10cSrcweir
1062cdf0e10cSrcweir /* convert file name to unicode */
1063cdf0e10cSrcweir rtl_string2UString( &ustrFileName, pEntry->d_name, strlen( pEntry->d_name ),
1064cdf0e10cSrcweir osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS );
1065cdf0e10cSrcweir OSL_ASSERT(ustrFileName != 0);
1066cdf0e10cSrcweir
1067cdf0e10cSrcweir osl_systemPathMakeAbsolutePath(pDirImpl->ustrPath, ustrFileName, &pItemImpl->ustrFilePath);
1068cdf0e10cSrcweir rtl_uString_release( ustrFileName );
1069cdf0e10cSrcweir
1070cdf0e10cSrcweir *pItem = (oslDirectoryItem)pItemImpl;
1071cdf0e10cSrcweir return osl_File_E_None;
1072cdf0e10cSrcweir }
1073cdf0e10cSrcweir
1074cdf0e10cSrcweir /****************************************************************************/
1075cdf0e10cSrcweir /* osl_closeDirectory */
1076cdf0e10cSrcweir /****************************************************************************/
1077cdf0e10cSrcweir
osl_closeDirectory(oslDirectory Directory)1078cdf0e10cSrcweir oslFileError SAL_CALL osl_closeDirectory( oslDirectory Directory )
1079cdf0e10cSrcweir {
1080cdf0e10cSrcweir DirectoryImpl* pDirImpl = (DirectoryImpl*) Directory;
1081cdf0e10cSrcweir oslFileError err = osl_File_E_None;
1082cdf0e10cSrcweir
1083cdf0e10cSrcweir OSL_ASSERT( Directory );
1084cdf0e10cSrcweir
1085cdf0e10cSrcweir if( NULL == pDirImpl )
1086cdf0e10cSrcweir return osl_File_E_INVAL;
1087cdf0e10cSrcweir
1088cdf0e10cSrcweir switch ( pDirImpl->uType )
1089cdf0e10cSrcweir {
1090cdf0e10cSrcweir case DIRECTORYTYPE_FILESYSTEM:
1091cdf0e10cSrcweir if( closedir( pDirImpl->pDirStruct ) )
1092cdf0e10cSrcweir err = oslTranslateFileError(OSL_FET_ERROR, errno);
1093cdf0e10cSrcweir break;
1094cdf0e10cSrcweir case DIRECTORYTYPE_LOCALROOT:
1095cdf0e10cSrcweir err = osl_File_E_None;
1096cdf0e10cSrcweir break;
1097cdf0e10cSrcweir #if 0
1098cdf0e10cSrcweir case DIRECTORYTYPE_NETROOT:
1099cdf0e10cSrcweir {
1100cdf0e10cSrcweir DWORD err = WNetCloseEnum(pDirImpl->hDirectory);
1101cdf0e10cSrcweir eError = (err == NO_ERROR) ? osl_File_E_None : MapError(err);
1102cdf0e10cSrcweir }
1103cdf0e10cSrcweir break;
1104cdf0e10cSrcweir #endif
1105cdf0e10cSrcweir default:
1106cdf0e10cSrcweir OSL_ENSURE( 0, "Invalid directory type" );
1107cdf0e10cSrcweir break;
1108cdf0e10cSrcweir }
1109cdf0e10cSrcweir
1110cdf0e10cSrcweir /* cleanup members */
1111cdf0e10cSrcweir rtl_uString_release( pDirImpl->ustrPath );
1112cdf0e10cSrcweir
1113cdf0e10cSrcweir rtl_freeMemory( pDirImpl );
1114cdf0e10cSrcweir
1115cdf0e10cSrcweir return err;
1116cdf0e10cSrcweir }
1117cdf0e10cSrcweir
1118cdf0e10cSrcweir /****************************************************************************/
1119cdf0e10cSrcweir /* osl_getDirectoryItem */
1120cdf0e10cSrcweir /****************************************************************************/
1121cdf0e10cSrcweir
osl_getDirectoryItem(rtl_uString * ustrFileURL,oslDirectoryItem * pItem)1122cdf0e10cSrcweir oslFileError SAL_CALL osl_getDirectoryItem( rtl_uString* ustrFileURL, oslDirectoryItem* pItem )
1123cdf0e10cSrcweir {
1124cdf0e10cSrcweir rtl_uString* strSysFilePath = NULL;
1125cdf0e10cSrcweir oslFileError error = osl_File_E_INVAL;
1126cdf0e10cSrcweir ULONG dwPathType;
1127cdf0e10cSrcweir PATHTYPE type = PATHTYPE_FILE;
1128cdf0e10cSrcweir
1129cdf0e10cSrcweir OSL_ASSERT(ustrFileURL);
1130cdf0e10cSrcweir OSL_ASSERT(pItem);
1131cdf0e10cSrcweir
1132cdf0e10cSrcweir /* Assume failure */
1133cdf0e10cSrcweir if ( !pItem )
1134cdf0e10cSrcweir return osl_File_E_INVAL;
1135cdf0e10cSrcweir *pItem = NULL;
1136cdf0e10cSrcweir
1137cdf0e10cSrcweir if (0 == ustrFileURL->length || NULL == pItem)
1138cdf0e10cSrcweir return osl_File_E_INVAL;
1139cdf0e10cSrcweir
1140cdf0e10cSrcweir error = osl_getSystemPathFromFileURL_Ex(ustrFileURL, &strSysFilePath, sal_False);
1141cdf0e10cSrcweir
1142cdf0e10cSrcweir if (osl_File_E_None != error)
1143cdf0e10cSrcweir return error;
1144cdf0e10cSrcweir
1145cdf0e10cSrcweir dwPathType = IsValidFilePath( strSysFilePath->buffer, NULL, VALIDATEPATH_NORMAL );
1146cdf0e10cSrcweir
1147cdf0e10cSrcweir if ( dwPathType & PATHTYPE_IS_VOLUME )
1148cdf0e10cSrcweir type = PATHTYPE_VOLUME;
1149cdf0e10cSrcweir else if ( dwPathType & PATHTYPE_IS_SERVER )
1150cdf0e10cSrcweir type = PATHTYPE_NETSERVER;
1151cdf0e10cSrcweir else
1152cdf0e10cSrcweir type = PATHTYPE_FILE;
1153cdf0e10cSrcweir
1154cdf0e10cSrcweir switch ( type )
1155cdf0e10cSrcweir {
1156cdf0e10cSrcweir case PATHTYPE_NETSERVER:
1157cdf0e10cSrcweir {
1158cdf0e10cSrcweir DirectoryItem_Impl* pItemImpl =
1159cdf0e10cSrcweir reinterpret_cast<DirectoryItem_Impl*>(rtl_allocateMemory(sizeof(DirectoryItem_Impl)));
1160cdf0e10cSrcweir
1161cdf0e10cSrcweir if ( !pItemImpl )
1162cdf0e10cSrcweir error = osl_File_E_NOMEM;
1163cdf0e10cSrcweir
1164cdf0e10cSrcweir if ( osl_File_E_None == error )
1165cdf0e10cSrcweir {
1166cdf0e10cSrcweir memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
1167cdf0e10cSrcweir pItemImpl->uType = DIRECTORYITEM_SERVER;
1168cdf0e10cSrcweir pItemImpl->nRefCount = 1;
1169cdf0e10cSrcweir rtl_uString_assign( &pItemImpl->ustrFilePath, strSysFilePath );
1170cdf0e10cSrcweir
1171cdf0e10cSrcweir *pItem = pItemImpl;
1172cdf0e10cSrcweir }
1173cdf0e10cSrcweir }
1174cdf0e10cSrcweir break;
1175cdf0e10cSrcweir case PATHTYPE_VOLUME:
1176cdf0e10cSrcweir {
1177cdf0e10cSrcweir DirectoryItem_Impl* pItemImpl =
1178cdf0e10cSrcweir reinterpret_cast<DirectoryItem_Impl*>(rtl_allocateMemory(sizeof(DirectoryItem_Impl)));
1179cdf0e10cSrcweir
1180cdf0e10cSrcweir if ( !pItemImpl )
1181cdf0e10cSrcweir error = osl_File_E_NOMEM;
1182cdf0e10cSrcweir
1183cdf0e10cSrcweir if ( osl_File_E_None == error )
1184cdf0e10cSrcweir {
1185cdf0e10cSrcweir memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
1186cdf0e10cSrcweir pItemImpl->uType = DIRECTORYITEM_DRIVE;
1187cdf0e10cSrcweir pItemImpl->nRefCount = 1;
1188cdf0e10cSrcweir rtl_uString_assign( &pItemImpl->ustrDrive, strSysFilePath );
1189cdf0e10cSrcweir
1190cdf0e10cSrcweir if ( pItemImpl->ustrDrive->buffer[pItemImpl->ustrDrive->length-1] != sal_Unicode('\\') )
1191cdf0e10cSrcweir rtl_uString_newConcat( &pItemImpl->ustrDrive,
1192cdf0e10cSrcweir pItemImpl->ustrDrive, rtl::OUString::createFromAscii( "\\" ).pData);
1193cdf0e10cSrcweir
1194cdf0e10cSrcweir *pItem = pItemImpl;
1195cdf0e10cSrcweir }
1196cdf0e10cSrcweir }
1197cdf0e10cSrcweir break;
1198cdf0e10cSrcweir default:
1199cdf0e10cSrcweir case PATHTYPE_FILE:
1200cdf0e10cSrcweir {
1201cdf0e10cSrcweir if ( strSysFilePath->length > 0 && strSysFilePath->buffer[strSysFilePath->length - 1] == '\\' )
1202cdf0e10cSrcweir rtl_uString_newFromStr_WithLength( &strSysFilePath, strSysFilePath->buffer, strSysFilePath->length - 1 );
1203cdf0e10cSrcweir
1204cdf0e10cSrcweir if (0 == access_u(strSysFilePath, F_OK))
1205cdf0e10cSrcweir {
1206cdf0e10cSrcweir DirectoryItem_Impl *pItemImpl =
1207cdf0e10cSrcweir reinterpret_cast<DirectoryItem_Impl*>(rtl_allocateMemory(sizeof(DirectoryItem_Impl)));
1208cdf0e10cSrcweir
1209cdf0e10cSrcweir memset( pItemImpl, 0, sizeof(DirectoryItem_Impl) );
1210cdf0e10cSrcweir pItemImpl->uType = DIRECTORYITEM_FILE;
1211cdf0e10cSrcweir pItemImpl->nRefCount = 1;
1212cdf0e10cSrcweir rtl_uString_assign( &pItemImpl->ustrFilePath, strSysFilePath );
1213cdf0e10cSrcweir
1214cdf0e10cSrcweir *pItem = pItemImpl;
1215cdf0e10cSrcweir }
1216cdf0e10cSrcweir else
1217cdf0e10cSrcweir error = oslTranslateFileError(OSL_FET_ERROR, errno);
1218cdf0e10cSrcweir }
1219cdf0e10cSrcweir break;
1220cdf0e10cSrcweir }
1221cdf0e10cSrcweir
1222cdf0e10cSrcweir if ( strSysFilePath )
1223cdf0e10cSrcweir rtl_uString_release( strSysFilePath );
1224cdf0e10cSrcweir
1225cdf0e10cSrcweir return error;
1226cdf0e10cSrcweir }
1227cdf0e10cSrcweir
1228cdf0e10cSrcweir /****************************************************************************/
1229cdf0e10cSrcweir /* osl_acquireDirectoryItem */
1230cdf0e10cSrcweir /****************************************************************************/
1231cdf0e10cSrcweir
osl_acquireDirectoryItem(oslDirectoryItem Item)1232cdf0e10cSrcweir oslFileError osl_acquireDirectoryItem( oslDirectoryItem Item )
1233cdf0e10cSrcweir {
1234cdf0e10cSrcweir OSL_ASSERT( Item );
1235cdf0e10cSrcweir DirectoryItem_Impl *pItemImpl = (DirectoryItem_Impl *)Item;
1236cdf0e10cSrcweir
1237cdf0e10cSrcweir if ( !pItemImpl )
1238cdf0e10cSrcweir return osl_File_E_INVAL;
1239cdf0e10cSrcweir
1240cdf0e10cSrcweir pItemImpl->nRefCount++;
1241cdf0e10cSrcweir return osl_File_E_None;
1242cdf0e10cSrcweir }
1243cdf0e10cSrcweir
1244cdf0e10cSrcweir /****************************************************************************/
1245cdf0e10cSrcweir /* osl_releaseDirectoryItem */
1246cdf0e10cSrcweir /****************************************************************************/
1247cdf0e10cSrcweir
osl_releaseDirectoryItem(oslDirectoryItem Item)1248cdf0e10cSrcweir oslFileError osl_releaseDirectoryItem( oslDirectoryItem Item )
1249cdf0e10cSrcweir {
1250cdf0e10cSrcweir OSL_ASSERT( Item );
1251cdf0e10cSrcweir DirectoryItem_Impl *pItemImpl = (DirectoryItem_Impl *)Item;
1252cdf0e10cSrcweir
1253cdf0e10cSrcweir if ( !pItemImpl )
1254cdf0e10cSrcweir return osl_File_E_INVAL;
1255cdf0e10cSrcweir
1256cdf0e10cSrcweir if ( ! --pItemImpl->nRefCount )
1257cdf0e10cSrcweir {
1258cdf0e10cSrcweir if (pItemImpl->ustrFilePath)
1259cdf0e10cSrcweir rtl_uString_release( pItemImpl->ustrFilePath );
1260cdf0e10cSrcweir if (pItemImpl->ustrDrive)
1261cdf0e10cSrcweir rtl_uString_release( pItemImpl->ustrDrive );
1262cdf0e10cSrcweir rtl_freeMemory( pItemImpl );
1263cdf0e10cSrcweir }
1264cdf0e10cSrcweir return osl_File_E_None;
1265cdf0e10cSrcweir }
1266cdf0e10cSrcweir
1267cdf0e10cSrcweir /****************************************************************************
1268cdf0e10cSrcweir * osl_createFileHandleFromFD
1269cdf0e10cSrcweir ***************************************************************************/
osl_createFileHandleFromFD(int fd)1270dcc6e752SPedro Giffuni extern "C" oslFileHandle osl_createFileHandleFromFD( int fd )
1271cdf0e10cSrcweir {
1272dcc6e752SPedro Giffuni if (-1 == fd)
1273dcc6e752SPedro Giffuni return 0; // EINVAL
1274cdf0e10cSrcweir
1275dcc6e752SPedro Giffuni struct stat aFileStat;
1276dcc6e752SPedro Giffuni if (-1 == fstat (fd, &aFileStat))
1277dcc6e752SPedro Giffuni return 0; // EBADF
1278cdf0e10cSrcweir
1279dcc6e752SPedro Giffuni FileHandle_Impl * pImpl = new FileHandle_Impl (fd);
1280dcc6e752SPedro Giffuni if (0 == pImpl)
1281dcc6e752SPedro Giffuni return 0; // ENOMEM
1282dcc6e752SPedro Giffuni
1283dcc6e752SPedro Giffuni // assume writeable
1284dcc6e752SPedro Giffuni pImpl->m_state |= FileHandle_Impl::STATE_WRITEABLE;
1285dcc6e752SPedro Giffuni if (!S_ISREG(aFileStat.st_mode))
1286dcc6e752SPedro Giffuni {
1287dcc6e752SPedro Giffuni /* not a regular file, mark not seekable */
1288dcc6e752SPedro Giffuni pImpl->m_state &= ~FileHandle_Impl::STATE_SEEKABLE;
1289dcc6e752SPedro Giffuni }
1290dcc6e752SPedro Giffuni else
1291dcc6e752SPedro Giffuni {
1292dcc6e752SPedro Giffuni /* regular file, init current size */
1293dcc6e752SPedro Giffuni pImpl->m_size = sal::static_int_cast< sal_uInt64 >(aFileStat.st_size);
1294dcc6e752SPedro Giffuni }
1295dcc6e752SPedro Giffuni
1296dcc6e752SPedro Giffuni OSL_FILE_TRACE("osl_createFileHandleFromFD(%d, writeable) => %s",
1297dcc6e752SPedro Giffuni pImpl->m_fd, rtl_string_getStr(pImpl->m_strFilePath));
1298dcc6e752SPedro Giffuni return (oslFileHandle)(pImpl);
1299dcc6e752SPedro Giffuni }
1300cdf0e10cSrcweir
1301dcc6e752SPedro Giffuni /*******************************************************************
1302dcc6e752SPedro Giffuni * osl_file_adjustLockFlags
1303dcc6e752SPedro Giffuni ******************************************************************/
osl_file_adjustLockFlags(const char * path,int flags)1304dcc6e752SPedro Giffuni static int osl_file_adjustLockFlags (const char * path, int flags)
1305dcc6e752SPedro Giffuni {
1306dcc6e752SPedro Giffuni #ifdef MACOSX
1307dcc6e752SPedro Giffuni /*
1308dcc6e752SPedro Giffuni * The AFP implementation of MacOS X 10.4 treats O_EXLOCK in a way
1309dcc6e752SPedro Giffuni * that makes it impossible for OOo to create a backup copy of the
1310dcc6e752SPedro Giffuni * file it keeps opened. OTOH O_SHLOCK for AFP behaves as desired by
1311dcc6e752SPedro Giffuni * the OOo file handling, so we need to check the path of the file
1312dcc6e752SPedro Giffuni * for the filesystem name.
1313dcc6e752SPedro Giffuni */
1314dcc6e752SPedro Giffuni struct statfs s;
1315dcc6e752SPedro Giffuni if( 0 <= statfs( path, &s ) )
1316dcc6e752SPedro Giffuni {
1317dcc6e752SPedro Giffuni if( 0 == strncmp("afpfs", s.f_fstypename, 5) )
1318dcc6e752SPedro Giffuni {
1319dcc6e752SPedro Giffuni flags &= ~O_EXLOCK;
1320dcc6e752SPedro Giffuni flags |= O_SHLOCK;
1321dcc6e752SPedro Giffuni }
1322dcc6e752SPedro Giffuni else
1323dcc6e752SPedro Giffuni {
1324dcc6e752SPedro Giffuni /* Needed flags to allow opening a webdav file */
1325dcc6e752SPedro Giffuni flags &= ~(O_EXLOCK | O_SHLOCK | O_NONBLOCK);
1326cdf0e10cSrcweir }
1327dcc6e752SPedro Giffuni }
1328dcc6e752SPedro Giffuni #endif /* MACOSX */
1329cdf0e10cSrcweir
1330dcc6e752SPedro Giffuni (void) path;
1331dcc6e752SPedro Giffuni return flags;
1332dcc6e752SPedro Giffuni }
1333dcc6e752SPedro Giffuni
1334dcc6e752SPedro Giffuni /****************************************************************************
1335dcc6e752SPedro Giffuni * osl_file_queryLocking
1336dcc6e752SPedro Giffuni ***************************************************************************/
1337dcc6e752SPedro Giffuni struct Locking_Impl
1338dcc6e752SPedro Giffuni {
1339dcc6e752SPedro Giffuni int m_enabled;
Locking_ImplLocking_Impl1340dcc6e752SPedro Giffuni Locking_Impl() : m_enabled(0)
1341dcc6e752SPedro Giffuni {
1342dcc6e752SPedro Giffuni #ifndef HAVE_O_EXLOCK
1343dcc6e752SPedro Giffuni m_enabled = ((getenv("SAL_ENABLE_FILE_LOCKING") != 0) || (getenv("STAR_ENABLE_FILE_LOCKING") != 0));
1344dcc6e752SPedro Giffuni #endif /* HAVE_O_EXLOCK */
1345dcc6e752SPedro Giffuni }
1346dcc6e752SPedro Giffuni };
osl_file_queryLocking(sal_uInt32 uFlags)1347dcc6e752SPedro Giffuni static int osl_file_queryLocking (sal_uInt32 uFlags)
1348dcc6e752SPedro Giffuni {
1349dcc6e752SPedro Giffuni if (!(uFlags & osl_File_OpenFlag_NoLock))
1350dcc6e752SPedro Giffuni {
1351dcc6e752SPedro Giffuni if ((uFlags & osl_File_OpenFlag_Write) || (uFlags & osl_File_OpenFlag_Create))
1352dcc6e752SPedro Giffuni {
1353dcc6e752SPedro Giffuni static Locking_Impl g_locking;
1354dcc6e752SPedro Giffuni return (g_locking.m_enabled != 0);
1355dcc6e752SPedro Giffuni }
1356dcc6e752SPedro Giffuni }
1357dcc6e752SPedro Giffuni return 0;
1358cdf0e10cSrcweir }
1359cdf0e10cSrcweir
1360cdf0e10cSrcweir /****************************************************************************
1361cdf0e10cSrcweir * osl_openFile
1362cdf0e10cSrcweir ***************************************************************************/
1363dcc6e752SPedro Giffuni #ifdef HAVE_O_EXLOCK
1364dcc6e752SPedro Giffuni #define OPEN_WRITE_FLAGS ( O_RDWR | O_EXLOCK | O_NONBLOCK )
1365dcc6e752SPedro Giffuni #define OPEN_CREATE_FLAGS ( O_CREAT | O_EXCL | O_RDWR | O_EXLOCK | O_NONBLOCK )
1366dcc6e752SPedro Giffuni #else
1367dcc6e752SPedro Giffuni #define OPEN_WRITE_FLAGS ( O_RDWR )
1368dcc6e752SPedro Giffuni #define OPEN_CREATE_FLAGS ( O_CREAT | O_EXCL | O_RDWR )
1369dcc6e752SPedro Giffuni #endif
1370cdf0e10cSrcweir
1371dcc6e752SPedro Giffuni oslFileError
osl_openFile(rtl_uString * ustrFileURL,oslFileHandle * pHandle,sal_uInt32 uFlags)1372dcc6e752SPedro Giffuni SAL_CALL osl_openFile( rtl_uString* ustrFileURL, oslFileHandle* pHandle, sal_uInt32 uFlags )
1373cdf0e10cSrcweir {
1374cdf0e10cSrcweir oslFileError eRet;
1375cdf0e10cSrcweir
1376dcc6e752SPedro Giffuni if ((ustrFileURL == 0) || (ustrFileURL->length == 0) || (pHandle == 0))
1377dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1378dcc6e752SPedro Giffuni
1379dcc6e752SPedro Giffuni /* convert file URL to system path */
1380cdf0e10cSrcweir char buffer[PATH_MAX];
1381dcc6e752SPedro Giffuni eRet = FileURLToPath (buffer, sizeof(buffer), ustrFileURL);
1382dcc6e752SPedro Giffuni if (eRet != osl_File_E_None)
1383dcc6e752SPedro Giffuni return eRet;
1384dcc6e752SPedro Giffuni #ifdef MACOSX
1385dcc6e752SPedro Giffuni if (macxp_resolveAlias (buffer, sizeof(buffer)) != 0)
1386dcc6e752SPedro Giffuni return oslTranslateFileError (OSL_FET_ERROR, errno);
1387dcc6e752SPedro Giffuni #endif /* MACOSX */
1388cdf0e10cSrcweir
1389dcc6e752SPedro Giffuni /* set mode and flags */
1390dcc6e752SPedro Giffuni int mode = S_IRUSR | S_IRGRP | S_IROTH;
1391dcc6e752SPedro Giffuni int flags = O_RDONLY;
1392dcc6e752SPedro Giffuni if (uFlags & osl_File_OpenFlag_Write)
1393dcc6e752SPedro Giffuni {
1394dcc6e752SPedro Giffuni mode |= S_IWUSR | S_IWGRP | S_IWOTH;
1395dcc6e752SPedro Giffuni flags = OPEN_WRITE_FLAGS;
1396dcc6e752SPedro Giffuni }
1397dcc6e752SPedro Giffuni if (uFlags & osl_File_OpenFlag_Create)
1398dcc6e752SPedro Giffuni {
1399dcc6e752SPedro Giffuni mode |= S_IWUSR | S_IWGRP | S_IWOTH;
1400dcc6e752SPedro Giffuni flags = OPEN_CREATE_FLAGS;
1401dcc6e752SPedro Giffuni }
1402dcc6e752SPedro Giffuni if (uFlags & osl_File_OpenFlag_NoLock)
1403dcc6e752SPedro Giffuni {
1404dcc6e752SPedro Giffuni #ifdef HAVE_O_EXLOCK
1405dcc6e752SPedro Giffuni flags &= ~(O_EXLOCK | O_SHLOCK | O_NONBLOCK);
1406dcc6e752SPedro Giffuni #endif /* HAVE_O_EXLOCK */
1407dcc6e752SPedro Giffuni }
1408dcc6e752SPedro Giffuni else
1409dcc6e752SPedro Giffuni {
1410dcc6e752SPedro Giffuni flags = osl_file_adjustLockFlags (buffer, flags);
1411dcc6e752SPedro Giffuni }
1412cdf0e10cSrcweir
1413dcc6e752SPedro Giffuni /* open the file */
1414dcc6e752SPedro Giffuni int fd = open( buffer, flags | O_BINARY, mode );
1415dcc6e752SPedro Giffuni if (-1 == fd)
1416dcc6e752SPedro Giffuni return oslTranslateFileError (OSL_FET_ERROR, errno);
1417cdf0e10cSrcweir
1418dcc6e752SPedro Giffuni /* reset O_NONBLOCK flag */
1419dcc6e752SPedro Giffuni if (flags & O_NONBLOCK)
1420dcc6e752SPedro Giffuni {
1421dcc6e752SPedro Giffuni int f = fcntl (fd, F_GETFL, 0);
1422dcc6e752SPedro Giffuni if (-1 == f)
1423dcc6e752SPedro Giffuni {
1424dcc6e752SPedro Giffuni eRet = oslTranslateFileError (OSL_FET_ERROR, errno);
1425dcc6e752SPedro Giffuni (void) close(fd);
1426dcc6e752SPedro Giffuni return eRet;
1427dcc6e752SPedro Giffuni }
1428dcc6e752SPedro Giffuni if (-1 == fcntl (fd, F_SETFL, (f & ~O_NONBLOCK)))
1429dcc6e752SPedro Giffuni {
1430dcc6e752SPedro Giffuni eRet = oslTranslateFileError (OSL_FET_ERROR, errno);
1431dcc6e752SPedro Giffuni (void) close(fd);
1432dcc6e752SPedro Giffuni return eRet;
1433dcc6e752SPedro Giffuni }
1434dcc6e752SPedro Giffuni }
1435cdf0e10cSrcweir
1436dcc6e752SPedro Giffuni /* get file status (mode, size) */
1437dcc6e752SPedro Giffuni struct stat aFileStat;
1438dcc6e752SPedro Giffuni if (-1 == fstat (fd, &aFileStat))
1439dcc6e752SPedro Giffuni {
1440dcc6e752SPedro Giffuni eRet = oslTranslateFileError (OSL_FET_ERROR, errno);
1441dcc6e752SPedro Giffuni (void) close(fd);
1442cdf0e10cSrcweir return eRet;
1443dcc6e752SPedro Giffuni }
1444dcc6e752SPedro Giffuni if (!S_ISREG(aFileStat.st_mode))
1445dcc6e752SPedro Giffuni {
1446dcc6e752SPedro Giffuni /* we only open regular files here */
1447dcc6e752SPedro Giffuni (void) close(fd);
1448dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1449dcc6e752SPedro Giffuni }
1450cdf0e10cSrcweir
1451dcc6e752SPedro Giffuni if (osl_file_queryLocking (uFlags))
1452cdf0e10cSrcweir {
1453dcc6e752SPedro Giffuni #ifdef MACOSX
1454dcc6e752SPedro Giffuni if (-1 == flock (fd, LOCK_EX | LOCK_NB))
1455cdf0e10cSrcweir {
1456dcc6e752SPedro Giffuni /* Mac OSX returns ENOTSUP for webdav drives. We should try read lock */
1457dcc6e752SPedro Giffuni if ((errno != ENOTSUP) || ((-1 == flock (fd, LOCK_SH | LOCK_NB)) && (errno != ENOTSUP)))
1458cdf0e10cSrcweir {
1459dcc6e752SPedro Giffuni eRet = oslTranslateFileError (OSL_FET_ERROR, errno);
1460dcc6e752SPedro Giffuni (void) close(fd);
1461dcc6e752SPedro Giffuni return eRet;
1462cdf0e10cSrcweir }
1463dcc6e752SPedro Giffuni }
1464dcc6e752SPedro Giffuni #else /* F_SETLK */
1465dcc6e752SPedro Giffuni {
1466dcc6e752SPedro Giffuni struct flock aflock;
1467cdf0e10cSrcweir
1468dcc6e752SPedro Giffuni aflock.l_type = F_WRLCK;
1469dcc6e752SPedro Giffuni aflock.l_whence = SEEK_SET;
1470dcc6e752SPedro Giffuni aflock.l_start = 0;
1471dcc6e752SPedro Giffuni aflock.l_len = 0;
1472dcc6e752SPedro Giffuni
1473dcc6e752SPedro Giffuni if (-1 == fcntl (fd, F_SETLK, &aflock))
1474cdf0e10cSrcweir {
1475dcc6e752SPedro Giffuni eRet = oslTranslateFileError (OSL_FET_ERROR, errno);
1476dcc6e752SPedro Giffuni (void) close(fd);
1477dcc6e752SPedro Giffuni return eRet;
1478cdf0e10cSrcweir }
1479cdf0e10cSrcweir }
1480dcc6e752SPedro Giffuni #endif /* F_SETLK */
1481dcc6e752SPedro Giffuni }
1482cdf0e10cSrcweir
1483dcc6e752SPedro Giffuni /* allocate memory for impl structure */
1484dcc6e752SPedro Giffuni FileHandle_Impl * pImpl = new FileHandle_Impl (fd, buffer);
1485dcc6e752SPedro Giffuni if (!pImpl)
1486dcc6e752SPedro Giffuni {
1487dcc6e752SPedro Giffuni eRet = oslTranslateFileError (OSL_FET_ERROR, ENOMEM);
1488dcc6e752SPedro Giffuni (void) close(fd);
1489dcc6e752SPedro Giffuni return eRet;
1490dcc6e752SPedro Giffuni }
1491dcc6e752SPedro Giffuni if (flags & O_RDWR)
1492dcc6e752SPedro Giffuni pImpl->m_state |= FileHandle_Impl::STATE_WRITEABLE;
1493dcc6e752SPedro Giffuni pImpl->m_size = sal::static_int_cast< sal_uInt64 >(aFileStat.st_size);
1494cdf0e10cSrcweir
1495dcc6e752SPedro Giffuni OSL_TRACE("osl_openFile(%d, %s) => %s", pImpl->m_fd,
1496dcc6e752SPedro Giffuni flags & O_RDWR ? "writeable":"readonly",
1497dcc6e752SPedro Giffuni rtl_string_getStr(pImpl->m_strFilePath));
1498cdf0e10cSrcweir
1499dcc6e752SPedro Giffuni *pHandle = (oslFileHandle)(pImpl);
1500dcc6e752SPedro Giffuni return osl_File_E_None;
1501dcc6e752SPedro Giffuni }
1502cdf0e10cSrcweir
1503dcc6e752SPedro Giffuni /****************************************************************************/
1504dcc6e752SPedro Giffuni /* osl_closeFile */
1505dcc6e752SPedro Giffuni /****************************************************************************/
1506dcc6e752SPedro Giffuni oslFileError
osl_closeFile(oslFileHandle Handle)1507dcc6e752SPedro Giffuni SAL_CALL osl_closeFile( oslFileHandle Handle )
1508dcc6e752SPedro Giffuni {
1509dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1510cdf0e10cSrcweir
1511dcc6e752SPedro Giffuni if ((pImpl == 0) || (pImpl->m_fd < 0))
1512dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1513cdf0e10cSrcweir
1514dcc6e752SPedro Giffuni /* close(2) implicitly (and unconditionally) unlocks */
1515dcc6e752SPedro Giffuni OSL_TRACE("osl_closeFile(%d) => %s", pImpl->m_fd, rtl_string_getStr(pImpl->m_strFilePath));
1516dcc6e752SPedro Giffuni oslFileError result = pImpl->syncFile();
1517dcc6e752SPedro Giffuni if (result != osl_File_E_None)
1518dcc6e752SPedro Giffuni {
1519dcc6e752SPedro Giffuni /* close, ignoring double failure */
1520dcc6e752SPedro Giffuni (void) close (pImpl->m_fd);
1521dcc6e752SPedro Giffuni }
1522dcc6e752SPedro Giffuni else if (-1 == close (pImpl->m_fd))
1523dcc6e752SPedro Giffuni {
1524dcc6e752SPedro Giffuni /* translate error code */
1525dcc6e752SPedro Giffuni result = oslTranslateFileError (OSL_FET_ERROR, errno);
1526dcc6e752SPedro Giffuni }
1527cdf0e10cSrcweir
1528dcc6e752SPedro Giffuni delete pImpl;
1529dcc6e752SPedro Giffuni return (result);
1530dcc6e752SPedro Giffuni }
1531cdf0e10cSrcweir
1532dcc6e752SPedro Giffuni /************************************************
1533dcc6e752SPedro Giffuni * osl_syncFile
1534dcc6e752SPedro Giffuni ***********************************************/
1535dcc6e752SPedro Giffuni oslFileError
osl_syncFile(oslFileHandle Handle)1536dcc6e752SPedro Giffuni SAL_CALL osl_syncFile(oslFileHandle Handle)
1537dcc6e752SPedro Giffuni {
1538dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1539dcc6e752SPedro Giffuni
1540dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd))
1541dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1542cdf0e10cSrcweir
1543dcc6e752SPedro Giffuni OSL_FILE_TRACE("osl_syncFile(%d)", pImpl->m_fd);
1544dcc6e752SPedro Giffuni oslFileError result = pImpl->syncFile();
1545dcc6e752SPedro Giffuni if (result != osl_File_E_None)
1546dcc6e752SPedro Giffuni return (result);
1547dcc6e752SPedro Giffuni if (-1 == fsync (pImpl->m_fd))
1548dcc6e752SPedro Giffuni return oslTranslateFileError (OSL_FET_ERROR, errno);
1549dcc6e752SPedro Giffuni
1550dcc6e752SPedro Giffuni return osl_File_E_None;
1551dcc6e752SPedro Giffuni }
1552cdf0e10cSrcweir
1553dcc6e752SPedro Giffuni /*******************************************
1554dcc6e752SPedro Giffuni osl_mapFile
1555dcc6e752SPedro Giffuni ********************************************/
1556dcc6e752SPedro Giffuni oslFileError
osl_mapFile(oslFileHandle Handle,void ** ppAddr,sal_uInt64 uLength,sal_uInt64 uOffset,sal_uInt32 uFlags)1557dcc6e752SPedro Giffuni SAL_CALL osl_mapFile (
1558dcc6e752SPedro Giffuni oslFileHandle Handle,
1559dcc6e752SPedro Giffuni void** ppAddr,
1560dcc6e752SPedro Giffuni sal_uInt64 uLength,
1561dcc6e752SPedro Giffuni sal_uInt64 uOffset,
1562dcc6e752SPedro Giffuni sal_uInt32 uFlags
1563dcc6e752SPedro Giffuni )
1564dcc6e752SPedro Giffuni {
1565dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1566cdf0e10cSrcweir
1567dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == ppAddr))
1568dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1569dcc6e752SPedro Giffuni *ppAddr = 0;
1570dcc6e752SPedro Giffuni
1571dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_size_t = std::numeric_limits< size_t >::max();
1572dcc6e752SPedro Giffuni if (g_limit_size_t < uLength)
1573dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1574dcc6e752SPedro Giffuni size_t const nLength = sal::static_int_cast< size_t >(uLength);
1575dcc6e752SPedro Giffuni
1576dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1577dcc6e752SPedro Giffuni if (g_limit_off_t < uOffset)
1578dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1579dcc6e752SPedro Giffuni off_t const nOffset = sal::static_int_cast< off_t >(uOffset);
1580dcc6e752SPedro Giffuni
1581dcc6e752SPedro Giffuni #ifdef SAL_OS2 // YD mmap does not support shared
1582dcc6e752SPedro Giffuni void* p = mmap(NULL, nLength, PROT_READ, MAP_PRIVATE, pImpl->m_fd, nOffset);
1583dcc6e752SPedro Giffuni #else
1584dcc6e752SPedro Giffuni void* p = mmap(NULL, nLength, PROT_READ, MAP_SHARED, pImpl->m_fd, nOffset);
1585dcc6e752SPedro Giffuni #endif
1586dcc6e752SPedro Giffuni if (MAP_FAILED == p)
1587dcc6e752SPedro Giffuni return oslTranslateFileError(OSL_FET_ERROR, errno);
1588dcc6e752SPedro Giffuni *ppAddr = p;
1589dcc6e752SPedro Giffuni
1590dcc6e752SPedro Giffuni if (uFlags & osl_File_MapFlag_RandomAccess)
1591dcc6e752SPedro Giffuni {
1592dcc6e752SPedro Giffuni // Determine memory pagesize.
1593dcc6e752SPedro Giffuni size_t const nPageSize = FileHandle_Impl::getpagesize();
1594dcc6e752SPedro Giffuni if (size_t(-1) != nPageSize)
1595dcc6e752SPedro Giffuni {
1596dcc6e752SPedro Giffuni /*
1597dcc6e752SPedro Giffuni * Pagein, touching first byte of every memory page.
1598dcc6e752SPedro Giffuni * Note: volatile disables optimizing the loop away.
1599dcc6e752SPedro Giffuni */
1600dcc6e752SPedro Giffuni sal_uInt8 * pData (reinterpret_cast<sal_uInt8*>(*ppAddr));
1601dcc6e752SPedro Giffuni size_t nSize (nLength);
1602dcc6e752SPedro Giffuni
1603dcc6e752SPedro Giffuni volatile sal_uInt8 c = 0;
1604dcc6e752SPedro Giffuni while (nSize > nPageSize)
1605dcc6e752SPedro Giffuni {
1606dcc6e752SPedro Giffuni c ^= pData[0];
1607dcc6e752SPedro Giffuni pData += nPageSize;
1608dcc6e752SPedro Giffuni nSize -= nPageSize;
1609dcc6e752SPedro Giffuni }
1610dcc6e752SPedro Giffuni if (nSize > 0)
1611dcc6e752SPedro Giffuni {
1612dcc6e752SPedro Giffuni c^= pData[0];
1613dcc6e752SPedro Giffuni pData += nSize;
1614dcc6e752SPedro Giffuni nSize -= nSize;
1615dcc6e752SPedro Giffuni }
1616dcc6e752SPedro Giffuni }
1617dcc6e752SPedro Giffuni }
1618dcc6e752SPedro Giffuni return osl_File_E_None;
1619cdf0e10cSrcweir }
1620cdf0e10cSrcweir
1621dcc6e752SPedro Giffuni /*******************************************
1622dcc6e752SPedro Giffuni osl_unmapFile
1623dcc6e752SPedro Giffuni ********************************************/
1624dcc6e752SPedro Giffuni oslFileError
osl_unmapFile(void * pAddr,sal_uInt64 uLength)1625dcc6e752SPedro Giffuni SAL_CALL osl_unmapFile (void* pAddr, sal_uInt64 uLength)
1626dcc6e752SPedro Giffuni {
1627dcc6e752SPedro Giffuni if (0 == pAddr)
1628dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1629dcc6e752SPedro Giffuni
1630dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_size_t = std::numeric_limits< size_t >::max();
1631dcc6e752SPedro Giffuni if (g_limit_size_t < uLength)
1632dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1633dcc6e752SPedro Giffuni size_t const nLength = sal::static_int_cast< size_t >(uLength);
1634dcc6e752SPedro Giffuni
1635dcc6e752SPedro Giffuni if (-1 == munmap(static_cast<char*>(pAddr), nLength))
1636dcc6e752SPedro Giffuni return oslTranslateFileError(OSL_FET_ERROR, errno);
1637cdf0e10cSrcweir
1638dcc6e752SPedro Giffuni return osl_File_E_None;
1639dcc6e752SPedro Giffuni }
1640dcc6e752SPedro Giffuni
1641dcc6e752SPedro Giffuni /*******************************************
1642dcc6e752SPedro Giffuni osl_readLine
1643dcc6e752SPedro Giffuni ********************************************/
1644dcc6e752SPedro Giffuni oslFileError
osl_readLine(oslFileHandle Handle,sal_Sequence ** ppSequence)1645dcc6e752SPedro Giffuni SAL_CALL osl_readLine (
1646dcc6e752SPedro Giffuni oslFileHandle Handle,
1647dcc6e752SPedro Giffuni sal_Sequence ** ppSequence)
1648cdf0e10cSrcweir {
1649dcc6e752SPedro Giffuni FileHandle_Impl * pImpl = static_cast<FileHandle_Impl*>(Handle);
1650cdf0e10cSrcweir
1651dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == ppSequence))
1652dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1653dcc6e752SPedro Giffuni sal_uInt64 uBytesRead = 0;
1654cdf0e10cSrcweir
1655dcc6e752SPedro Giffuni // read at current fileptr; fileptr += uBytesRead;
1656dcc6e752SPedro Giffuni oslFileError result = pImpl->readLineAt (
1657dcc6e752SPedro Giffuni pImpl->m_fileptr, ppSequence, &uBytesRead);
1658dcc6e752SPedro Giffuni if (result == osl_File_E_None)
1659dcc6e752SPedro Giffuni pImpl->m_fileptr += uBytesRead;
1660dcc6e752SPedro Giffuni return (result);
1661dcc6e752SPedro Giffuni }
1662cdf0e10cSrcweir
1663dcc6e752SPedro Giffuni /*******************************************
1664dcc6e752SPedro Giffuni osl_readFile
1665dcc6e752SPedro Giffuni ********************************************/
1666dcc6e752SPedro Giffuni oslFileError
osl_readFile(oslFileHandle Handle,void * pBuffer,sal_uInt64 uBytesRequested,sal_uInt64 * pBytesRead)1667dcc6e752SPedro Giffuni SAL_CALL osl_readFile (
1668dcc6e752SPedro Giffuni oslFileHandle Handle,
1669dcc6e752SPedro Giffuni void * pBuffer,
1670dcc6e752SPedro Giffuni sal_uInt64 uBytesRequested,
1671dcc6e752SPedro Giffuni sal_uInt64 * pBytesRead)
1672dcc6e752SPedro Giffuni {
1673dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1674cdf0e10cSrcweir
1675dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == pBuffer) || (0 == pBytesRead))
1676dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1677dcc6e752SPedro Giffuni
1678dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_ssize_t = std::numeric_limits< ssize_t >::max();
1679dcc6e752SPedro Giffuni if (g_limit_ssize_t < uBytesRequested)
1680dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1681dcc6e752SPedro Giffuni size_t const nBytesRequested = sal::static_int_cast< size_t >(uBytesRequested);
1682cdf0e10cSrcweir
1683dcc6e752SPedro Giffuni // read at current fileptr; fileptr += *pBytesRead;
1684dcc6e752SPedro Giffuni oslFileError result = pImpl->readFileAt (
1685dcc6e752SPedro Giffuni pImpl->m_fileptr, pBuffer, nBytesRequested, pBytesRead);
1686dcc6e752SPedro Giffuni if (result == osl_File_E_None)
1687dcc6e752SPedro Giffuni pImpl->m_fileptr += *pBytesRead;
1688dcc6e752SPedro Giffuni return (result);
1689dcc6e752SPedro Giffuni }
1690cdf0e10cSrcweir
1691dcc6e752SPedro Giffuni /*******************************************
1692dcc6e752SPedro Giffuni osl_writeFile
1693dcc6e752SPedro Giffuni ********************************************/
1694dcc6e752SPedro Giffuni oslFileError
osl_writeFile(oslFileHandle Handle,const void * pBuffer,sal_uInt64 uBytesToWrite,sal_uInt64 * pBytesWritten)1695dcc6e752SPedro Giffuni SAL_CALL osl_writeFile (
1696dcc6e752SPedro Giffuni oslFileHandle Handle,
1697dcc6e752SPedro Giffuni const void * pBuffer,
1698dcc6e752SPedro Giffuni sal_uInt64 uBytesToWrite,
1699dcc6e752SPedro Giffuni sal_uInt64 * pBytesWritten)
1700dcc6e752SPedro Giffuni {
1701dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1702cdf0e10cSrcweir
1703dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == pBuffer) || (0 == pBytesWritten))
1704dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1705dcc6e752SPedro Giffuni if (0 == (pImpl->m_state & FileHandle_Impl::STATE_WRITEABLE))
1706dcc6e752SPedro Giffuni return osl_File_E_BADF;
1707cdf0e10cSrcweir
1708dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_ssize_t = std::numeric_limits< ssize_t >::max();
1709dcc6e752SPedro Giffuni if (g_limit_ssize_t < uBytesToWrite)
1710dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1711dcc6e752SPedro Giffuni size_t const nBytesToWrite = sal::static_int_cast< size_t >(uBytesToWrite);
1712cdf0e10cSrcweir
1713dcc6e752SPedro Giffuni // write at current fileptr; fileptr += *pBytesWritten;
1714dcc6e752SPedro Giffuni oslFileError result = pImpl->writeFileAt (
1715dcc6e752SPedro Giffuni pImpl->m_fileptr, pBuffer, nBytesToWrite, pBytesWritten);
1716dcc6e752SPedro Giffuni if (result == osl_File_E_None)
1717dcc6e752SPedro Giffuni pImpl->m_fileptr += *pBytesWritten;
1718dcc6e752SPedro Giffuni return (result);
1719dcc6e752SPedro Giffuni }
1720dcc6e752SPedro Giffuni
1721dcc6e752SPedro Giffuni /*******************************************
1722dcc6e752SPedro Giffuni osl_readFileAt
1723dcc6e752SPedro Giffuni ********************************************/
1724dcc6e752SPedro Giffuni oslFileError
osl_readFileAt(oslFileHandle Handle,sal_uInt64 uOffset,void * pBuffer,sal_uInt64 uBytesRequested,sal_uInt64 * pBytesRead)1725dcc6e752SPedro Giffuni SAL_CALL osl_readFileAt (
1726dcc6e752SPedro Giffuni oslFileHandle Handle,
1727dcc6e752SPedro Giffuni sal_uInt64 uOffset,
1728dcc6e752SPedro Giffuni void* pBuffer,
1729dcc6e752SPedro Giffuni sal_uInt64 uBytesRequested,
1730dcc6e752SPedro Giffuni sal_uInt64* pBytesRead)
1731dcc6e752SPedro Giffuni {
1732dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1733dcc6e752SPedro Giffuni
1734dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == pBuffer) || (0 == pBytesRead))
1735dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1736dcc6e752SPedro Giffuni if (0 == (pImpl->m_state & FileHandle_Impl::STATE_SEEKABLE))
1737dcc6e752SPedro Giffuni return osl_File_E_SPIPE;
1738dcc6e752SPedro Giffuni
1739dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1740dcc6e752SPedro Giffuni if (g_limit_off_t < uOffset)
1741dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1742dcc6e752SPedro Giffuni off_t const nOffset = sal::static_int_cast< off_t >(uOffset);
1743dcc6e752SPedro Giffuni
1744dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_ssize_t = std::numeric_limits< ssize_t >::max();
1745dcc6e752SPedro Giffuni if (g_limit_ssize_t < uBytesRequested)
1746dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1747dcc6e752SPedro Giffuni size_t const nBytesRequested = sal::static_int_cast< size_t >(uBytesRequested);
1748dcc6e752SPedro Giffuni
1749dcc6e752SPedro Giffuni // read at specified fileptr
1750dcc6e752SPedro Giffuni return pImpl->readFileAt (nOffset, pBuffer, nBytesRequested, pBytesRead);
1751dcc6e752SPedro Giffuni }
1752dcc6e752SPedro Giffuni
1753dcc6e752SPedro Giffuni /*******************************************
1754dcc6e752SPedro Giffuni osl_writeFileAt
1755dcc6e752SPedro Giffuni ********************************************/
1756dcc6e752SPedro Giffuni oslFileError
osl_writeFileAt(oslFileHandle Handle,sal_uInt64 uOffset,const void * pBuffer,sal_uInt64 uBytesToWrite,sal_uInt64 * pBytesWritten)1757dcc6e752SPedro Giffuni SAL_CALL osl_writeFileAt (
1758dcc6e752SPedro Giffuni oslFileHandle Handle,
1759dcc6e752SPedro Giffuni sal_uInt64 uOffset,
1760dcc6e752SPedro Giffuni const void* pBuffer,
1761dcc6e752SPedro Giffuni sal_uInt64 uBytesToWrite,
1762dcc6e752SPedro Giffuni sal_uInt64* pBytesWritten)
1763dcc6e752SPedro Giffuni {
1764dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1765dcc6e752SPedro Giffuni
1766dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == pBuffer) || (0 == pBytesWritten))
1767dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1768dcc6e752SPedro Giffuni if (0 == (pImpl->m_state & FileHandle_Impl::STATE_SEEKABLE))
1769dcc6e752SPedro Giffuni return osl_File_E_SPIPE;
1770dcc6e752SPedro Giffuni if (0 == (pImpl->m_state & FileHandle_Impl::STATE_WRITEABLE))
1771dcc6e752SPedro Giffuni return osl_File_E_BADF;
1772dcc6e752SPedro Giffuni
1773dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1774dcc6e752SPedro Giffuni if (g_limit_off_t < uOffset)
1775dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1776dcc6e752SPedro Giffuni off_t const nOffset = sal::static_int_cast< off_t >(uOffset);
1777dcc6e752SPedro Giffuni
1778dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_ssize_t = std::numeric_limits< ssize_t >::max();
1779dcc6e752SPedro Giffuni if (g_limit_ssize_t < uBytesToWrite)
1780dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1781dcc6e752SPedro Giffuni size_t const nBytesToWrite = sal::static_int_cast< size_t >(uBytesToWrite);
1782dcc6e752SPedro Giffuni
1783dcc6e752SPedro Giffuni // write at specified fileptr
1784dcc6e752SPedro Giffuni return pImpl->writeFileAt (nOffset, pBuffer, nBytesToWrite, pBytesWritten);
1785cdf0e10cSrcweir }
1786cdf0e10cSrcweir
1787cdf0e10cSrcweir /****************************************************************************/
1788cdf0e10cSrcweir /* osl_isEndOfFile */
1789cdf0e10cSrcweir /****************************************************************************/
1790dcc6e752SPedro Giffuni oslFileError
osl_isEndOfFile(oslFileHandle Handle,sal_Bool * pIsEOF)1791dcc6e752SPedro Giffuni SAL_CALL osl_isEndOfFile( oslFileHandle Handle, sal_Bool *pIsEOF )
1792dcc6e752SPedro Giffuni {
1793dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1794dcc6e752SPedro Giffuni
1795dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == pIsEOF))
1796dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1797cdf0e10cSrcweir
1798dcc6e752SPedro Giffuni *pIsEOF = (pImpl->getPos() == pImpl->getSize());
1799dcc6e752SPedro Giffuni return osl_File_E_None;
1800dcc6e752SPedro Giffuni }
1801dcc6e752SPedro Giffuni
1802dcc6e752SPedro Giffuni /************************************************
1803dcc6e752SPedro Giffuni * osl_getFilePos
1804dcc6e752SPedro Giffuni ***********************************************/
1805dcc6e752SPedro Giffuni oslFileError
osl_getFilePos(oslFileHandle Handle,sal_uInt64 * pPos)1806dcc6e752SPedro Giffuni SAL_CALL osl_getFilePos( oslFileHandle Handle, sal_uInt64* pPos )
1807cdf0e10cSrcweir {
1808dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1809cdf0e10cSrcweir
1810dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == pPos))
1811dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1812cdf0e10cSrcweir
1813dcc6e752SPedro Giffuni *pPos = pImpl->getPos();
1814dcc6e752SPedro Giffuni return osl_File_E_None;
1815dcc6e752SPedro Giffuni }
1816cdf0e10cSrcweir
1817dcc6e752SPedro Giffuni /*******************************************
1818dcc6e752SPedro Giffuni osl_setFilePos
1819dcc6e752SPedro Giffuni ********************************************/
1820dcc6e752SPedro Giffuni oslFileError
osl_setFilePos(oslFileHandle Handle,sal_uInt32 uHow,sal_Int64 uOffset)1821dcc6e752SPedro Giffuni SAL_CALL osl_setFilePos (oslFileHandle Handle, sal_uInt32 uHow, sal_Int64 uOffset)
1822dcc6e752SPedro Giffuni {
1823dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1824cdf0e10cSrcweir
1825dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd))
1826dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1827dcc6e752SPedro Giffuni
1828dcc6e752SPedro Giffuni static sal_Int64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1829dcc6e752SPedro Giffuni if (g_limit_off_t < uOffset)
1830dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1831dcc6e752SPedro Giffuni off_t nPos = 0, nOffset = sal::static_int_cast< off_t >(uOffset);
1832dcc6e752SPedro Giffuni
1833dcc6e752SPedro Giffuni switch(uHow)
1834dcc6e752SPedro Giffuni {
1835dcc6e752SPedro Giffuni case osl_Pos_Absolut:
1836dcc6e752SPedro Giffuni if (0 > nOffset)
1837dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1838dcc6e752SPedro Giffuni break;
1839dcc6e752SPedro Giffuni
1840dcc6e752SPedro Giffuni case osl_Pos_Current:
1841dcc6e752SPedro Giffuni nPos = sal::static_int_cast< off_t >(pImpl->getPos());
1842dcc6e752SPedro Giffuni if ((0 > nOffset) && (-1*nOffset > nPos))
1843dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1844dcc6e752SPedro Giffuni if (g_limit_off_t < nPos + nOffset)
1845dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1846dcc6e752SPedro Giffuni break;
1847dcc6e752SPedro Giffuni
1848dcc6e752SPedro Giffuni case osl_Pos_End:
1849dcc6e752SPedro Giffuni nPos = sal::static_int_cast< off_t >(pImpl->getSize());
1850dcc6e752SPedro Giffuni if ((0 > nOffset) && (-1*nOffset > nPos))
1851dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1852dcc6e752SPedro Giffuni if (g_limit_off_t < nPos + nOffset)
1853dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1854dcc6e752SPedro Giffuni break;
1855dcc6e752SPedro Giffuni
1856dcc6e752SPedro Giffuni default:
1857dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1858dcc6e752SPedro Giffuni }
1859dcc6e752SPedro Giffuni
1860dcc6e752SPedro Giffuni return pImpl->setPos (nPos + nOffset);
1861dcc6e752SPedro Giffuni }
1862cdf0e10cSrcweir
1863dcc6e752SPedro Giffuni /****************************************************************************
1864dcc6e752SPedro Giffuni * osl_getFileSize
1865dcc6e752SPedro Giffuni ****************************************************************************/
1866dcc6e752SPedro Giffuni oslFileError
osl_getFileSize(oslFileHandle Handle,sal_uInt64 * pSize)1867dcc6e752SPedro Giffuni SAL_CALL osl_getFileSize( oslFileHandle Handle, sal_uInt64* pSize )
1868dcc6e752SPedro Giffuni {
1869dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1870dcc6e752SPedro Giffuni
1871dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd) || (0 == pSize))
1872dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1873dcc6e752SPedro Giffuni
1874dcc6e752SPedro Giffuni *pSize = pImpl->getSize();
1875dcc6e752SPedro Giffuni return osl_File_E_None;
1876cdf0e10cSrcweir }
1877cdf0e10cSrcweir
1878dcc6e752SPedro Giffuni /************************************************
1879dcc6e752SPedro Giffuni * osl_setFileSize
1880dcc6e752SPedro Giffuni ***********************************************/
1881dcc6e752SPedro Giffuni oslFileError
osl_setFileSize(oslFileHandle Handle,sal_uInt64 uSize)1882dcc6e752SPedro Giffuni SAL_CALL osl_setFileSize( oslFileHandle Handle, sal_uInt64 uSize )
1883dcc6e752SPedro Giffuni {
1884dcc6e752SPedro Giffuni FileHandle_Impl* pImpl = static_cast<FileHandle_Impl*>(Handle);
1885dcc6e752SPedro Giffuni
1886dcc6e752SPedro Giffuni if ((0 == pImpl) || (-1 == pImpl->m_fd))
1887dcc6e752SPedro Giffuni return osl_File_E_INVAL;
1888dcc6e752SPedro Giffuni if (0 == (pImpl->m_state & FileHandle_Impl::STATE_WRITEABLE))
1889dcc6e752SPedro Giffuni return osl_File_E_BADF;
1890dcc6e752SPedro Giffuni
1891dcc6e752SPedro Giffuni static sal_uInt64 const g_limit_off_t = std::numeric_limits< off_t >::max();
1892dcc6e752SPedro Giffuni if (g_limit_off_t < uSize)
1893dcc6e752SPedro Giffuni return osl_File_E_OVERFLOW;
1894dcc6e752SPedro Giffuni
1895dcc6e752SPedro Giffuni oslFileError result = pImpl->syncFile();
1896dcc6e752SPedro Giffuni if (result != osl_File_E_None)
1897dcc6e752SPedro Giffuni return (result);
1898dcc6e752SPedro Giffuni pImpl->m_bufptr = -1, pImpl->m_buflen = 0;
1899dcc6e752SPedro Giffuni
1900dcc6e752SPedro Giffuni return pImpl->setSize (uSize);
1901dcc6e752SPedro Giffuni }
1902cdf0e10cSrcweir
1903cdf0e10cSrcweir /****************************************************************************/
1904cdf0e10cSrcweir /* osl_moveFile */
1905cdf0e10cSrcweir /****************************************************************************/
1906cdf0e10cSrcweir
osl_moveFile(rtl_uString * ustrFileURL,rtl_uString * ustrDestURL)1907cdf0e10cSrcweir oslFileError osl_moveFile( rtl_uString* ustrFileURL, rtl_uString* ustrDestURL )
1908cdf0e10cSrcweir {
1909cdf0e10cSrcweir char srcPath[PATH_MAX];
1910cdf0e10cSrcweir char destPath[PATH_MAX];
1911cdf0e10cSrcweir oslFileError eRet;
1912cdf0e10cSrcweir APIRET rc;
1913cdf0e10cSrcweir
1914cdf0e10cSrcweir OSL_ASSERT( ustrFileURL );
1915cdf0e10cSrcweir OSL_ASSERT( ustrDestURL );
1916cdf0e10cSrcweir
1917cdf0e10cSrcweir /* convert source url to system path */
1918cdf0e10cSrcweir eRet = FileURLToPath( srcPath, PATH_MAX, ustrFileURL );
1919cdf0e10cSrcweir if( eRet != osl_File_E_None )
1920cdf0e10cSrcweir return eRet;
1921cdf0e10cSrcweir
1922cdf0e10cSrcweir /* convert destination url to system path */
1923cdf0e10cSrcweir eRet = FileURLToPath( destPath, PATH_MAX, ustrDestURL );
1924cdf0e10cSrcweir if( eRet != osl_File_E_None )
1925cdf0e10cSrcweir return eRet;
1926cdf0e10cSrcweir
1927cdf0e10cSrcweir //YD 01/05/06 rename() can overwrite existing files.
1928cdf0e10cSrcweir rc = DosDelete( (PCSZ)destPath);
1929cdf0e10cSrcweir rc = DosMove( (PCSZ)srcPath, (PCSZ)destPath);
1930cdf0e10cSrcweir if (!rc)
1931cdf0e10cSrcweir eRet = osl_File_E_None;
1932cdf0e10cSrcweir else
1933cdf0e10cSrcweir eRet = MapError( rc);
1934cdf0e10cSrcweir
1935cdf0e10cSrcweir return eRet;
1936cdf0e10cSrcweir }
1937cdf0e10cSrcweir
1938cdf0e10cSrcweir /****************************************************************************/
1939cdf0e10cSrcweir /* osl_copyFile */
1940cdf0e10cSrcweir /****************************************************************************/
1941cdf0e10cSrcweir
1942cdf0e10cSrcweir #define TMP_DEST_FILE_EXTENSION ".osl-tmp"
1943cdf0e10cSrcweir
oslDoCopy(const sal_Char * pszSourceFileName,const sal_Char * pszDestFileName,mode_t nMode,size_t nSourceSize,int DestFileExists)1944cdf0e10cSrcweir static oslFileError oslDoCopy(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, mode_t nMode, size_t nSourceSize, int DestFileExists)
1945cdf0e10cSrcweir {
1946cdf0e10cSrcweir int nRet=0;
1947cdf0e10cSrcweir sal_Char pszTmpDestFile[PATH_MAX];
1948cdf0e10cSrcweir size_t size_tmp_dest_buff = sizeof(pszTmpDestFile);
1949cdf0e10cSrcweir
1950cdf0e10cSrcweir /* Quick fix for #106048, the whole copy file function seems
1951cdf0e10cSrcweir to be erroneous anyway and needs to be rewritten.
1952cdf0e10cSrcweir Besides osl_copyFile is currently not used from OO/SO code.
1953cdf0e10cSrcweir */
1954cdf0e10cSrcweir memset(pszTmpDestFile, 0, size_tmp_dest_buff);
1955cdf0e10cSrcweir
1956cdf0e10cSrcweir if ( DestFileExists )
1957cdf0e10cSrcweir {
1958cdf0e10cSrcweir strncpy(pszTmpDestFile, pszDestFileName, size_tmp_dest_buff - 1);
1959cdf0e10cSrcweir
1960cdf0e10cSrcweir if ((strlen(pszTmpDestFile) + strlen(TMP_DEST_FILE_EXTENSION)) >= size_tmp_dest_buff)
1961cdf0e10cSrcweir return osl_File_E_NAMETOOLONG;
1962cdf0e10cSrcweir
1963cdf0e10cSrcweir strncat(pszTmpDestFile, TMP_DEST_FILE_EXTENSION, strlen(TMP_DEST_FILE_EXTENSION));
1964cdf0e10cSrcweir
1965cdf0e10cSrcweir /* FIXME: what if pszTmpDestFile already exists? */
1966cdf0e10cSrcweir /* with getcanonical??? */
1967cdf0e10cSrcweir nRet=rename(pszDestFileName,pszTmpDestFile);
1968cdf0e10cSrcweir }
1969cdf0e10cSrcweir
1970cdf0e10cSrcweir /* mfe: should be S_ISREG */
1971cdf0e10cSrcweir if ( !S_ISLNK(nMode) )
1972cdf0e10cSrcweir {
1973cdf0e10cSrcweir /* copy SourceFile to DestFile */
1974cdf0e10cSrcweir nRet = oslDoCopyFile(pszSourceFileName,pszDestFileName,nSourceSize, nMode);
1975cdf0e10cSrcweir }
1976cdf0e10cSrcweir /* mfe: OK redundant at the moment */
1977cdf0e10cSrcweir else if ( S_ISLNK(nMode) )
1978cdf0e10cSrcweir {
1979cdf0e10cSrcweir nRet = oslDoCopyLink(pszSourceFileName,pszDestFileName);
1980cdf0e10cSrcweir }
1981cdf0e10cSrcweir else
1982cdf0e10cSrcweir {
1983cdf0e10cSrcweir /* mfe: what to do here? */
1984cdf0e10cSrcweir nRet=ENOSYS;
1985cdf0e10cSrcweir }
1986cdf0e10cSrcweir
1987cdf0e10cSrcweir if ( nRet > 0 && DestFileExists == 1 )
1988cdf0e10cSrcweir {
1989cdf0e10cSrcweir unlink(pszDestFileName);
1990cdf0e10cSrcweir rename(pszTmpDestFile,pszDestFileName);
1991cdf0e10cSrcweir }
1992cdf0e10cSrcweir
1993cdf0e10cSrcweir if ( nRet > 0 )
1994cdf0e10cSrcweir {
1995cdf0e10cSrcweir return oslTranslateFileError(OSL_FET_ERROR, nRet);
1996cdf0e10cSrcweir }
1997cdf0e10cSrcweir
1998cdf0e10cSrcweir if ( DestFileExists == 1 )
1999cdf0e10cSrcweir {
2000cdf0e10cSrcweir unlink(pszTmpDestFile);
2001cdf0e10cSrcweir }
2002cdf0e10cSrcweir
2003cdf0e10cSrcweir return osl_File_E_None;
2004cdf0e10cSrcweir }
2005cdf0e10cSrcweir
2006cdf0e10cSrcweir /*****************************************
2007cdf0e10cSrcweir * oslChangeFileModes
2008cdf0e10cSrcweir ****************************************/
2009cdf0e10cSrcweir
oslChangeFileModes(const sal_Char * pszFileName,mode_t nMode,time_t nAcTime,time_t nModTime,uid_t nUID,gid_t nGID)2010cdf0e10cSrcweir static oslFileError oslChangeFileModes( const sal_Char* pszFileName, mode_t nMode, time_t nAcTime, time_t nModTime, uid_t nUID, gid_t nGID)
2011cdf0e10cSrcweir {
2012cdf0e10cSrcweir int nRet=0;
2013cdf0e10cSrcweir struct utimbuf aTimeBuffer;
2014cdf0e10cSrcweir
2015cdf0e10cSrcweir nRet = chmod(pszFileName,nMode);
2016cdf0e10cSrcweir if ( nRet < 0 )
2017cdf0e10cSrcweir {
2018cdf0e10cSrcweir nRet=errno;
2019cdf0e10cSrcweir return oslTranslateFileError(OSL_FET_ERROR, nRet);
2020cdf0e10cSrcweir }
2021cdf0e10cSrcweir
2022cdf0e10cSrcweir aTimeBuffer.actime=nAcTime;
2023cdf0e10cSrcweir aTimeBuffer.modtime=nModTime;
2024cdf0e10cSrcweir nRet=utime(pszFileName,&aTimeBuffer);
2025cdf0e10cSrcweir if ( nRet < 0 )
2026cdf0e10cSrcweir {
2027cdf0e10cSrcweir nRet=errno;
2028cdf0e10cSrcweir return oslTranslateFileError(OSL_FET_ERROR, nRet);
2029cdf0e10cSrcweir }
2030cdf0e10cSrcweir
2031cdf0e10cSrcweir if ( nUID != getuid() )
2032cdf0e10cSrcweir {
2033cdf0e10cSrcweir nUID=getuid();
2034cdf0e10cSrcweir }
2035cdf0e10cSrcweir
2036cdf0e10cSrcweir nRet=chown(pszFileName,nUID,nGID);
2037cdf0e10cSrcweir if ( nRet < 0 )
2038cdf0e10cSrcweir {
2039cdf0e10cSrcweir nRet=errno;
2040cdf0e10cSrcweir
2041cdf0e10cSrcweir /* mfe: do not return an error here! */
2042cdf0e10cSrcweir /* return oslTranslateFileError(nRet);*/
2043cdf0e10cSrcweir }
2044cdf0e10cSrcweir
2045cdf0e10cSrcweir return osl_File_E_None;
2046cdf0e10cSrcweir }
2047cdf0e10cSrcweir
2048cdf0e10cSrcweir /*****************************************
2049cdf0e10cSrcweir * oslDoCopyLink
2050cdf0e10cSrcweir ****************************************/
2051cdf0e10cSrcweir
oslDoCopyLink(const sal_Char * pszSourceFileName,const sal_Char * pszDestFileName)2052cdf0e10cSrcweir static int oslDoCopyLink(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName)
2053cdf0e10cSrcweir {
2054cdf0e10cSrcweir int nRet=0;
2055cdf0e10cSrcweir
2056cdf0e10cSrcweir /* mfe: if dest file is symbolic link remove the link and place the file instead (hro says so) */
2057cdf0e10cSrcweir /* mfe: if source is a link copy the link and not the file it points to (hro says so) */
2058cdf0e10cSrcweir sal_Char pszLinkContent[PATH_MAX];
2059cdf0e10cSrcweir
2060cdf0e10cSrcweir pszLinkContent[0] = '\0';
2061cdf0e10cSrcweir
2062cdf0e10cSrcweir nRet = readlink(pszSourceFileName,pszLinkContent,PATH_MAX);
2063cdf0e10cSrcweir
2064cdf0e10cSrcweir if ( nRet < 0 )
2065cdf0e10cSrcweir {
2066cdf0e10cSrcweir nRet=errno;
2067cdf0e10cSrcweir return nRet;
2068cdf0e10cSrcweir }
2069cdf0e10cSrcweir else
2070cdf0e10cSrcweir pszLinkContent[ nRet ] = 0;
2071cdf0e10cSrcweir
2072cdf0e10cSrcweir nRet = symlink(pszLinkContent,pszDestFileName);
2073cdf0e10cSrcweir
2074cdf0e10cSrcweir if ( nRet < 0 )
2075cdf0e10cSrcweir {
2076cdf0e10cSrcweir nRet=errno;
2077cdf0e10cSrcweir return nRet;
2078cdf0e10cSrcweir }
2079cdf0e10cSrcweir
2080cdf0e10cSrcweir return 0;
2081cdf0e10cSrcweir }
2082cdf0e10cSrcweir
2083cdf0e10cSrcweir /*****************************************
2084cdf0e10cSrcweir * oslDoCopyFile
2085cdf0e10cSrcweir ****************************************/
2086cdf0e10cSrcweir
oslDoCopyFile(const sal_Char * pszSourceFileName,const sal_Char * pszDestFileName,size_t nSourceSize,mode_t mode)2087cdf0e10cSrcweir static int oslDoCopyFile(const sal_Char* pszSourceFileName, const sal_Char* pszDestFileName, size_t nSourceSize, mode_t mode)
2088cdf0e10cSrcweir {
2089cdf0e10cSrcweir int SourceFileFD=0;
2090cdf0e10cSrcweir int DestFileFD=0;
2091cdf0e10cSrcweir int nRet=0;
2092cdf0e10cSrcweir void* pSourceFile=0;
2093cdf0e10cSrcweir char buffer[ 4096];
2094cdf0e10cSrcweir
2095cdf0e10cSrcweir SourceFileFD=open(pszSourceFileName,O_RDONLY | O_BINARY);
2096cdf0e10cSrcweir if ( SourceFileFD < 0 )
2097cdf0e10cSrcweir {
2098cdf0e10cSrcweir nRet=errno;
2099cdf0e10cSrcweir return nRet;
2100cdf0e10cSrcweir }
2101cdf0e10cSrcweir
2102cdf0e10cSrcweir DestFileFD=open(pszDestFileName, O_WRONLY | O_CREAT | O_BINARY, mode);
2103cdf0e10cSrcweir if ( DestFileFD < 0 )
2104cdf0e10cSrcweir {
2105cdf0e10cSrcweir nRet=errno;
2106cdf0e10cSrcweir close(SourceFileFD);
2107cdf0e10cSrcweir return nRet;
2108cdf0e10cSrcweir }
2109cdf0e10cSrcweir
2110cdf0e10cSrcweir /* HACK: because memory mapping fails on various
2111cdf0e10cSrcweir platforms if the size of the source file is 0 byte */
2112cdf0e10cSrcweir if (0 == nSourceSize)
2113cdf0e10cSrcweir {
2114cdf0e10cSrcweir close(SourceFileFD);
2115cdf0e10cSrcweir close(DestFileFD);
2116cdf0e10cSrcweir return 0;
2117cdf0e10cSrcweir }
2118cdf0e10cSrcweir
2119cdf0e10cSrcweir while( (nRet = read(SourceFileFD, buffer, sizeof(buffer))) !=0 )
2120cdf0e10cSrcweir {
2121cdf0e10cSrcweir nRet = write( DestFileFD, buffer, nRet);
2122cdf0e10cSrcweir }
2123cdf0e10cSrcweir
2124cdf0e10cSrcweir close(SourceFileFD);
2125cdf0e10cSrcweir close(DestFileFD);
2126cdf0e10cSrcweir
2127cdf0e10cSrcweir return nRet;
2128cdf0e10cSrcweir }
2129cdf0e10cSrcweir
osl_psz_copyFile(const sal_Char * pszPath,const sal_Char * pszDestPath)2130cdf0e10cSrcweir static oslFileError osl_psz_copyFile( const sal_Char* pszPath, const sal_Char* pszDestPath )
2131cdf0e10cSrcweir {
2132cdf0e10cSrcweir time_t nAcTime=0;
2133cdf0e10cSrcweir time_t nModTime=0;
2134cdf0e10cSrcweir uid_t nUID=0;
2135cdf0e10cSrcweir gid_t nGID=0;
2136cdf0e10cSrcweir int nRet=0;
2137cdf0e10cSrcweir mode_t nMode=0;
2138cdf0e10cSrcweir struct stat aFileStat;
2139cdf0e10cSrcweir oslFileError tErr=osl_File_E_invalidError;
2140cdf0e10cSrcweir size_t nSourceSize=0;
2141cdf0e10cSrcweir int DestFileExists=1;
2142cdf0e10cSrcweir
2143cdf0e10cSrcweir /* mfe: does the source file really exists? */
2144cdf0e10cSrcweir nRet = lstat(pszPath,&aFileStat);
2145cdf0e10cSrcweir
2146cdf0e10cSrcweir if ( nRet < 0 )
2147cdf0e10cSrcweir {
2148cdf0e10cSrcweir nRet=errno;
2149cdf0e10cSrcweir return oslTranslateFileError(OSL_FET_ERROR, nRet);
2150cdf0e10cSrcweir }
2151cdf0e10cSrcweir
2152cdf0e10cSrcweir /* mfe: we do only copy files here! */
2153cdf0e10cSrcweir if ( S_ISDIR(aFileStat.st_mode) )
2154cdf0e10cSrcweir {
2155cdf0e10cSrcweir return osl_File_E_ISDIR;
2156cdf0e10cSrcweir }
2157cdf0e10cSrcweir
2158cdf0e10cSrcweir nSourceSize=(size_t)aFileStat.st_size;
2159cdf0e10cSrcweir nMode=aFileStat.st_mode;
2160cdf0e10cSrcweir nAcTime=aFileStat.st_atime;
2161cdf0e10cSrcweir nModTime=aFileStat.st_mtime;
2162cdf0e10cSrcweir nUID=aFileStat.st_uid;
2163cdf0e10cSrcweir nGID=aFileStat.st_gid;
2164cdf0e10cSrcweir
2165cdf0e10cSrcweir nRet = stat(pszDestPath,&aFileStat);
2166cdf0e10cSrcweir if ( nRet < 0 )
2167cdf0e10cSrcweir {
2168cdf0e10cSrcweir nRet=errno;
2169cdf0e10cSrcweir
2170cdf0e10cSrcweir if ( nRet == ENOENT )
2171cdf0e10cSrcweir {
2172cdf0e10cSrcweir DestFileExists=0;
2173cdf0e10cSrcweir }
2174cdf0e10cSrcweir /* return oslTranslateFileError(nRet);*/
2175cdf0e10cSrcweir }
2176cdf0e10cSrcweir
2177cdf0e10cSrcweir /* mfe: the destination file must not be a directory! */
2178cdf0e10cSrcweir if ( nRet == 0 && S_ISDIR(aFileStat.st_mode) )
2179cdf0e10cSrcweir {
2180cdf0e10cSrcweir return osl_File_E_ISDIR;
2181cdf0e10cSrcweir }
2182cdf0e10cSrcweir else
2183cdf0e10cSrcweir {
2184cdf0e10cSrcweir /* mfe: file does not exists or is no dir */
2185cdf0e10cSrcweir }
2186cdf0e10cSrcweir
2187cdf0e10cSrcweir tErr = oslDoCopy(pszPath,pszDestPath,nMode,nSourceSize,DestFileExists);
2188cdf0e10cSrcweir
2189cdf0e10cSrcweir if ( tErr != osl_File_E_None )
2190cdf0e10cSrcweir {
2191cdf0e10cSrcweir return tErr;
2192cdf0e10cSrcweir }
2193cdf0e10cSrcweir
2194cdf0e10cSrcweir /*
2195cdf0e10cSrcweir * mfe: ignore return code
2196cdf0e10cSrcweir * since only the success of the copy is
2197cdf0e10cSrcweir * important
2198cdf0e10cSrcweir */
2199cdf0e10cSrcweir oslChangeFileModes(pszDestPath,nMode,nAcTime,nModTime,nUID,nGID);
2200cdf0e10cSrcweir
2201cdf0e10cSrcweir return tErr;
2202cdf0e10cSrcweir }
2203cdf0e10cSrcweir
osl_copyFile(rtl_uString * ustrFileURL,rtl_uString * ustrDestURL)2204cdf0e10cSrcweir oslFileError osl_copyFile( rtl_uString* ustrFileURL, rtl_uString* ustrDestURL )
2205cdf0e10cSrcweir {
2206cdf0e10cSrcweir char srcPath[PATH_MAX];
2207cdf0e10cSrcweir char destPath[PATH_MAX];
2208cdf0e10cSrcweir oslFileError eRet;
2209cdf0e10cSrcweir APIRET rc;
2210cdf0e10cSrcweir
2211cdf0e10cSrcweir OSL_ASSERT( ustrFileURL );
2212cdf0e10cSrcweir OSL_ASSERT( ustrDestURL );
2213cdf0e10cSrcweir
2214cdf0e10cSrcweir /* convert source url to system path */
2215cdf0e10cSrcweir eRet = FileURLToPath( srcPath, PATH_MAX, ustrFileURL );
2216cdf0e10cSrcweir if( eRet != osl_File_E_None )
2217cdf0e10cSrcweir return eRet;
2218cdf0e10cSrcweir
2219cdf0e10cSrcweir /* convert destination url to system path */
2220cdf0e10cSrcweir eRet = FileURLToPath( destPath, PATH_MAX, ustrDestURL );
2221cdf0e10cSrcweir if( eRet != osl_File_E_None )
2222cdf0e10cSrcweir return eRet;
2223cdf0e10cSrcweir
2224cdf0e10cSrcweir return osl_psz_copyFile( srcPath, destPath );
2225cdf0e10cSrcweir }
2226cdf0e10cSrcweir
2227cdf0e10cSrcweir /****************************************************************************/
2228cdf0e10cSrcweir /* osl_removeFile */
2229cdf0e10cSrcweir /****************************************************************************/
2230cdf0e10cSrcweir
osl_removeFile(rtl_uString * ustrFileURL)2231cdf0e10cSrcweir oslFileError osl_removeFile( rtl_uString* ustrFileURL )
2232cdf0e10cSrcweir {
2233cdf0e10cSrcweir char path[PATH_MAX];
2234cdf0e10cSrcweir oslFileError eRet;
2235cdf0e10cSrcweir APIRET rc;
2236cdf0e10cSrcweir
2237cdf0e10cSrcweir OSL_ASSERT( ustrFileURL );
2238cdf0e10cSrcweir
2239cdf0e10cSrcweir /* convert file url to system path */
2240cdf0e10cSrcweir eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
2241cdf0e10cSrcweir if( eRet != osl_File_E_None )
2242cdf0e10cSrcweir return eRet;
2243cdf0e10cSrcweir
2244cdf0e10cSrcweir rc = DosDelete( (PCSZ)path);
2245cdf0e10cSrcweir if (!rc)
2246cdf0e10cSrcweir eRet = osl_File_E_None;
2247cdf0e10cSrcweir else
2248cdf0e10cSrcweir eRet = MapError( rc);
2249cdf0e10cSrcweir
2250cdf0e10cSrcweir return eRet;
2251cdf0e10cSrcweir }
2252cdf0e10cSrcweir
2253cdf0e10cSrcweir /****************************************************************************/
2254cdf0e10cSrcweir /* osl_getVolumeInformation */
2255cdf0e10cSrcweir /****************************************************************************/
2256cdf0e10cSrcweir
2257cdf0e10cSrcweir #define TXFSDC_BLOCKR 0x00 // block device removable
2258cdf0e10cSrcweir #define TXFSDC_GETBPB 0x00 // get device bpb info
2259cdf0e10cSrcweir #define TXFSBPB_REMOVABLE 0x08 // BPB attribute for removable
2260cdf0e10cSrcweir
2261cdf0e10cSrcweir typedef struct drivecmd
2262cdf0e10cSrcweir {
2263cdf0e10cSrcweir BYTE cmd; // 0=unlock 1=lock 2=eject
2264cdf0e10cSrcweir BYTE drv; // 0=A, 1=B 2=C ...
2265cdf0e10cSrcweir } DRIVECMD; // end of struct "drivecmd"
2266cdf0e10cSrcweir
2267cdf0e10cSrcweir #pragma pack(push, 1) // byte packing
2268cdf0e10cSrcweir typedef struct txfs_ebpb // ext. boot parameter block
2269cdf0e10cSrcweir { // at offset 0x0b in bootsector
2270cdf0e10cSrcweir USHORT SectSize; // 0B bytes per sector
2271cdf0e10cSrcweir BYTE ClustSize; // 0D sectors per cluster
2272cdf0e10cSrcweir USHORT FatOffset; // 0E sectors to 1st FAT
2273cdf0e10cSrcweir BYTE NrOfFats; // 10 nr of FATS (FAT only)
2274cdf0e10cSrcweir USHORT RootEntries; // 11 Max entries \ (FAT only)
2275cdf0e10cSrcweir USHORT Sectors; // 13 nr of sectors if < 64K
2276cdf0e10cSrcweir BYTE MediaType; // 15 mediatype (F8 for HD)
2277cdf0e10cSrcweir USHORT FatSectors; // 16 sectors/FAT (FAT only)
2278cdf0e10cSrcweir USHORT LogGeoSect; // 18 sectors/Track
2279cdf0e10cSrcweir USHORT LogGeoHead; // 1a nr of heads
2280cdf0e10cSrcweir ULONG HiddenSectors; // 1c sector-offset from MBR/EBR
2281cdf0e10cSrcweir ULONG BigSectors; // 20 nr of sectors if >= 64K
2282cdf0e10cSrcweir } TXFS_EBPB; // last byte is at offset 0x23
2283cdf0e10cSrcweir
2284cdf0e10cSrcweir typedef struct drivebpb
2285cdf0e10cSrcweir {
2286cdf0e10cSrcweir TXFS_EBPB ebpb; // extended BPB
2287cdf0e10cSrcweir BYTE reserved[6];
2288cdf0e10cSrcweir USHORT cyls;
2289cdf0e10cSrcweir BYTE type;
2290cdf0e10cSrcweir USHORT attributes; // device attributes
2291cdf0e10cSrcweir BYTE fill[6]; // documented for IOCtl
2292cdf0e10cSrcweir } DRIVEBPB; // end of struct "drivebpb"
2293cdf0e10cSrcweir
2294cdf0e10cSrcweir struct CDInfo {
2295cdf0e10cSrcweir USHORT usCount;
2296cdf0e10cSrcweir USHORT usFirst;
2297cdf0e10cSrcweir };
2298cdf0e10cSrcweir
2299cdf0e10cSrcweir #pragma pack(pop)
2300cdf0e10cSrcweir
2301cdf0e10cSrcweir /*****************************************************************************/
2302cdf0e10cSrcweir // Get number of cdrom readers
2303cdf0e10cSrcweir /*****************************************************************************/
GetCDInfo(CDInfo * pCDInfo)2304cdf0e10cSrcweir BOOL GetCDInfo( CDInfo * pCDInfo )
2305cdf0e10cSrcweir {
2306cdf0e10cSrcweir HFILE hFileCD;
2307cdf0e10cSrcweir ULONG ulAction;
2308cdf0e10cSrcweir
2309cdf0e10cSrcweir if( NO_ERROR == DosOpen( (PCSZ)"\\DEV\\CD-ROM2$",
2310cdf0e10cSrcweir &hFileCD, &ulAction, 0, FILE_NORMAL,
2311cdf0e10cSrcweir OPEN_ACTION_OPEN_IF_EXISTS,
2312cdf0e10cSrcweir OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, NULL )) {
2313cdf0e10cSrcweir ULONG ulDataSize = sizeof(CDInfo);
2314cdf0e10cSrcweir APIRET rc = DosDevIOCtl( hFileCD, 0x82, 0x60, NULL, 0,
2315cdf0e10cSrcweir NULL, (PVOID)pCDInfo, ulDataSize, &ulDataSize);
2316cdf0e10cSrcweir DosClose( hFileCD);
2317cdf0e10cSrcweir if(rc == NO_ERROR)
2318cdf0e10cSrcweir return TRUE;
2319cdf0e10cSrcweir }
2320cdf0e10cSrcweir // failed
2321cdf0e10cSrcweir pCDInfo->usFirst = 0;
2322cdf0e10cSrcweir pCDInfo->usCount = 0;
2323cdf0e10cSrcweir return FALSE;
2324cdf0e10cSrcweir }
2325cdf0e10cSrcweir
2326cdf0e10cSrcweir /*****************************************************************************/
2327cdf0e10cSrcweir // Determine if unit is a cdrom or not
2328cdf0e10cSrcweir /*****************************************************************************/
DriveIsCDROM(UINT uiDrive,CDInfo * pCDInfo)2329cdf0e10cSrcweir BOOL DriveIsCDROM(UINT uiDrive, CDInfo *pCDInfo)
2330cdf0e10cSrcweir {
2331cdf0e10cSrcweir return (uiDrive >= pCDInfo->usFirst)
2332cdf0e10cSrcweir && (uiDrive < (pCDInfo->usFirst + pCDInfo->usCount));
2333cdf0e10cSrcweir }
2334cdf0e10cSrcweir
2335cdf0e10cSrcweir /*****************************************************************************/
2336cdf0e10cSrcweir // Determine attached fstype, e.g. HPFS for specified drive
2337cdf0e10cSrcweir /*****************************************************************************/
TxFsType(char * drive,char * fstype,char * details)2338cdf0e10cSrcweir BOOL TxFsType // RET FS type resolved
2339cdf0e10cSrcweir (
2340cdf0e10cSrcweir char *drive, // IN Drive specification
2341cdf0e10cSrcweir char *fstype, // OUT Attached FS type
2342cdf0e10cSrcweir char *details // OUT details (UNC) or NULL
2343cdf0e10cSrcweir )
2344cdf0e10cSrcweir {
2345cdf0e10cSrcweir BOOL rc = FALSE;
2346cdf0e10cSrcweir FSQBUFFER2 *fsinfo; // Attached FS info
2347cdf0e10cSrcweir ULONG fsdlen = 2048; // Fs info data length
2348cdf0e10cSrcweir
2349cdf0e10cSrcweir strcpy(fstype, "none");
2350cdf0e10cSrcweir if (details)
2351cdf0e10cSrcweir {
2352cdf0e10cSrcweir strcpy(details, "");
2353cdf0e10cSrcweir }
2354cdf0e10cSrcweir if ((fsinfo = (FSQBUFFER2*)calloc(1, fsdlen)) != NULL)
2355cdf0e10cSrcweir {
2356cdf0e10cSrcweir if (DosQFSAttach((PCSZ)drive, 0, 1, fsinfo, &fsdlen) == NO_ERROR)
2357cdf0e10cSrcweir {
2358cdf0e10cSrcweir strcpy(fstype, (char*) fsinfo->szName + fsinfo->cbName +1);
2359cdf0e10cSrcweir if (details && (fsinfo->cbFSAData != 0))
2360cdf0e10cSrcweir {
2361cdf0e10cSrcweir strcpy( details, (char*) fsinfo->szName + fsinfo->cbName +
2362cdf0e10cSrcweir fsinfo->cbFSDName +2);
2363cdf0e10cSrcweir }
2364cdf0e10cSrcweir rc = TRUE;
2365cdf0e10cSrcweir }
2366cdf0e10cSrcweir free(fsinfo);
2367cdf0e10cSrcweir }
2368cdf0e10cSrcweir return (rc);
2369cdf0e10cSrcweir } // end 'TxFsType'
2370cdf0e10cSrcweir /*---------------------------------------------------------------------------*/
2371cdf0e10cSrcweir
2372cdf0e10cSrcweir
2373cdf0e10cSrcweir /*****************************************************************************/
2374cdf0e10cSrcweir // Determine if a driveletter represents a removable medium/device
2375cdf0e10cSrcweir /*****************************************************************************/
TxFsIsRemovable(char * drive)2376cdf0e10cSrcweir BOOL TxFsIsRemovable // RET drive is removable
2377cdf0e10cSrcweir (
2378cdf0e10cSrcweir char *drive // IN Driveletter to test
2379cdf0e10cSrcweir )
2380cdf0e10cSrcweir {
2381cdf0e10cSrcweir BOOL rc = FALSE;
2382cdf0e10cSrcweir DRIVECMD IOCtl;
2383cdf0e10cSrcweir DRIVEBPB RemAt;
2384cdf0e10cSrcweir ULONG DataLen;
2385cdf0e10cSrcweir ULONG ParmLen;
2386cdf0e10cSrcweir BYTE NoRem;
2387cdf0e10cSrcweir
2388cdf0e10cSrcweir DosError( FERR_DISABLEHARDERR); // avoid 'not ready' popups
2389cdf0e10cSrcweir
2390cdf0e10cSrcweir ParmLen = sizeof(IOCtl);
2391cdf0e10cSrcweir IOCtl.cmd = TXFSDC_BLOCKR;
2392cdf0e10cSrcweir IOCtl.drv = toupper(drive[0]) - 'A';
2393cdf0e10cSrcweir DataLen = sizeof(NoRem);
2394cdf0e10cSrcweir
2395cdf0e10cSrcweir if (DosDevIOCtl((HFILE) -1, IOCTL_DISK,
2396cdf0e10cSrcweir DSK_BLOCKREMOVABLE,
2397cdf0e10cSrcweir &IOCtl, ParmLen, &ParmLen,
2398cdf0e10cSrcweir &NoRem, DataLen, &DataLen) == NO_ERROR)
2399cdf0e10cSrcweir {
2400cdf0e10cSrcweir if (NoRem) // non-removable sofar, check
2401cdf0e10cSrcweir { // BPB as well (USB devices)
2402cdf0e10cSrcweir ParmLen = sizeof(IOCtl);
2403cdf0e10cSrcweir IOCtl.cmd = TXFSDC_GETBPB;
2404cdf0e10cSrcweir IOCtl.drv = toupper(drive[0]) - 'A';
2405cdf0e10cSrcweir DataLen = sizeof(RemAt);
2406cdf0e10cSrcweir
2407cdf0e10cSrcweir if (DosDevIOCtl((HFILE) -1, IOCTL_DISK,
2408cdf0e10cSrcweir DSK_GETDEVICEPARAMS,
2409cdf0e10cSrcweir &IOCtl, ParmLen, &ParmLen,
2410cdf0e10cSrcweir &RemAt, DataLen, &DataLen) == NO_ERROR)
2411cdf0e10cSrcweir
2412cdf0e10cSrcweir {
2413cdf0e10cSrcweir if (RemAt.attributes & TXFSBPB_REMOVABLE)
2414cdf0e10cSrcweir {
2415cdf0e10cSrcweir rc = TRUE; // removable, probably USB
2416cdf0e10cSrcweir }
2417cdf0e10cSrcweir }
2418cdf0e10cSrcweir }
2419cdf0e10cSrcweir else
2420cdf0e10cSrcweir {
2421cdf0e10cSrcweir rc = TRUE; // removable block device
2422cdf0e10cSrcweir }
2423cdf0e10cSrcweir }
2424cdf0e10cSrcweir DosError( FERR_ENABLEHARDERR); // enable criterror handler
2425cdf0e10cSrcweir return (rc);
2426cdf0e10cSrcweir } // end 'TxFsIsRemovable'
2427cdf0e10cSrcweir /*---------------------------------------------------------------------------*/
2428cdf0e10cSrcweir
get_drive_type(const char * path,oslVolumeInfo * pInfo)2429cdf0e10cSrcweir static oslFileError get_drive_type(const char* path, oslVolumeInfo* pInfo)
2430cdf0e10cSrcweir {
2431cdf0e10cSrcweir char Drive_Letter = toupper( *path);
2432cdf0e10cSrcweir char fstype[ 64];
2433cdf0e10cSrcweir
2434cdf0e10cSrcweir pInfo->uValidFields |= osl_VolumeInfo_Mask_Attributes;
2435cdf0e10cSrcweir
2436cdf0e10cSrcweir // check for floppy A/B
2437cdf0e10cSrcweir BYTE nFloppies;
2438cdf0e10cSrcweir APIRET rc;
2439cdf0e10cSrcweir rc = DosDevConfig( (void*) &nFloppies, DEVINFO_FLOPPY );
2440cdf0e10cSrcweir if ((Drive_Letter - 'A') < nFloppies) {
2441cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_Removeable;
2442cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_FloppyDisk;
2443cdf0e10cSrcweir return osl_File_E_None;
2444cdf0e10cSrcweir }
2445cdf0e10cSrcweir
2446cdf0e10cSrcweir // query system for CD drives
2447cdf0e10cSrcweir CDInfo cdInfo;
2448cdf0e10cSrcweir GetCDInfo(&cdInfo);
2449cdf0e10cSrcweir
2450cdf0e10cSrcweir // query if drive is a CDROM
2451cdf0e10cSrcweir if (DriveIsCDROM( Drive_Letter - 'A', &cdInfo))
2452cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_CompactDisc | osl_Volume_Attribute_Removeable;
2453cdf0e10cSrcweir
2454cdf0e10cSrcweir if (TxFsIsRemovable( (char*)path))
2455cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_Removeable;
2456cdf0e10cSrcweir
2457cdf0e10cSrcweir if (TxFsType( (char*)path, fstype, NULL) == FALSE) {
2458cdf0e10cSrcweir // query failed, assume fixed disk
2459cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_FixedDisk;
2460cdf0e10cSrcweir return osl_File_E_None;
2461cdf0e10cSrcweir }
2462cdf0e10cSrcweir
2463cdf0e10cSrcweir //- Note, connected Win-NT drives use the REAL FS-name like NTFS!
2464cdf0e10cSrcweir if ((strncasecmp( fstype, "LAN", 3) == 0) //- OS/2 LAN drives
2465cdf0e10cSrcweir || (strncasecmp( fstype, "NDFS", 4) == 0) //- NetDrive
2466cdf0e10cSrcweir || (strncasecmp( fstype, "REMOTE", 5) == 0) ) //- NT disconnected
2467cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_Remote;
2468cdf0e10cSrcweir else if (strncasecmp( fstype, "RAMFS", 5) == 0)
2469cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_RAMDisk;
2470cdf0e10cSrcweir else if ((strncasecmp( fstype, "CD", 2) == 0) // OS2:CDFS, DOS/WIN:CDROM
2471cdf0e10cSrcweir || (strncasecmp( fstype, "UDF", 3) == 0) ) // OS2:UDF DVD's
2472cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_CompactDisc | osl_Volume_Attribute_Removeable;
2473cdf0e10cSrcweir else
2474cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_FixedDisk;
2475cdf0e10cSrcweir
2476cdf0e10cSrcweir return osl_File_E_None;
2477cdf0e10cSrcweir }
2478cdf0e10cSrcweir
2479cdf0e10cSrcweir //#############################################
is_volume_space_info_request(sal_uInt32 field_mask)2480cdf0e10cSrcweir inline bool is_volume_space_info_request(sal_uInt32 field_mask)
2481cdf0e10cSrcweir {
2482cdf0e10cSrcweir return (field_mask &
2483cdf0e10cSrcweir (osl_VolumeInfo_Mask_TotalSpace |
2484cdf0e10cSrcweir osl_VolumeInfo_Mask_UsedSpace |
2485cdf0e10cSrcweir osl_VolumeInfo_Mask_FreeSpace));
2486cdf0e10cSrcweir }
2487cdf0e10cSrcweir
2488cdf0e10cSrcweir //#############################################
get_volume_space_information(const char * path,oslVolumeInfo * pInfo)2489cdf0e10cSrcweir static void get_volume_space_information(const char* path, oslVolumeInfo *pInfo)
2490cdf0e10cSrcweir {
2491cdf0e10cSrcweir FSALLOCATE aFSInfoBuf;
2492cdf0e10cSrcweir ULONG nDriveNumber = toupper( *path) - 'A' + 1;
2493cdf0e10cSrcweir
2494cdf0e10cSrcweir // disable error popups
2495cdf0e10cSrcweir DosError(FERR_DISABLEHARDERR);
2496cdf0e10cSrcweir APIRET rc = DosQueryFSInfo( nDriveNumber, FSIL_ALLOC,
2497cdf0e10cSrcweir &aFSInfoBuf, sizeof(aFSInfoBuf) );
2498cdf0e10cSrcweir // enable error popups
2499cdf0e10cSrcweir DosError(FERR_ENABLEHARDERR);
2500cdf0e10cSrcweir if (!rc)
2501cdf0e10cSrcweir {
2502cdf0e10cSrcweir uint64_t aBytesPerCluster( uint64_t(aFSInfoBuf.cbSector) *
2503cdf0e10cSrcweir uint64_t(aFSInfoBuf.cSectorUnit) );
2504cdf0e10cSrcweir pInfo->uFreeSpace = aBytesPerCluster * uint64_t(aFSInfoBuf.cUnitAvail);
2505cdf0e10cSrcweir pInfo->uTotalSpace = aBytesPerCluster * uint64_t(aFSInfoBuf.cUnit);
2506cdf0e10cSrcweir pInfo->uUsedSpace = pInfo->uTotalSpace - pInfo->uFreeSpace;
2507cdf0e10cSrcweir pInfo->uValidFields |= osl_VolumeInfo_Mask_TotalSpace |
2508cdf0e10cSrcweir osl_VolumeInfo_Mask_UsedSpace |
2509cdf0e10cSrcweir osl_VolumeInfo_Mask_FreeSpace;
2510cdf0e10cSrcweir }
2511cdf0e10cSrcweir }
2512cdf0e10cSrcweir
2513cdf0e10cSrcweir //#############################################
is_filesystem_attributes_request(sal_uInt32 field_mask)2514cdf0e10cSrcweir inline bool is_filesystem_attributes_request(sal_uInt32 field_mask)
2515cdf0e10cSrcweir {
2516cdf0e10cSrcweir return (field_mask &
2517cdf0e10cSrcweir (osl_VolumeInfo_Mask_MaxNameLength |
2518cdf0e10cSrcweir osl_VolumeInfo_Mask_MaxPathLength |
2519cdf0e10cSrcweir osl_VolumeInfo_Mask_FileSystemName |
2520cdf0e10cSrcweir osl_VolumeInfo_Mask_FileSystemCaseHandling));
2521cdf0e10cSrcweir }
2522cdf0e10cSrcweir
2523cdf0e10cSrcweir //#############################################
is_drivetype_request(sal_uInt32 field_mask)2524cdf0e10cSrcweir inline bool is_drivetype_request(sal_uInt32 field_mask)
2525cdf0e10cSrcweir {
2526cdf0e10cSrcweir return (field_mask & osl_VolumeInfo_Mask_Attributes);
2527cdf0e10cSrcweir }
2528cdf0e10cSrcweir
2529cdf0e10cSrcweir typedef struct _FSQBUFFER_
2530cdf0e10cSrcweir {
2531cdf0e10cSrcweir FSQBUFFER2 aBuf;
2532cdf0e10cSrcweir UCHAR sBuf[64];
2533cdf0e10cSrcweir } FSQBUFFER_;
2534cdf0e10cSrcweir
2535cdf0e10cSrcweir //#############################################
get_filesystem_attributes(const char * path,sal_uInt32 field_mask,oslVolumeInfo * pInfo)2536cdf0e10cSrcweir static oslFileError get_filesystem_attributes(const char* path, sal_uInt32 field_mask, oslVolumeInfo* pInfo)
2537cdf0e10cSrcweir {
2538cdf0e10cSrcweir pInfo->uAttributes = 0;
2539cdf0e10cSrcweir
2540cdf0e10cSrcweir oslFileError osl_error = osl_File_E_None;
2541cdf0e10cSrcweir
2542cdf0e10cSrcweir // osl_get_drive_type must be called first because
2543cdf0e10cSrcweir // this function resets osl_VolumeInfo_Mask_Attributes
2544cdf0e10cSrcweir // on failure
2545cdf0e10cSrcweir if (is_drivetype_request(field_mask))
2546cdf0e10cSrcweir osl_error = get_drive_type(path, pInfo);
2547cdf0e10cSrcweir
2548cdf0e10cSrcweir if ((osl_File_E_None == osl_error) && is_filesystem_attributes_request(field_mask))
2549cdf0e10cSrcweir {
2550cdf0e10cSrcweir FSQBUFFER_ aBuf;
2551cdf0e10cSrcweir ULONG nBufLen;
2552cdf0e10cSrcweir APIRET nRet;
2553cdf0e10cSrcweir
2554cdf0e10cSrcweir nBufLen = sizeof( aBuf );
2555cdf0e10cSrcweir // disable error popups
2556cdf0e10cSrcweir DosError(FERR_DISABLEHARDERR);
2557cdf0e10cSrcweir nRet = DosQueryFSAttach( (PCSZ)path, 0, FSAIL_QUERYNAME, (_FSQBUFFER2*) &aBuf, &nBufLen );
2558cdf0e10cSrcweir if ( !nRet )
2559cdf0e10cSrcweir {
2560cdf0e10cSrcweir char *pType = (char*)(aBuf.aBuf.szName + aBuf.aBuf.cbName + 1);
2561cdf0e10cSrcweir pInfo->uValidFields |= osl_VolumeInfo_Mask_MaxNameLength;
2562cdf0e10cSrcweir pInfo->uMaxNameLength = _MAX_FNAME;
2563cdf0e10cSrcweir
2564cdf0e10cSrcweir pInfo->uValidFields |= osl_VolumeInfo_Mask_MaxPathLength;
2565cdf0e10cSrcweir pInfo->uMaxPathLength = _MAX_PATH;
2566cdf0e10cSrcweir
2567cdf0e10cSrcweir pInfo->uValidFields |= osl_VolumeInfo_Mask_FileSystemName;
2568cdf0e10cSrcweir rtl_uString_newFromAscii(&pInfo->ustrFileSystemName, pType);
2569cdf0e10cSrcweir
2570cdf0e10cSrcweir // case is preserved always except for FAT
2571cdf0e10cSrcweir if (strcmp( pType, "FAT" ))
2572cdf0e10cSrcweir pInfo->uAttributes |= osl_Volume_Attribute_Case_Is_Preserved;
2573cdf0e10cSrcweir
2574cdf0e10cSrcweir pInfo->uValidFields |= osl_VolumeInfo_Mask_Attributes;
2575cdf0e10cSrcweir }
2576cdf0e10cSrcweir // enable error popups
2577cdf0e10cSrcweir DosError(FERR_ENABLEHARDERR);
2578cdf0e10cSrcweir }
2579cdf0e10cSrcweir return osl_error;
2580cdf0e10cSrcweir }
2581cdf0e10cSrcweir
osl_getVolumeInformation(rtl_uString * ustrDirectoryURL,oslVolumeInfo * pInfo,sal_uInt32 uFieldMask)2582cdf0e10cSrcweir oslFileError SAL_CALL osl_getVolumeInformation( rtl_uString* ustrDirectoryURL, oslVolumeInfo* pInfo, sal_uInt32 uFieldMask )
2583cdf0e10cSrcweir {
2584cdf0e10cSrcweir char volume_root[PATH_MAX];
2585cdf0e10cSrcweir oslFileError error;
2586cdf0e10cSrcweir
2587cdf0e10cSrcweir OSL_ASSERT( ustrDirectoryURL );
2588cdf0e10cSrcweir OSL_ASSERT( pInfo );
2589cdf0e10cSrcweir
2590cdf0e10cSrcweir /* convert directory url to system path */
2591cdf0e10cSrcweir error = FileURLToPath( volume_root, PATH_MAX, ustrDirectoryURL );
2592cdf0e10cSrcweir if( error != osl_File_E_None )
2593cdf0e10cSrcweir return error;
2594cdf0e10cSrcweir
2595cdf0e10cSrcweir if (!pInfo)
2596cdf0e10cSrcweir return osl_File_E_INVAL;
2597cdf0e10cSrcweir
2598cdf0e10cSrcweir pInfo->uValidFields = 0;
2599cdf0e10cSrcweir
2600cdf0e10cSrcweir if ((error = get_filesystem_attributes(volume_root, uFieldMask, pInfo)) != osl_File_E_None)
2601cdf0e10cSrcweir return error;
2602cdf0e10cSrcweir
2603cdf0e10cSrcweir if (is_volume_space_info_request(uFieldMask))
2604cdf0e10cSrcweir get_volume_space_information(volume_root, pInfo);
2605cdf0e10cSrcweir
2606cdf0e10cSrcweir if (uFieldMask & osl_VolumeInfo_Mask_DeviceHandle)
2607cdf0e10cSrcweir {
2608cdf0e10cSrcweir pInfo->uValidFields |= osl_VolumeInfo_Mask_DeviceHandle;
2609cdf0e10cSrcweir rtl_uString* uVolumeRoot;
2610cdf0e10cSrcweir rtl_uString_newFromAscii( &uVolumeRoot, volume_root);
2611cdf0e10cSrcweir osl_getFileURLFromSystemPath( uVolumeRoot, (rtl_uString**)&pInfo->pDeviceHandle);
2612cdf0e10cSrcweir rtl_uString_release( uVolumeRoot);
2613cdf0e10cSrcweir }
2614cdf0e10cSrcweir
2615cdf0e10cSrcweir return osl_File_E_None;
2616cdf0e10cSrcweir }
2617cdf0e10cSrcweir
2618cdf0e10cSrcweir /****************************************************************************/
2619cdf0e10cSrcweir /* osl_getFileStatus */
2620cdf0e10cSrcweir /****************************************************************************/
_osl_getDriveInfo(oslDirectoryItem Item,oslFileStatus * pStatus,sal_uInt32 uFieldMask)2621cdf0e10cSrcweir static oslFileError _osl_getDriveInfo(
2622cdf0e10cSrcweir oslDirectoryItem Item, oslFileStatus *pStatus, sal_uInt32 uFieldMask)
2623cdf0e10cSrcweir {
2624cdf0e10cSrcweir DirectoryItem_Impl *pItemImpl = (DirectoryItem_Impl *)Item;
2625cdf0e10cSrcweir sal_Unicode cDrive[3];
2626cdf0e10cSrcweir sal_Unicode cRoot[4];
2627cdf0e10cSrcweir
2628cdf0e10cSrcweir if ( !pItemImpl )
2629cdf0e10cSrcweir return osl_File_E_INVAL;
2630cdf0e10cSrcweir
2631cdf0e10cSrcweir pStatus->uValidFields = 0;
2632cdf0e10cSrcweir
2633cdf0e10cSrcweir cDrive[0] = pItemImpl->ustrDrive->buffer[0];
2634cdf0e10cSrcweir cDrive[1] = (sal_Unicode)':';
2635cdf0e10cSrcweir cDrive[2] = 0;
2636cdf0e10cSrcweir cRoot[0] = pItemImpl->ustrDrive->buffer[0];
2637cdf0e10cSrcweir cRoot[1] = (sal_Unicode)':';
2638cdf0e10cSrcweir cRoot[2] = 0;
2639cdf0e10cSrcweir
2640cdf0e10cSrcweir if ( uFieldMask & osl_FileStatus_Mask_FileName )
2641cdf0e10cSrcweir {
2642cdf0e10cSrcweir if ( pItemImpl->ustrDrive->buffer[0] == '\\' &&
2643cdf0e10cSrcweir pItemImpl->ustrDrive->buffer[1] == '\\' )
2644cdf0e10cSrcweir {
2645cdf0e10cSrcweir LPCWSTR lpFirstBkSlash = wcschr( (const wchar_t*)&pItemImpl->ustrDrive->buffer[2], '\\' );
2646cdf0e10cSrcweir
2647cdf0e10cSrcweir if ( lpFirstBkSlash && lpFirstBkSlash[1] )
2648cdf0e10cSrcweir {
2649cdf0e10cSrcweir LPCWSTR lpLastBkSlash = wcschr( (const wchar_t*)&lpFirstBkSlash[1], '\\' );
2650cdf0e10cSrcweir
2651cdf0e10cSrcweir if ( lpLastBkSlash )
2652cdf0e10cSrcweir rtl_uString_newFromStr_WithLength( &pStatus->ustrFileName, (sal_Unicode*)&lpFirstBkSlash[1], lpLastBkSlash - lpFirstBkSlash - 1 );
2653cdf0e10cSrcweir else
2654cdf0e10cSrcweir rtl_uString_newFromStr( &pStatus->ustrFileName, (sal_Unicode*)&lpFirstBkSlash[1] );
2655cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
2656cdf0e10cSrcweir }
2657cdf0e10cSrcweir }
2658cdf0e10cSrcweir else
2659cdf0e10cSrcweir {
2660cdf0e10cSrcweir FSINFO aFSInfoBuf;
2661cdf0e10cSrcweir ULONG ulFSInfoLevel = FSIL_VOLSER;
2662cdf0e10cSrcweir ULONG nDriveNumber;
2663cdf0e10cSrcweir char szFileName[ _MAX_PATH];
2664cdf0e10cSrcweir
2665cdf0e10cSrcweir nDriveNumber = toupper(*cDrive) - 'A' + 1;
2666cdf0e10cSrcweir memset( &aFSInfoBuf, 0, sizeof(FSINFO) );
2667cdf0e10cSrcweir // disable error popups
2668cdf0e10cSrcweir DosError(FERR_DISABLEHARDERR);
2669cdf0e10cSrcweir APIRET rc = DosQueryFSInfo( nDriveNumber, ulFSInfoLevel, &aFSInfoBuf, sizeof(FSINFO) );
2670cdf0e10cSrcweir // enable error popups
2671cdf0e10cSrcweir DosError(FERR_ENABLEHARDERR);
2672cdf0e10cSrcweir memset( szFileName, 0, sizeof( szFileName));
2673cdf0e10cSrcweir *szFileName = toupper(*cDrive);
2674cdf0e10cSrcweir strcat( szFileName, ": [");
2675cdf0e10cSrcweir if ( !rc || aFSInfoBuf.vol.cch)
2676cdf0e10cSrcweir strncat( szFileName, aFSInfoBuf.vol.szVolLabel, aFSInfoBuf.vol.cch);
2677cdf0e10cSrcweir strcat( szFileName, "]");
2678cdf0e10cSrcweir rtl_uString_newFromAscii( &pStatus->ustrFileName, szFileName );
2679cdf0e10cSrcweir
2680cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
2681cdf0e10cSrcweir }
2682cdf0e10cSrcweir }
2683cdf0e10cSrcweir
2684cdf0e10cSrcweir pStatus->eType = osl_File_Type_Volume;
2685cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_Type;
2686cdf0e10cSrcweir
2687cdf0e10cSrcweir if ( uFieldMask & osl_FileStatus_Mask_FileURL )
2688cdf0e10cSrcweir {
2689cdf0e10cSrcweir rtl_uString *ustrSystemPath = NULL;
2690cdf0e10cSrcweir
2691cdf0e10cSrcweir rtl_uString_newFromStr( &ustrSystemPath, pItemImpl->ustrDrive->buffer );
2692cdf0e10cSrcweir osl_getFileURLFromSystemPath( ustrSystemPath, &pStatus->ustrFileURL );
2693cdf0e10cSrcweir rtl_uString_release( ustrSystemPath );
2694cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_FileURL;
2695cdf0e10cSrcweir }
2696cdf0e10cSrcweir
2697cdf0e10cSrcweir return osl_File_E_None;
2698cdf0e10cSrcweir }
2699cdf0e10cSrcweir
osl_getFileStatus(oslDirectoryItem Item,oslFileStatus * pStatus,sal_uInt32 uFieldMask)2700cdf0e10cSrcweir oslFileError SAL_CALL osl_getFileStatus(
2701cdf0e10cSrcweir oslDirectoryItem Item,
2702cdf0e10cSrcweir oslFileStatus *pStatus,
2703cdf0e10cSrcweir sal_uInt32 uFieldMask )
2704cdf0e10cSrcweir {
2705cdf0e10cSrcweir DirectoryItem_Impl *pItemImpl = (DirectoryItem_Impl *)Item;
2706cdf0e10cSrcweir struct stat file_stat;
2707cdf0e10cSrcweir
2708cdf0e10cSrcweir if ( !pItemImpl )
2709cdf0e10cSrcweir return osl_File_E_INVAL;
2710cdf0e10cSrcweir
2711cdf0e10cSrcweir if ( pItemImpl->uType == DIRECTORYITEM_DRIVE)
2712cdf0e10cSrcweir return _osl_getDriveInfo( Item, pStatus, uFieldMask );
2713cdf0e10cSrcweir
2714cdf0e10cSrcweir osl::lstat(pItemImpl->ustrFilePath, file_stat);
2715cdf0e10cSrcweir if ( uFieldMask & osl_FileStatus_Mask_Validate )
2716cdf0e10cSrcweir {
2717cdf0e10cSrcweir uFieldMask &= ~ osl_FileStatus_Mask_Validate;
2718cdf0e10cSrcweir }
2719cdf0e10cSrcweir
2720cdf0e10cSrcweir /* If no fields to retrieve left ignore pStatus */
2721cdf0e10cSrcweir if ( !uFieldMask )
2722cdf0e10cSrcweir return osl_File_E_None;
2723cdf0e10cSrcweir
2724cdf0e10cSrcweir /* Otherwise, this must be a valid pointer */
2725cdf0e10cSrcweir if ( !pStatus )
2726cdf0e10cSrcweir return osl_File_E_INVAL;
2727cdf0e10cSrcweir
2728cdf0e10cSrcweir if ( pStatus->uStructSize != sizeof(oslFileStatus) )
2729cdf0e10cSrcweir return osl_File_E_INVAL;
2730cdf0e10cSrcweir
2731cdf0e10cSrcweir pStatus->uValidFields = 0;
2732cdf0e10cSrcweir
2733cdf0e10cSrcweir /* File time stamps */
2734cdf0e10cSrcweir
2735cdf0e10cSrcweir if ( (uFieldMask & osl_FileStatus_Mask_ModifyTime))
2736cdf0e10cSrcweir {
2737cdf0e10cSrcweir pStatus->aModifyTime.Seconds = file_stat.st_mtime;
2738cdf0e10cSrcweir pStatus->aModifyTime.Nanosec = 0;
2739cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_ModifyTime;
2740cdf0e10cSrcweir }
2741cdf0e10cSrcweir
2742cdf0e10cSrcweir if ( (uFieldMask & osl_FileStatus_Mask_AccessTime))
2743cdf0e10cSrcweir {
2744cdf0e10cSrcweir pStatus->aAccessTime.Seconds = file_stat.st_atime;
2745cdf0e10cSrcweir pStatus->aAccessTime.Nanosec = 0;
2746cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_AccessTime;
2747cdf0e10cSrcweir }
2748cdf0e10cSrcweir
2749cdf0e10cSrcweir if ( (uFieldMask & osl_FileStatus_Mask_CreationTime))
2750cdf0e10cSrcweir {
2751cdf0e10cSrcweir pStatus->aAccessTime.Seconds = file_stat.st_birthtime;
2752cdf0e10cSrcweir pStatus->aAccessTime.Nanosec = 0;
2753cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_CreationTime;
2754cdf0e10cSrcweir }
2755cdf0e10cSrcweir
2756cdf0e10cSrcweir /* Most of the fields are already set, regardless of requiered fields */
2757cdf0e10cSrcweir
2758cdf0e10cSrcweir osl_systemPathGetFileNameOrLastDirectoryPart(pItemImpl->ustrFilePath, &pStatus->ustrFileName);
2759cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_FileName;
2760cdf0e10cSrcweir
2761cdf0e10cSrcweir if (S_ISLNK(file_stat.st_mode))
2762cdf0e10cSrcweir pStatus->eType = osl_File_Type_Link;
2763cdf0e10cSrcweir else if (S_ISDIR(file_stat.st_mode))
2764cdf0e10cSrcweir pStatus->eType = osl_File_Type_Directory;
2765cdf0e10cSrcweir else if (S_ISREG(file_stat.st_mode))
2766cdf0e10cSrcweir pStatus->eType = osl_File_Type_Regular;
2767cdf0e10cSrcweir else if (S_ISFIFO(file_stat.st_mode))
2768cdf0e10cSrcweir pStatus->eType = osl_File_Type_Fifo;
2769cdf0e10cSrcweir else if (S_ISSOCK(file_stat.st_mode))
2770cdf0e10cSrcweir pStatus->eType = osl_File_Type_Socket;
2771cdf0e10cSrcweir else if (S_ISCHR(file_stat.st_mode) || S_ISBLK(file_stat.st_mode))
2772cdf0e10cSrcweir pStatus->eType = osl_File_Type_Special;
2773cdf0e10cSrcweir else
2774cdf0e10cSrcweir pStatus->eType = osl_File_Type_Unknown;
2775cdf0e10cSrcweir
2776cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_Type;
2777cdf0e10cSrcweir
2778cdf0e10cSrcweir pStatus->uAttributes = pItemImpl->d_attr;
2779cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_Attributes;
2780cdf0e10cSrcweir
2781cdf0e10cSrcweir pStatus->uFileSize = file_stat.st_size;
2782cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_FileSize;
2783cdf0e10cSrcweir
2784cdf0e10cSrcweir if ( uFieldMask & osl_FileStatus_Mask_LinkTargetURL )
2785cdf0e10cSrcweir {
2786cdf0e10cSrcweir rtl_uString *ustrFullPath = NULL;
2787cdf0e10cSrcweir
2788cdf0e10cSrcweir rtl_uString_newFromStr( &ustrFullPath, rtl_uString_getStr(pItemImpl->ustrFilePath) );
2789cdf0e10cSrcweir osl_getFileURLFromSystemPath( ustrFullPath, &pStatus->ustrLinkTargetURL );
2790cdf0e10cSrcweir rtl_uString_release( ustrFullPath );
2791cdf0e10cSrcweir
2792cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_LinkTargetURL;
2793cdf0e10cSrcweir }
2794cdf0e10cSrcweir
2795cdf0e10cSrcweir if ( uFieldMask & osl_FileStatus_Mask_FileURL )
2796cdf0e10cSrcweir {
2797cdf0e10cSrcweir rtl_uString *ustrFullPath = NULL;
2798cdf0e10cSrcweir
2799cdf0e10cSrcweir rtl_uString_newFromStr( &ustrFullPath, rtl_uString_getStr(pItemImpl->ustrFilePath) );
2800cdf0e10cSrcweir osl_getFileURLFromSystemPath( ustrFullPath, &pStatus->ustrFileURL );
2801cdf0e10cSrcweir rtl_uString_release( ustrFullPath );
2802cdf0e10cSrcweir pStatus->uValidFields |= osl_FileStatus_Mask_FileURL;
2803cdf0e10cSrcweir }
2804cdf0e10cSrcweir
2805cdf0e10cSrcweir return osl_File_E_None;
2806cdf0e10cSrcweir }
2807cdf0e10cSrcweir
2808cdf0e10cSrcweir /****************************************************************************/
2809cdf0e10cSrcweir /* osl_createDirectory */
2810cdf0e10cSrcweir /****************************************************************************/
2811cdf0e10cSrcweir
osl_createDirectory(rtl_uString * ustrDirectoryURL)2812cdf0e10cSrcweir oslFileError osl_createDirectory( rtl_uString* ustrDirectoryURL )
2813cdf0e10cSrcweir {
2814cdf0e10cSrcweir char path[PATH_MAX];
2815cdf0e10cSrcweir oslFileError eRet;
2816cdf0e10cSrcweir APIRET rc;
2817cdf0e10cSrcweir
2818cdf0e10cSrcweir OSL_ASSERT( ustrDirectoryURL );
2819cdf0e10cSrcweir
2820cdf0e10cSrcweir /* convert directory url to system path */
2821cdf0e10cSrcweir eRet = FileURLToPath( path, PATH_MAX, ustrDirectoryURL );
2822cdf0e10cSrcweir if( eRet != osl_File_E_None )
2823cdf0e10cSrcweir return eRet;
2824cdf0e10cSrcweir
2825cdf0e10cSrcweir rc = DosCreateDir( (PCSZ)path, NULL);
2826cdf0e10cSrcweir if (rc == ERROR_ACCESS_DENIED)
2827cdf0e10cSrcweir rc=ERROR_FILE_EXISTS;
2828cdf0e10cSrcweir
2829cdf0e10cSrcweir if (!rc)
2830cdf0e10cSrcweir eRet = osl_File_E_None;
2831cdf0e10cSrcweir else
2832cdf0e10cSrcweir eRet = MapError( rc);
2833cdf0e10cSrcweir
2834cdf0e10cSrcweir return eRet;
2835cdf0e10cSrcweir }
2836cdf0e10cSrcweir
2837cdf0e10cSrcweir /****************************************************************************/
2838cdf0e10cSrcweir /* osl_removeDirectory */
2839cdf0e10cSrcweir /****************************************************************************/
2840cdf0e10cSrcweir
osl_removeDirectory(rtl_uString * ustrDirectoryURL)2841cdf0e10cSrcweir oslFileError osl_removeDirectory( rtl_uString* ustrDirectoryURL )
2842cdf0e10cSrcweir {
2843cdf0e10cSrcweir char path[PATH_MAX];
2844cdf0e10cSrcweir oslFileError eRet;
2845cdf0e10cSrcweir APIRET rc;
2846cdf0e10cSrcweir
2847cdf0e10cSrcweir OSL_ASSERT( ustrDirectoryURL );
2848cdf0e10cSrcweir
2849cdf0e10cSrcweir /* convert directory url to system path */
2850cdf0e10cSrcweir eRet = FileURLToPath( path, PATH_MAX, ustrDirectoryURL );
2851cdf0e10cSrcweir if( eRet != osl_File_E_None )
2852cdf0e10cSrcweir return eRet;
2853cdf0e10cSrcweir
2854cdf0e10cSrcweir rc = DosDeleteDir( (PCSZ)path);
2855cdf0e10cSrcweir if (!rc)
2856cdf0e10cSrcweir eRet = osl_File_E_None;
2857cdf0e10cSrcweir else
2858cdf0e10cSrcweir eRet = MapError( rc);
2859cdf0e10cSrcweir
2860cdf0e10cSrcweir return eRet;
2861cdf0e10cSrcweir }
2862cdf0e10cSrcweir
2863cdf0e10cSrcweir //#############################################
path_make_parent(sal_Unicode * path)2864cdf0e10cSrcweir int path_make_parent(sal_Unicode* path)
2865cdf0e10cSrcweir {
2866cdf0e10cSrcweir int i = rtl_ustr_lastIndexOfChar(path, '/');
2867*336e7b3aSPedro Giffuni if (i == -1)
2868*336e7b3aSPedro Giffuni i = rtl_ustr_lastIndexOfChar(path, '\\');
2869cdf0e10cSrcweir
2870cdf0e10cSrcweir if (i > 0)
2871cdf0e10cSrcweir {
2872cdf0e10cSrcweir *(path + i) = 0;
2873cdf0e10cSrcweir return i;
2874cdf0e10cSrcweir }
2875cdf0e10cSrcweir else
2876cdf0e10cSrcweir return 0;
2877cdf0e10cSrcweir }
2878cdf0e10cSrcweir
2879cdf0e10cSrcweir //#############################################
create_dir_with_callback(sal_Unicode * directory_path,oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,void * pData)2880cdf0e10cSrcweir int create_dir_with_callback(
2881cdf0e10cSrcweir sal_Unicode* directory_path,
2882cdf0e10cSrcweir oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
2883cdf0e10cSrcweir void* pData)
2884cdf0e10cSrcweir {
2885cdf0e10cSrcweir int mode = S_IRWXU | S_IRWXG | S_IRWXO;
2886cdf0e10cSrcweir
2887cdf0e10cSrcweir if (osl::mkdir(directory_path, mode) == 0)
2888cdf0e10cSrcweir {
2889cdf0e10cSrcweir if (aDirectoryCreationCallbackFunc)
2890cdf0e10cSrcweir {
2891cdf0e10cSrcweir rtl::OUString url;
2892cdf0e10cSrcweir osl::FileBase::getFileURLFromSystemPath(directory_path, url);
2893cdf0e10cSrcweir aDirectoryCreationCallbackFunc(pData, url.pData);
2894cdf0e10cSrcweir }
2895cdf0e10cSrcweir return 0;
2896cdf0e10cSrcweir }
2897cdf0e10cSrcweir return errno;
2898cdf0e10cSrcweir }
2899cdf0e10cSrcweir
2900cdf0e10cSrcweir //#############################################
create_dir_recursively_(sal_Unicode * dir_path,oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,void * pData)2901cdf0e10cSrcweir oslFileError create_dir_recursively_(
2902cdf0e10cSrcweir sal_Unicode* dir_path,
2903cdf0e10cSrcweir oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
2904cdf0e10cSrcweir void* pData)
2905cdf0e10cSrcweir {
2906cdf0e10cSrcweir OSL_PRECOND((rtl_ustr_getLength(dir_path) > 0) && ((dir_path + (rtl_ustr_getLength(dir_path) - 1)) != (dir_path + rtl_ustr_lastIndexOfChar(dir_path, '/'))), \
2907cdf0e10cSrcweir "Path must not end with a slash");
2908cdf0e10cSrcweir
2909cdf0e10cSrcweir int native_err = create_dir_with_callback(
2910cdf0e10cSrcweir dir_path, aDirectoryCreationCallbackFunc, pData);
2911cdf0e10cSrcweir
2912cdf0e10cSrcweir if (native_err == 0)
2913cdf0e10cSrcweir return osl_File_E_None;
2914cdf0e10cSrcweir
2915cdf0e10cSrcweir if (native_err != ENOENT)
2916cdf0e10cSrcweir return oslTranslateFileError(OSL_FET_ERROR, native_err);
2917cdf0e10cSrcweir
2918cdf0e10cSrcweir // we step back until '/a_dir' at maximum because
2919cdf0e10cSrcweir // we should get an error unequal ENOENT when
2920cdf0e10cSrcweir // we try to create 'a_dir' at '/' and would so
2921cdf0e10cSrcweir // return before
2922cdf0e10cSrcweir int pos = path_make_parent(dir_path);
2923cdf0e10cSrcweir
2924cdf0e10cSrcweir oslFileError osl_error = create_dir_recursively_(
2925cdf0e10cSrcweir dir_path, aDirectoryCreationCallbackFunc, pData);
2926cdf0e10cSrcweir
2927cdf0e10cSrcweir if (osl_File_E_None != osl_error)
2928cdf0e10cSrcweir return osl_error;
2929cdf0e10cSrcweir
2930cdf0e10cSrcweir dir_path[pos] = '/';
2931cdf0e10cSrcweir
2932cdf0e10cSrcweir return create_dir_recursively_(dir_path, aDirectoryCreationCallbackFunc, pData);
2933cdf0e10cSrcweir }
2934cdf0e10cSrcweir
2935cdf0e10cSrcweir //#######################################
osl_createDirectoryPath(rtl_uString * aDirectoryUrl,oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,void * pData)2936cdf0e10cSrcweir oslFileError SAL_CALL osl_createDirectoryPath(
2937cdf0e10cSrcweir rtl_uString* aDirectoryUrl,
2938cdf0e10cSrcweir oslDirectoryCreationCallbackFunc aDirectoryCreationCallbackFunc,
2939cdf0e10cSrcweir void* pData)
2940cdf0e10cSrcweir {
2941cdf0e10cSrcweir if (aDirectoryUrl == NULL)
2942cdf0e10cSrcweir return osl_File_E_INVAL;
2943cdf0e10cSrcweir
2944cdf0e10cSrcweir rtl::OUString sys_path;
2945cdf0e10cSrcweir oslFileError osl_error = osl_getSystemPathFromFileURL_Ex(
2946cdf0e10cSrcweir aDirectoryUrl, &sys_path.pData, sal_False);
2947cdf0e10cSrcweir
2948cdf0e10cSrcweir if (osl_error != osl_File_E_None)
2949cdf0e10cSrcweir return osl_error;
2950cdf0e10cSrcweir
2951cdf0e10cSrcweir osl::systemPathRemoveSeparator(sys_path);
2952cdf0e10cSrcweir
2953cdf0e10cSrcweir // const_cast because sys_path is a local copy which we want to modify inplace instead of
2954cdf0e10cSrcweir // coyp it into another buffer on the heap again
2955cdf0e10cSrcweir return create_dir_recursively_(sys_path.pData->buffer, aDirectoryCreationCallbackFunc, pData);
2956cdf0e10cSrcweir }
2957cdf0e10cSrcweir
2958cdf0e10cSrcweir /****************************************************************************/
2959cdf0e10cSrcweir /* osl_getCanonicalName */
2960cdf0e10cSrcweir /****************************************************************************/
2961cdf0e10cSrcweir
osl_getCanonicalName(rtl_uString * ustrFileURL,rtl_uString ** pustrValidURL)2962cdf0e10cSrcweir oslFileError osl_getCanonicalName( rtl_uString* ustrFileURL, rtl_uString** pustrValidURL )
2963cdf0e10cSrcweir {
2964cdf0e10cSrcweir OSL_ENSURE(sal_False, "osl_getCanonicalName not implemented");
2965cdf0e10cSrcweir
2966cdf0e10cSrcweir rtl_uString_newFromString(pustrValidURL, ustrFileURL);
2967cdf0e10cSrcweir return osl_File_E_None;
2968cdf0e10cSrcweir }
2969cdf0e10cSrcweir
2970cdf0e10cSrcweir
2971cdf0e10cSrcweir /****************************************************************************/
2972cdf0e10cSrcweir /* osl_setFileAttributes */
2973cdf0e10cSrcweir /****************************************************************************/
2974cdf0e10cSrcweir
osl_setFileAttributes(rtl_uString * ustrFileURL,sal_uInt64 uAttributes)2975cdf0e10cSrcweir oslFileError osl_setFileAttributes( rtl_uString* ustrFileURL, sal_uInt64 uAttributes )
2976cdf0e10cSrcweir {
2977cdf0e10cSrcweir char path[PATH_MAX];
2978cdf0e10cSrcweir oslFileError eRet;
2979cdf0e10cSrcweir FILESTATUS3 fsts3ConfigInfo;
2980cdf0e10cSrcweir ULONG ulBufSize = sizeof(FILESTATUS3);
2981cdf0e10cSrcweir APIRET rc = NO_ERROR;
2982cdf0e10cSrcweir
2983cdf0e10cSrcweir OSL_ASSERT( ustrFileURL );
2984cdf0e10cSrcweir
2985cdf0e10cSrcweir /* convert file url to system path */
2986cdf0e10cSrcweir eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
2987cdf0e10cSrcweir if( eRet != osl_File_E_None )
2988cdf0e10cSrcweir return eRet;
2989cdf0e10cSrcweir
2990cdf0e10cSrcweir /* query current attributes */
2991cdf0e10cSrcweir rc = DosQueryPathInfo( (PCSZ)path, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize);
2992cdf0e10cSrcweir if (rc != NO_ERROR)
2993cdf0e10cSrcweir return MapError( rc);
2994cdf0e10cSrcweir
2995cdf0e10cSrcweir /* set/reset readonly/hidden (see w32\file.cxx) */
2996cdf0e10cSrcweir fsts3ConfigInfo.attrFile &= ~(FILE_READONLY | FILE_HIDDEN);
2997cdf0e10cSrcweir if ( uAttributes & osl_File_Attribute_ReadOnly )
2998cdf0e10cSrcweir fsts3ConfigInfo.attrFile |= FILE_READONLY;
2999cdf0e10cSrcweir if ( uAttributes & osl_File_Attribute_Hidden )
3000cdf0e10cSrcweir fsts3ConfigInfo.attrFile |= FILE_HIDDEN;
3001cdf0e10cSrcweir
3002cdf0e10cSrcweir /* write new attributes */
3003cdf0e10cSrcweir rc = DosSetPathInfo( (PCSZ)path, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize, 0);
3004cdf0e10cSrcweir if (rc != NO_ERROR)
3005cdf0e10cSrcweir return MapError( rc);
3006cdf0e10cSrcweir
3007cdf0e10cSrcweir /* everything ok */
3008cdf0e10cSrcweir return osl_File_E_None;
3009cdf0e10cSrcweir }
3010cdf0e10cSrcweir
3011cdf0e10cSrcweir /****************************************************************************/
3012cdf0e10cSrcweir /* osl_setFileTime */
3013cdf0e10cSrcweir /****************************************************************************/
3014cdf0e10cSrcweir
osl_setFileTime(rtl_uString * ustrFileURL,const TimeValue * pCreationTime,const TimeValue * pLastAccessTime,const TimeValue * pLastWriteTime)3015cdf0e10cSrcweir oslFileError osl_setFileTime( rtl_uString* ustrFileURL, const TimeValue* pCreationTime,
3016cdf0e10cSrcweir const TimeValue* pLastAccessTime, const TimeValue* pLastWriteTime )
3017cdf0e10cSrcweir {
3018cdf0e10cSrcweir char path[PATH_MAX];
3019cdf0e10cSrcweir oslFileError eRet;
3020cdf0e10cSrcweir
3021cdf0e10cSrcweir OSL_ASSERT( ustrFileURL );
3022cdf0e10cSrcweir
3023cdf0e10cSrcweir /* convert file url to system path */
3024cdf0e10cSrcweir eRet = FileURLToPath( path, PATH_MAX, ustrFileURL );
3025cdf0e10cSrcweir if( eRet != osl_File_E_None )
3026cdf0e10cSrcweir return eRet;
3027cdf0e10cSrcweir
3028cdf0e10cSrcweir return osl_psz_setFileTime( path, pCreationTime, pLastAccessTime, pLastWriteTime );
3029cdf0e10cSrcweir }
3030cdf0e10cSrcweir
3031cdf0e10cSrcweir /******************************************************************************
3032cdf0e10cSrcweir *
3033cdf0e10cSrcweir * Exported Module Functions
3034cdf0e10cSrcweir * (independent of C or Unicode Strings)
3035cdf0e10cSrcweir *
3036cdf0e10cSrcweir *****************************************************************************/
3037cdf0e10cSrcweir
3038cdf0e10cSrcweir
3039cdf0e10cSrcweir
3040dcc6e752SPedro Giffuni /******************************************************************************
3041dcc6e752SPedro Giffuni *
3042dcc6e752SPedro Giffuni * C-String Versions of Exported Module Functions
3043dcc6e752SPedro Giffuni *
3044dcc6e752SPedro Giffuni *****************************************************************************/
3045cdf0e10cSrcweir
3046cdf0e10cSrcweir
3047dcc6e752SPedro Giffuni /******************************************
3048dcc6e752SPedro Giffuni * osl_psz_setFileTime
3049dcc6e752SPedro Giffuni *****************************************/
3050cdf0e10cSrcweir
osl_psz_setFileTime(const sal_Char * pszFilePath,const TimeValue *,const TimeValue * pLastAccessTime,const TimeValue * pLastWriteTime)3051dcc6e752SPedro Giffuni static oslFileError osl_psz_setFileTime( const sal_Char* pszFilePath,
3052dcc6e752SPedro Giffuni const TimeValue* /*pCreationTime*/,
3053dcc6e752SPedro Giffuni const TimeValue* pLastAccessTime,
3054dcc6e752SPedro Giffuni const TimeValue* pLastWriteTime )
3055cdf0e10cSrcweir {
3056dcc6e752SPedro Giffuni int nRet=0;
3057dcc6e752SPedro Giffuni struct utimbuf aTimeBuffer;
3058dcc6e752SPedro Giffuni struct stat aFileStat;
3059dcc6e752SPedro Giffuni #ifdef DEBUG_OSL_FILE
3060dcc6e752SPedro Giffuni struct tm* pTM=0;
3061dcc6e752SPedro Giffuni #endif
3062cdf0e10cSrcweir
3063dcc6e752SPedro Giffuni nRet = lstat(pszFilePath,&aFileStat);
3064cdf0e10cSrcweir
3065cdf0e10cSrcweir if ( nRet < 0 )
3066cdf0e10cSrcweir {
3067cdf0e10cSrcweir nRet=errno;
3068cdf0e10cSrcweir return oslTranslateFileError(OSL_FET_ERROR, nRet);
3069cdf0e10cSrcweir }
3070cdf0e10cSrcweir
3071dcc6e752SPedro Giffuni #ifdef DEBUG_OSL_FILE
3072dcc6e752SPedro Giffuni fprintf(stderr,"File Times are (in localtime):\n");
3073dcc6e752SPedro Giffuni pTM=localtime(&aFileStat.st_ctime);
3074dcc6e752SPedro Giffuni fprintf(stderr,"CreationTime is '%s'\n",asctime(pTM));
3075dcc6e752SPedro Giffuni pTM=localtime(&aFileStat.st_atime);
3076dcc6e752SPedro Giffuni fprintf(stderr,"AccessTime is '%s'\n",asctime(pTM));
3077dcc6e752SPedro Giffuni pTM=localtime(&aFileStat.st_mtime);
3078dcc6e752SPedro Giffuni fprintf(stderr,"Modification is '%s'\n",asctime(pTM));
3079cdf0e10cSrcweir
3080dcc6e752SPedro Giffuni fprintf(stderr,"File Times are (in UTC):\n");
3081dcc6e752SPedro Giffuni fprintf(stderr,"CreationTime is '%s'\n",ctime(&aFileStat.st_ctime));
3082dcc6e752SPedro Giffuni fprintf(stderr,"AccessTime is '%s'\n",ctime(&aTimeBuffer.actime));
3083dcc6e752SPedro Giffuni fprintf(stderr,"Modification is '%s'\n",ctime(&aTimeBuffer.modtime));
3084dcc6e752SPedro Giffuni #endif
3085cdf0e10cSrcweir
3086dcc6e752SPedro Giffuni if ( pLastAccessTime != 0 )
3087cdf0e10cSrcweir {
3088dcc6e752SPedro Giffuni aTimeBuffer.actime=pLastAccessTime->Seconds;
3089cdf0e10cSrcweir }
3090dcc6e752SPedro Giffuni else
3091cdf0e10cSrcweir {
3092dcc6e752SPedro Giffuni aTimeBuffer.actime=aFileStat.st_atime;
3093cdf0e10cSrcweir }
3094cdf0e10cSrcweir
3095dcc6e752SPedro Giffuni if ( pLastWriteTime != 0 )
3096cdf0e10cSrcweir {
3097dcc6e752SPedro Giffuni aTimeBuffer.modtime=pLastWriteTime->Seconds;
3098cdf0e10cSrcweir }
3099cdf0e10cSrcweir else
3100cdf0e10cSrcweir {
3101dcc6e752SPedro Giffuni aTimeBuffer.modtime=aFileStat.st_mtime;
3102cdf0e10cSrcweir }
3103cdf0e10cSrcweir
3104dcc6e752SPedro Giffuni /* mfe: Creation time not used here! */
3105cdf0e10cSrcweir
3106dcc6e752SPedro Giffuni #ifdef DEBUG_OSL_FILE
3107dcc6e752SPedro Giffuni fprintf(stderr,"File Times are (in localtime):\n");
3108dcc6e752SPedro Giffuni pTM=localtime(&aFileStat.st_ctime);
3109dcc6e752SPedro Giffuni fprintf(stderr,"CreationTime now '%s'\n",asctime(pTM));
3110dcc6e752SPedro Giffuni pTM=localtime(&aTimeBuffer.actime);
3111dcc6e752SPedro Giffuni fprintf(stderr,"AccessTime now '%s'\n",asctime(pTM));
3112dcc6e752SPedro Giffuni pTM=localtime(&aTimeBuffer.modtime);
3113dcc6e752SPedro Giffuni fprintf(stderr,"Modification now '%s'\n",asctime(pTM));
3114dcc6e752SPedro Giffuni
3115dcc6e752SPedro Giffuni fprintf(stderr,"File Times are (in UTC):\n");
3116dcc6e752SPedro Giffuni fprintf(stderr,"CreationTime now '%s'\n",ctime(&aFileStat.st_ctime));
3117dcc6e752SPedro Giffuni fprintf(stderr,"AccessTime now '%s'\n",ctime(&aTimeBuffer.actime));
3118dcc6e752SPedro Giffuni fprintf(stderr,"Modification now '%s'\n",ctime(&aTimeBuffer.modtime));
3119dcc6e752SPedro Giffuni #endif
3120dcc6e752SPedro Giffuni
3121dcc6e752SPedro Giffuni nRet=utime(pszFilePath,&aTimeBuffer);
3122dcc6e752SPedro Giffuni if ( nRet < 0 )
3123cdf0e10cSrcweir {
3124dcc6e752SPedro Giffuni nRet=errno;
3125dcc6e752SPedro Giffuni return oslTranslateFileError(OSL_FET_ERROR, nRet);
3126cdf0e10cSrcweir }
3127cdf0e10cSrcweir
3128dcc6e752SPedro Giffuni return osl_File_E_None;
3129cdf0e10cSrcweir }
3130dcc6e752SPedro Giffuni
3131cdf0e10cSrcweir
3132cdf0e10cSrcweir /******************************************************************************
3133cdf0e10cSrcweir *
3134cdf0e10cSrcweir * Utility Functions
3135cdf0e10cSrcweir *
3136cdf0e10cSrcweir *****************************************************************************/
3137cdf0e10cSrcweir
3138cdf0e10cSrcweir
3139cdf0e10cSrcweir /*****************************************
3140cdf0e10cSrcweir * oslMakeUStrFromPsz
3141cdf0e10cSrcweir ****************************************/
3142cdf0e10cSrcweir
oslMakeUStrFromPsz(const sal_Char * pszStr,rtl_uString ** ustrValid)3143cdf0e10cSrcweir rtl_uString* oslMakeUStrFromPsz(const sal_Char* pszStr, rtl_uString** ustrValid)
3144cdf0e10cSrcweir {
3145cdf0e10cSrcweir rtl_string2UString(
3146cdf0e10cSrcweir ustrValid,
3147cdf0e10cSrcweir pszStr,
3148cdf0e10cSrcweir rtl_str_getLength( pszStr ),
3149cdf0e10cSrcweir osl_getThreadTextEncoding(),
3150cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS );
3151cdf0e10cSrcweir OSL_ASSERT(*ustrValid != 0);
3152cdf0e10cSrcweir
3153cdf0e10cSrcweir return *ustrValid;
3154cdf0e10cSrcweir }
3155cdf0e10cSrcweir
3156cdf0e10cSrcweir /*****************************************************************************
3157cdf0e10cSrcweir * UnicodeToText
3158cdf0e10cSrcweir * converting unicode to text manually saves us the penalty of a temporary
3159cdf0e10cSrcweir * rtl_String object.
3160cdf0e10cSrcweir ****************************************************************************/
3161cdf0e10cSrcweir
UnicodeToText(char * buffer,size_t bufLen,const sal_Unicode * uniText,sal_Int32 uniTextLen)3162cdf0e10cSrcweir int UnicodeToText( char * buffer, size_t bufLen, const sal_Unicode * uniText, sal_Int32 uniTextLen )
3163cdf0e10cSrcweir {
3164cdf0e10cSrcweir rtl_UnicodeToTextConverter hConverter;
3165cdf0e10cSrcweir sal_uInt32 nInfo;
3166cdf0e10cSrcweir sal_Size nSrcChars, nDestBytes;
3167cdf0e10cSrcweir
3168cdf0e10cSrcweir /* stolen from rtl/string.c */
3169cdf0e10cSrcweir hConverter = rtl_createUnicodeToTextConverter( osl_getThreadTextEncoding() );
3170cdf0e10cSrcweir
3171cdf0e10cSrcweir nDestBytes = rtl_convertUnicodeToText( hConverter, 0, uniText, uniTextLen,
3172cdf0e10cSrcweir buffer, bufLen,
3173cdf0e10cSrcweir OUSTRING_TO_OSTRING_CVTFLAGS | RTL_UNICODETOTEXT_FLAGS_FLUSH,
3174cdf0e10cSrcweir &nInfo, &nSrcChars );
3175cdf0e10cSrcweir
3176cdf0e10cSrcweir rtl_destroyUnicodeToTextConverter( hConverter );
3177cdf0e10cSrcweir
3178cdf0e10cSrcweir if( nInfo & RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL )
3179cdf0e10cSrcweir {
3180cdf0e10cSrcweir errno = EOVERFLOW;
3181cdf0e10cSrcweir return 0;
3182cdf0e10cSrcweir }
3183cdf0e10cSrcweir
3184cdf0e10cSrcweir /* ensure trailing '\0' */
3185cdf0e10cSrcweir buffer[nDestBytes] = '\0';
3186cdf0e10cSrcweir
3187cdf0e10cSrcweir return nDestBytes;
3188cdf0e10cSrcweir }
3189cdf0e10cSrcweir
3190cdf0e10cSrcweir /*****************************************************************************
3191cdf0e10cSrcweir TextToUnicode
3192cdf0e10cSrcweir
3193cdf0e10cSrcweir @param text
3194cdf0e10cSrcweir The text to convert.
3195cdf0e10cSrcweir
3196cdf0e10cSrcweir @param text_buffer_size
3197cdf0e10cSrcweir The number of characters.
3198cdf0e10cSrcweir
3199cdf0e10cSrcweir @param unic_text
3200cdf0e10cSrcweir The unicode buffer.
3201cdf0e10cSrcweir
3202cdf0e10cSrcweir @param unic_text_buffer_size
3203cdf0e10cSrcweir The size in characters of the unicode buffer.
3204cdf0e10cSrcweir
3205cdf0e10cSrcweir ****************************************************************************/
3206cdf0e10cSrcweir
TextToUnicode(const char * text,size_t text_buffer_size,sal_Unicode * unic_text,sal_Int32 unic_text_buffer_size)3207cdf0e10cSrcweir int TextToUnicode(
3208cdf0e10cSrcweir const char* text,
3209cdf0e10cSrcweir size_t text_buffer_size,
3210cdf0e10cSrcweir sal_Unicode* unic_text,
3211cdf0e10cSrcweir sal_Int32 unic_text_buffer_size)
3212cdf0e10cSrcweir {
3213cdf0e10cSrcweir rtl_TextToUnicodeConverter hConverter;
3214cdf0e10cSrcweir sal_uInt32 nInfo;
3215cdf0e10cSrcweir sal_Size nSrcChars;
3216cdf0e10cSrcweir sal_Size nDestBytes;
3217cdf0e10cSrcweir
3218cdf0e10cSrcweir /* stolen from rtl/string.c */
3219cdf0e10cSrcweir hConverter = rtl_createTextToUnicodeConverter(osl_getThreadTextEncoding());
3220cdf0e10cSrcweir
3221cdf0e10cSrcweir nDestBytes = rtl_convertTextToUnicode(hConverter,
3222cdf0e10cSrcweir 0,
3223cdf0e10cSrcweir text, text_buffer_size,
3224cdf0e10cSrcweir unic_text, unic_text_buffer_size,
3225cdf0e10cSrcweir OSTRING_TO_OUSTRING_CVTFLAGS | RTL_TEXTTOUNICODE_FLAGS_FLUSH,
3226cdf0e10cSrcweir &nInfo, &nSrcChars);
3227cdf0e10cSrcweir
3228cdf0e10cSrcweir rtl_destroyTextToUnicodeConverter(hConverter);
3229cdf0e10cSrcweir
3230cdf0e10cSrcweir if (nInfo & RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOSMALL)
3231cdf0e10cSrcweir {
3232cdf0e10cSrcweir errno = EOVERFLOW;
3233cdf0e10cSrcweir return 0;
3234cdf0e10cSrcweir }
3235cdf0e10cSrcweir
3236cdf0e10cSrcweir /* ensure trailing '\0' */
3237cdf0e10cSrcweir unic_text[nDestBytes] = '\0';
3238cdf0e10cSrcweir
3239cdf0e10cSrcweir return nDestBytes;
3240cdf0e10cSrcweir }
3241cdf0e10cSrcweir
3242cdf0e10cSrcweir /******************************************************************************
3243cdf0e10cSrcweir *
3244cdf0e10cSrcweir * GENERIC FLOPPY FUNCTIONS
3245cdf0e10cSrcweir *
3246cdf0e10cSrcweir *****************************************************************************/
3247cdf0e10cSrcweir
3248cdf0e10cSrcweir /*****************************************
3249cdf0e10cSrcweir * osl_unmountVolumeDevice
3250cdf0e10cSrcweir ****************************************/
osl_unmountVolumeDevice(oslVolumeDeviceHandle Handle)3251cdf0e10cSrcweir oslFileError osl_unmountVolumeDevice( oslVolumeDeviceHandle Handle )
3252cdf0e10cSrcweir {
3253dcc6e752SPedro Giffuni if ( Handle )
3254dcc6e752SPedro Giffuni return osl_File_E_None;
3255dcc6e752SPedro Giffuni else
3256dcc6e752SPedro Giffuni return osl_File_E_INVAL;
3257cdf0e10cSrcweir }
3258cdf0e10cSrcweir
3259cdf0e10cSrcweir /*****************************************
3260cdf0e10cSrcweir * osl_automountVolumeDevice
3261cdf0e10cSrcweir ****************************************/
osl_automountVolumeDevice(oslVolumeDeviceHandle Handle)3262cdf0e10cSrcweir oslFileError osl_automountVolumeDevice( oslVolumeDeviceHandle Handle )
3263cdf0e10cSrcweir {
3264dcc6e752SPedro Giffuni if ( Handle )
3265dcc6e752SPedro Giffuni return osl_File_E_None;
3266dcc6e752SPedro Giffuni else
3267dcc6e752SPedro Giffuni return osl_File_E_INVAL;
3268cdf0e10cSrcweir }
3269cdf0e10cSrcweir
3270cdf0e10cSrcweir /*****************************************
3271cdf0e10cSrcweir * osl_getVolumeDeviceMountPath
3272cdf0e10cSrcweir ****************************************/
osl_getVolumeDeviceMountPath(oslVolumeDeviceHandle Handle,rtl_uString ** pstrPath)3273cdf0e10cSrcweir oslFileError osl_getVolumeDeviceMountPath( oslVolumeDeviceHandle Handle, rtl_uString **pstrPath )
3274cdf0e10cSrcweir {
3275dcc6e752SPedro Giffuni if ( Handle && pstrPath )
3276dcc6e752SPedro Giffuni {
3277dcc6e752SPedro Giffuni rtl_uString_assign( pstrPath, (rtl_uString *)Handle );
3278dcc6e752SPedro Giffuni return osl_File_E_None;
3279dcc6e752SPedro Giffuni }
3280dcc6e752SPedro Giffuni else
3281dcc6e752SPedro Giffuni return osl_File_E_INVAL;
3282cdf0e10cSrcweir }
3283cdf0e10cSrcweir
3284cdf0e10cSrcweir /*****************************************
3285cdf0e10cSrcweir * osl_acquireVolumeDeviceHandle
3286cdf0e10cSrcweir ****************************************/
3287cdf0e10cSrcweir
osl_acquireVolumeDeviceHandle(oslVolumeDeviceHandle Handle)3288cdf0e10cSrcweir oslFileError SAL_CALL osl_acquireVolumeDeviceHandle( oslVolumeDeviceHandle Handle )
3289cdf0e10cSrcweir {
3290dcc6e752SPedro Giffuni if ( Handle )
3291dcc6e752SPedro Giffuni {
3292dcc6e752SPedro Giffuni rtl_uString_acquire( (rtl_uString *)Handle );
3293dcc6e752SPedro Giffuni return osl_File_E_None;
3294dcc6e752SPedro Giffuni }
3295dcc6e752SPedro Giffuni else
3296dcc6e752SPedro Giffuni return osl_File_E_INVAL;
3297cdf0e10cSrcweir }
3298cdf0e10cSrcweir
3299cdf0e10cSrcweir /*****************************************
3300cdf0e10cSrcweir * osl_releaseVolumeDeviceHandle
3301cdf0e10cSrcweir ****************************************/
3302cdf0e10cSrcweir
osl_releaseVolumeDeviceHandle(oslVolumeDeviceHandle Handle)3303cdf0e10cSrcweir oslFileError osl_releaseVolumeDeviceHandle( oslVolumeDeviceHandle Handle )
3304cdf0e10cSrcweir {
3305dcc6e752SPedro Giffuni if ( Handle )
3306dcc6e752SPedro Giffuni {
3307dcc6e752SPedro Giffuni rtl_uString_release( (rtl_uString *)Handle );
3308dcc6e752SPedro Giffuni return osl_File_E_None;
3309dcc6e752SPedro Giffuni }
3310dcc6e752SPedro Giffuni else
3311dcc6e752SPedro Giffuni return osl_File_E_INVAL;
3312cdf0e10cSrcweir }
3313cdf0e10cSrcweir
3314cdf0e10cSrcweir /******************************************************************************
3315cdf0e10cSrcweir *
3316cdf0e10cSrcweir * OS/2 FLOPPY FUNCTIONS
3317cdf0e10cSrcweir *
3318cdf0e10cSrcweir *****************************************************************************/
osl_isFloppyDrive(const sal_Char * pszPath)3319cdf0e10cSrcweir static oslVolumeDeviceHandle osl_isFloppyDrive(const sal_Char* pszPath)
3320cdf0e10cSrcweir {
3321cdf0e10cSrcweir return NULL;
3322cdf0e10cSrcweir }
3323cdf0e10cSrcweir
3324