| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
| * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| |
| #include<dirent.h> |
| |
| #include<errno.h> |
| #include<fcntl.h> |
| #include<malloc.h> |
| #include<string.h> |
| #include<sys/stat.h> |
| #include<sys/types.h> |
| #include<unistd.h> |
| |
| #include<android/fdsan.h> |
| |
| #include"private/bionic_fortify.h" |
| #include"private/ErrnoRestorer.h" |
| #include"private/ScopedPthreadMutexLocker.h" |
| |
| extern"C"int __getdents64(unsignedint, dirent*,unsignedint); |
| |
| // Apportable decided to copy the data structure from this file |
| // and use it in their own code, but they also call into readdir. |
| // In order to avoid a lockup, the structure must be maintained in |
| // the exact same order as in L and below. New structure members |
| // need to be added to the end of this structure. |
| // See b/21037208 for more details. |
| structDIR{ |
| int fd_; |
| size_t available_bytes_; |
| dirent* next_; |
| pthread_mutex_t mutex_; |
| dirent buff_[15]; |
| long current_pos_; |
| }; |
| |
| #define CHECK_DIR(d)if(d==nullptr) __fortify_fatal("%s: null DIR*", __FUNCTION__) |
| |
| staticuint64_t __get_dir_tag(DIR* dir){ |
| return android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_DIR, |
| reinterpret_cast<uint64_t>(dir)); |
| } |
| |
| staticDIR* __allocate_DIR(int fd){ |
| DIR* d=reinterpret_cast<DIR*>(malloc(sizeof(DIR))); |
| if(d==nullptr){ |
| returnnullptr; |
| } |
| d->fd_= fd; |
| android_fdsan_exchange_owner_tag(fd,0, __get_dir_tag(d)); |
| d->available_bytes_=0; |
| d->next_=nullptr; |
| d->current_pos_=0L; |
| pthread_mutex_init(&d->mutex_,nullptr); |
| return d; |
| } |
| |
| int dirfd(DIR* d){ |
| CHECK_DIR(d); |
| return d->fd_; |
| } |
| |
| DIR* fdopendir(int fd){ |
| // Is 'fd' actually a directory? |
| struct stat sb; |
| if(fstat(fd,&sb)==-1){ |
| returnnullptr; |
| } |
| if(!S_ISDIR(sb.st_mode)){ |
| errno= ENOTDIR; |
| returnnullptr; |
| } |
| |
| return __allocate_DIR(fd); |
| } |
| |
| DIR* opendir(constchar* path){ |
| int fd= open(path, O_CLOEXEC| O_DIRECTORY| O_RDONLY); |
| return(fd!=-1)? __allocate_DIR(fd):nullptr; |
| } |
| |
| staticbool __fill_DIR(DIR* d){ |
| CHECK_DIR(d); |
| int rc= TEMP_FAILURE_RETRY(__getdents64(d->fd_, d->buff_,sizeof(d->buff_))); |
| if(rc<=0){ |
| returnfalse; |
| } |
| d->available_bytes_= rc; |
| d->next_= d->buff_; |
| returntrue; |
| } |
| |
| static dirent* __readdir_locked(DIR* d){ |
| if(d->available_bytes_==0&&!__fill_DIR(d)){ |
| returnnullptr; |
| } |
| |
| dirent* entry= d->next_; |
| d->next_=reinterpret_cast<dirent*>(reinterpret_cast<char*>(entry)+ entry->d_reclen); |
| d->available_bytes_-= entry->d_reclen; |
| // The directory entry offset uses 0, 1, 2 instead of real file offset, |
| // so the value range of long type is enough. |
| d->current_pos_=static_cast<long>(entry->d_off); |
| return entry; |
| } |
| |
| dirent* readdir(DIR* d){ |
| CHECK_DIR(d); |
| ScopedPthreadMutexLocker locker(&d->mutex_); |
| return __readdir_locked(d); |
| } |
| __strong_alias(readdir64, readdir); |
| |
| int readdir_r(DIR* d, dirent* entry, dirent** result){ |
| CHECK_DIR(d); |
| |
| ErrnoRestorer errno_restorer; |
| |
| *result=nullptr; |
| errno=0; |
| |
| ScopedPthreadMutexLocker locker(&d->mutex_); |
| |
| dirent* next= __readdir_locked(d); |
| if(errno!=0&& next==nullptr){ |
| return errno; |
| } |
| |
| if(next!=nullptr){ |
| memcpy(entry, next, next->d_reclen); |
| *result= entry; |
| } |
| return0; |
| } |
| __strong_alias(readdir64_r, readdir_r); |
| |
| int closedir(DIR* d){ |
| if(d==nullptr){ |
| errno= EINVAL; |
| return-1; |
| } |
| |
| int fd= d->fd_; |
| pthread_mutex_destroy(&d->mutex_); |
| int rc= android_fdsan_close_with_tag(fd, __get_dir_tag(d)); |
| free(d); |
| return rc; |
| } |
| |
| void rewinddir(DIR* d){ |
| CHECK_DIR(d); |
| |
| ScopedPthreadMutexLocker locker(&d->mutex_); |
| lseek(d->fd_,0, SEEK_SET); |
| d->available_bytes_=0; |
| d->current_pos_=0L; |
| } |
| |
| void seekdir(DIR* d,long offset){ |
| CHECK_DIR(d); |
| |
| ScopedPthreadMutexLocker locker(&d->mutex_); |
| off_t ret= lseek(d->fd_, offset, SEEK_SET); |
| if(ret!=-1L){ |
| d->available_bytes_=0; |
| d->current_pos_= ret; |
| } |
| } |
| |
| long telldir(DIR* d){ |
| CHECK_DIR(d); |
| |
| return d->current_pos_; |
| } |
| |
| int alphasort(const dirent** a,const dirent** b){ |
| return strcoll((*a)->d_name,(*b)->d_name); |
| } |
| __strong_alias(alphasort64, alphasort); |
