| /****************************************************************************** |
| * |
| * Copyright (C) 2009-2012 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| #include <stdio.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <sys/statfs.h> |
| #include <sys/vfs.h> |
| #include <unistd.h> |
| #include <dirent.h> |
| #include <time.h> |
| #include <limits.h> |
| #include "gki.h" |
| #include "bta_fs_co.h" |
| #include "bta_fs_ci.h" |
| #include <inttypes.h> |
| |
| #ifndef AID_SYSTEM |
| #define AID_SYSTEM 1000 |
| #define AID_BLUETOOTH 1002 |
| #define AID_SDCARD_RW 1015 |
| #define AID_MISC 9998 |
| #endif |
| |
| #define FAT_FS 0x4d44 |
| const unsigned short BT_UID= AID_BLUETOOTH; |
| const unsigned short BT_GID= AID_BLUETOOTH; |
| |
| /* enable additional debugging traces that should be compiled out by default! */ |
| #ifndef BTA_FS_DEBUG |
| #define BTA_FS_DEBUG TRUE |
| #define LOG_TAG "BTA_FS_CO" |
| #define LOGI(format, ...) fprintf (stdout, LOG_TAG format"\n", ## __VA_ARGS__) |
| #endif |
| |
| #if (defined BTA_PBS_INCLUDED) && (BTA_PBS_INCLUDED == TRUE) |
| extern const tBTA_PBS_CFG bta_pbs_cfg; |
| #endif |
| |
| |
| |
| static int del_path (const char *path) |
| { |
| DIR *dir; |
| struct dirent *de; |
| int ret = 0; |
| char nameBuffer[PATH_MAX] = {0}; |
| struct stat statBuffer; |
| BTIF_TRACE_DEBUG1("in del_path for path:%s", path); |
| dir = opendir(path); |
| |
| if (dir == NULL) { |
| BTIF_TRACE_DEBUG1("opendir failed on path:%s", path); |
| return -1; |
| } |
| |
| char *filenameOffset; |
| |
| strncpy(nameBuffer, path, PATH_MAX - 1); |
| strcat(nameBuffer, "/"); |
| int nameLen = strlen(nameBuffer); |
| filenameOffset = nameBuffer + nameLen; |
| |
| for (;;) { |
| de = readdir(dir); |
| |
| if (de == NULL) { |
| BTIF_TRACE_DEBUG1("readdir failed for path:%s", path); |
| //ret = -1; |
| break; |
| } |
| |
| if (0 == strcmp(de->d_name, ".") || 0 == strcmp(de->d_name, "..")) |
| continue; |
| |
| if((int)strlen(de->d_name) > PATH_MAX - nameLen) { |
| BTIF_TRACE_DEBUG1("d_name len:%d is too big", strlen(de->d_name)); |
| ret = -1; |
| break; |
| } |
| |
| strcpy(filenameOffset, de->d_name); |
| |
| ret = lstat (nameBuffer, &statBuffer); |
| |
| if (ret != 0) { |
| BTIF_TRACE_DEBUG1("lstat failed for path:%s", nameBuffer); |
| break; |
| } |
| |
| if(S_ISDIR(statBuffer.st_mode)) { |
| |
| ret = del_path(nameBuffer); |
| if(ret != 0) |
| break; |
| } else { |
| ret = unlink(nameBuffer); |
| if (ret != 0) { |
| BTIF_TRACE_DEBUG1("unlink failed for path:%s", nameBuffer); |
| break; |
| } |
| } |
| } |
| |
| closedir(dir); |
| if(ret == 0) { |
| ret = rmdir(path); |
| BTIF_TRACE_DEBUG2("rmdir return:%d for path:%s", ret, path); |
| } |
| |
| return ret; |
| |
| } |
| |
| inline int getAccess(int accType, struct stat *buffer, char *p_path) |
| { |
| |
| struct statfs fsbuffer; |
| int idType; |
| |
| if(! buffer) |
| return BTA_FS_CO_FAIL; |
| |
| //idType= (buffer->st_uid== BT_UID) ? 1 : (buffer->st_uid== BT_GID) ? 2 : 3; |
| if(buffer->st_uid == BT_UID) |
| idType = 1; |
| else if(buffer->st_gid == BT_GID || |
| buffer->st_gid == AID_SYSTEM || |
| buffer->st_gid == AID_MISC || |
| buffer->st_gid == AID_SDCARD_RW) |
| idType = 2; |
| else idType = 3; |
| |
| if(statfs(p_path, &fsbuffer)==0) |
| { |
| if(fsbuffer.f_type == FAT_FS) |
| return BTA_FS_CO_OK; |
| } |
| else { |
| return BTA_FS_CO_FAIL; |
| } |
| |
| switch(accType) { |
| case 4: |
| if(idType== 1) { //Id is User Id |
| if(buffer-> st_mode & S_IRUSR) |
| return BTA_FS_CO_OK; |
| } |
| else if(idType==2) { //Id is Group Id |
| if(buffer-> st_mode & S_IRGRP) |
| return BTA_FS_CO_OK; |
| } |
| else { //Id is Others |
| if(buffer-> st_mode & S_IROTH) |
| return BTA_FS_CO_OK; |
| } |
| break; |
| |
| case 6: |
| if(idType== 1) { //Id is User Id |
| if((buffer-> st_mode & S_IRUSR) && (buffer-> st_mode & S_IWUSR)) |
| return BTA_FS_CO_OK; |
| } |
| else if(idType==2) { //Id is Group Id |
| if((buffer-> st_mode & S_IRGRP) && (buffer-> st_mode & S_IWGRP)) |
| return BTA_FS_CO_OK; |
| } |
| else { //Id is Others |
| if((buffer-> st_mode & S_IROTH) && (buffer-> st_mode & S_IWOTH)) |
| return BTA_FS_CO_OK; |
| } |
| break; |
| |
| default: |
| return BTA_FS_CO_OK; |
| } |
| BTIF_TRACE_DEBUG0("*************FTP- Access Failed **********"); |
| return BTA_FS_CO_EACCES; |
| } |
| |
| |
| /***************************************************************************** |
| ** Function Declarations |
| *****************************************************************************/ |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_convert_oflags |
| ** |
| ** Description This function converts the open flags from BTA into MFS. |
| ** |
| ** Returns BTA FS status value. |
| ** |
| *******************************************************************************/ |
| int bta_fs_convert_bta_oflags(int bta_oflags) |
| { |
| int oflags = 0; /* Initially read only */ |
| |
| /* Only one of these can be set: Read Only, Read/Write, or Write Only */ |
| if (bta_oflags & BTA_FS_O_RDWR) |
| oflags |= O_RDWR; |
| else if (bta_oflags & BTA_FS_O_WRONLY) |
| oflags |= O_WRONLY; |
| |
| /* OR in any other flags that are set by BTA */ |
| if (bta_oflags & BTA_FS_O_CREAT) |
| oflags |= O_CREAT; |
| |
| if (bta_oflags & BTA_FS_O_EXCL) |
| oflags |= O_EXCL; |
| |
| if (bta_oflags & BTA_FS_O_TRUNC) |
| oflags |= O_TRUNC; |
| |
| return (oflags); |
| } |
| |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function btapp_fs_check_space |
| ** |
| ** Description determines access and if there is enough space for given files size on given path |
| ** |
| ** Parameters p_path - Fully qualified path and file name. |
| ** WARNING: file name is stripped off! so it must be present! |
| ** size - size of file to put (0 if unavailable or not applicable) |
| ** app_id - in case application specific treatement is required (e.g opp versus ftp) |
| ** Returns 0 if enough space, otherwise errno failure codes |
| ** |
| *******************************************************************************/ |
| static int btapp_fs_check_space( const char *p_path, const UINT32 size, const UINT8 app_id ) |
| { |
| |
| unsigned long long max_space; |
| struct statfs fs_buffer; |
| int err = 0; |
| char *p_dir; |
| char *p_end; |
| |
| if(size==BTA_FS_LEN_UNKNOWN) |
| return 0; |
| /* fail silently in case of no memory. write will catch if not enough space */ |
| |
| if (NULL != (p_dir = (char *) GKI_getbuf(strlen(p_path) + 1))) |
| { |
| strcpy(p_dir, p_path); |
| if (NULL != (p_end = strrchr(p_dir, '/'))) |
| { |
| |
| *p_end = '\0'; |
| /* get fs info and calculate available space. if not enough, the fs error EFBIG is returned */ |
| |
| if (0 == statfs(p_dir, &fs_buffer)) |
| { |
| |
| max_space = fs_buffer.f_bavail * fs_buffer.f_bsize; |
| #if (BTA_FS_DEBUG==TRUE) |
| BTIF_TRACE_DEBUG2("btapp_fs_enough_space(file size: %d): (uint)max_size: %u", size, (UINT32)max_space); |
| #endif |
| if (max_space < size) |
| err = EFBIG; |
| } |
| else |
| { |
| err = errno; |
| BTIF_TRACE_WARNING1("btapp_fs_enough_space(): statfs() failed with err: %d", err); |
| } |
| } |
| else |
| { |
| err = ENOENT; |
| } |
| GKI_freebuf(p_dir); |
| } |
| else |
| { |
| err = ENOMEM; |
| } |
| return err; |
| |
| } /* btapp_fs_check_access_space() */ |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_open |
| ** |
| ** Description This function is executed by BTA when a file is opened. |
| ** The phone uses this function to open |
| ** a file for reading or writing. |
| ** |
| ** Parameters p_path - Fully qualified path and file name. |
| ** oflags - permissions and mode (see constants above) |
| ** size - size of file to put (0 if unavailable or not applicable) |
| ** evt - event that must be passed into the call-in function. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| ** Note: Upon completion of the request, a file descriptor (int), |
| ** if successful, and an error code (tBTA_FS_CO_STATUS) |
| ** are returned in the call-in function, bta_fs_ci_open(). |
| ** |
| *******************************************************************************/ |
| |
| void bta_fs_co_open(const char *p_path, int oflags, UINT32 size, UINT16 evt, |
| UINT8 app_id) |
| { |
| |
| tBTA_FS_CO_STATUS status; |
| UINT32 file_size = 0; |
| struct stat file_stat; |
| int fd = -1; |
| int err = 0; |
| |
| /* Convert BTA oflags into os specific flags */ |
| oflags = bta_fs_convert_bta_oflags(oflags); |
| |
| /* check available space in case of write access. oflags are in OS format! */ |
| if (oflags & (O_RDWR|O_WRONLY)) |
| { |
| err = btapp_fs_check_space(p_path, size, app_id); |
| } |
| |
| if ( 0==err ) |
| { |
| if ((fd = open(p_path, oflags | O_NONBLOCK, 0666)) >= 0) |
| { |
| if (fstat(fd, &file_stat) == 0) |
| { |
| file_size = file_stat.st_size; |
| if (oflags & O_CREAT) |
| { |
| fchown(fd, BT_UID, BT_GID); |
| BTIF_TRACE_DEBUG0("\n ******CHANGED OWNERSHIP SUCCESSFULLY**********"); |
| } |
| } |
| } |
| |
| else |
| { |
| err = errno; |
| } |
| } |
| |
| BTIF_TRACE_DEBUG4("[CO] bta_fs_co_open: handle:%d err:%d, flags:%x, app id:%d", |
| fd, err, oflags, app_id); |
| BTIF_TRACE_DEBUG1("file=%s", p_path); |
| |
| /* convert fs error into bta_fs err. erro is set by first call to enough space to a valid value |
| * and needs only updating in case of error. This reports correct failure to remote obex! */ |
| |
| switch (err) |
| { |
| |
| case 0: |
| status = BTA_FS_CO_OK; |
| break; |
| case EACCES: |
| status = BTA_FS_CO_EACCES; |
| break; |
| case EFBIG: /* file to big for available fs space */ |
| status = BTA_FS_CO_ENOSPACE; |
| break; |
| default: |
| status = BTA_FS_CO_FAIL; |
| break; |
| } |
| bta_fs_ci_open(fd, status, file_size, evt); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_close |
| ** |
| ** Description This function is called by BTA when a connection to a |
| ** client is closed. |
| ** |
| ** Parameters fd - file descriptor of file to close. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns (tBTA_FS_CO_STATUS) status of the call. |
| ** [BTA_FS_CO_OK if successful], |
| ** [BTA_FS_CO_FAIL if failed ] |
| ** |
| *******************************************************************************/ |
| tBTA_FS_CO_STATUS bta_fs_co_close(int fd, UINT8 app_id) |
| { |
| tBTA_FS_CO_STATUS status = BTA_FS_CO_OK; |
| int err; |
| |
| BTIF_TRACE_DEBUG2("[CO] bta_fs_co_close: handle:%d, app id:%d", |
| fd, app_id); |
| if (close (fd) < 0) |
| { |
| err = errno; |
| status = BTA_FS_CO_FAIL; |
| BTIF_TRACE_WARNING3("[CO] bta_fs_co_close: handle:%d error=%d app_id:%d", fd, err, app_id); |
| } |
| |
| return (status); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_read |
| ** |
| ** Description This function is called by BTA to read in data from the |
| ** previously opened file on the phone. |
| ** |
| ** Parameters fd - file descriptor of file to read from. |
| ** p_buf - buffer to read the data into. |
| ** nbytes - number of bytes to read into the buffer. |
| ** evt - event that must be passed into the call-in function. |
| ** ssn - session sequence number. Ignored, if bta_fs_co_open |
| ** was not called with BTA_FS_CO_RELIABLE. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| ** Note: Upon completion of the request, bta_fs_ci_read() is |
| ** called with the buffer of data, along with the number |
| ** of bytes read into the buffer, and a status. The |
| ** call-in function should only be called when ALL requested |
| ** bytes have been read, the end of file has been detected, |
| ** or an error has occurred. |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_read(int fd, UINT8 *p_buf, UINT16 nbytes, UINT16 evt, UINT8 ssn, UINT8 app_id) |
| { |
| tBTA_FS_CO_STATUS status = BTA_FS_CO_OK; |
| INT32 num_read; |
| int err; |
| |
| if ((num_read = read (fd, p_buf, nbytes)) < 0) |
| { |
| err = errno; |
| status = BTA_FS_CO_FAIL; |
| BTIF_TRACE_WARNING3("[CO] bta_fs_co_read: handle:%d error=%d app_id:%d", |
| fd, err, app_id); |
| } |
| else if (num_read < nbytes) |
| status = BTA_FS_CO_EOF; |
| |
| bta_fs_ci_read(fd, (UINT16)num_read, status, evt); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_write |
| ** |
| ** Description This function is called by io to send file data to the |
| ** phone. |
| ** |
| ** Parameters fd - file descriptor of file to write to. |
| ** p_buf - buffer to read the data from. |
| ** nbytes - number of bytes to write out to the file. |
| ** evt - event that must be passed into the call-in function. |
| ** ssn - session sequence number. Ignored, if bta_fs_co_open |
| ** was not called with BTA_FS_CO_RELIABLE. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| ** Note: Upon completion of the request, bta_fs_ci_write() is |
| ** called with the file descriptor and the status. The |
| ** call-in function should only be called when ALL requested |
| ** bytes have been written, or an error has been detected, |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_write(int fd, const UINT8 *p_buf, UINT16 nbytes, UINT16 evt, |
| UINT8 ssn, UINT8 app_id) |
| { |
| tBTA_FS_CO_STATUS status = BTA_FS_CO_OK; |
| INT32 num_written; |
| int err=0; |
| |
| if ((num_written = write (fd, p_buf, nbytes)) < 0) |
| { |
| err = errno; |
| status = BTA_FS_CO_FAIL; |
| } |
| /* BTIF_TRACE_DEBUG3("[CO] bta_fs_co_write: handle:%d error=%d, num_written:%d", fd, err, num_written);*/ |
| |
| bta_fs_ci_write(fd, status, evt); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_seek |
| ** |
| ** Description This function is called by io to move the file pointer |
| ** of a previously opened file to the specified location for |
| ** the next read or write operation. |
| ** |
| ** Parameters fd - file descriptor of file. |
| ** offset - Number of bytes from origin. |
| ** origin - Initial position. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_seek (int fd, INT32 offset, INT16 origin, UINT8 app_id) |
| { |
| lseek(fd, offset, origin); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_access |
| ** |
| ** Description This function is called to check the existence of |
| ** a file or directory, and return whether or not it is a |
| ** directory or length of the file. |
| ** |
| ** Parameters p_path - (input) file or directory to access (fully qualified path). |
| ** mode - (input) [BTA_FS_ACC_EXIST, BTA_FS_ACC_READ, or BTA_FS_ACC_RDWR] |
| ** p_is_dir - (output) returns TRUE if p_path specifies a directory. |
| ** app_id - (input) application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns (tBTA_FS_CO_STATUS) status of the call. |
| ** [BTA_FS_CO_OK if it exists] |
| ** [BTA_FS_CO_EACCES if permissions are wrong] |
| ** [BTA_FS_CO_FAIL if it does not exist] |
| ** |
| *******************************************************************************/ |
| tBTA_FS_CO_STATUS bta_fs_co_access(const char *p_path, int mode, BOOLEAN *p_is_dir, |
| UINT8 app_id) |
| { |
| int err; |
| int os_mode = 0; |
| tBTA_FS_CO_STATUS status = BTA_FS_CO_OK; |
| struct stat buffer; |
| |
| #if (TRUE==BTA_FS_DEBUG) |
| LOGI("***********CHECKING ACCESS TO = %s", p_path); |
| #endif |
| |
| #if (defined BTA_PBS_INCLUDED) && (BTA_PBS_INCLUDED == TRUE) |
| |
| if (app_id == UI_PBS_ID) |
| { |
| |
| *p_is_dir = TRUE; |
| |
| #if (TRUE==BTA_FS_DEBUG) |
| LOGI("***********SUPPORTED REPO = %d", bta_pbs_cfg.supported_repositories); |
| #endif |
| //Check if SIM contact requested, and if so if it's supported. |
| //If not, return error! |
| if (strstr(p_path,"SIM1") && !(bta_pbs_cfg.supported_repositories & 0x2)) { |
| LOGI("***********RETURNING FAIL!"); |
| return BTA_FS_CO_FAIL; |
| } |
| |
| #if (TRUE==BTA_FS_DEBUG) |
| LOGI("***********RETURNING success!"); |
| #endif |
| return (status); |
| } |
| #endif |
| |
| |
| *p_is_dir = FALSE; |
| |
| if (mode == BTA_FS_ACC_RDWR) |
| os_mode = 6; |
| else if (mode == BTA_FS_ACC_READ) |
| os_mode = 4; |
| |
| if (stat(p_path, &buffer) == 0) |
| { |
| /* Determine if the object is a file or directory */ |
| if (S_ISDIR(buffer.st_mode)) |
| *p_is_dir = TRUE; |
| } |
| else |
| { |
| BTIF_TRACE_DEBUG0("stat() failed! "); |
| return BTA_FS_CO_FAIL; |
| } |
| |
| status=getAccess (os_mode, &buffer, (char*)p_path); |
| return (status); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_mkdir |
| ** |
| ** Description This function is called to create a directory with |
| ** the pathname given by path. The pathname is a null terminated |
| ** string. All components of the path must already exist. |
| ** |
| ** Parameters p_path - (input) name of directory to create (fully qualified path). |
| ** app_id - (input) application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns (tBTA_FS_CO_STATUS) status of the call. |
| ** [BTA_FS_CO_OK if successful] |
| ** [BTA_FS_CO_FAIL if unsuccessful] |
| ** |
| *******************************************************************************/ |
| tBTA_FS_CO_STATUS bta_fs_co_mkdir(const char *p_path, UINT8 app_id) |
| { |
| int err; |
| tBTA_FS_CO_STATUS status = BTA_FS_CO_OK; |
| |
| if ((mkdir (p_path, 0666)) != 0) |
| { |
| err = errno; |
| status = BTA_FS_CO_FAIL; |
| BTIF_TRACE_WARNING3("[CO] bta_fs_co_mkdir: error=%d, path [%s] app_id:%d", |
| err, p_path, app_id); |
| } |
| return (status); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_rmdir |
| ** |
| ** Description This function is called to remove a directory whose |
| ** name is given by path. The directory must be empty. |
| ** |
| ** Parameters p_path - (input) name of directory to remove (fully qualified path). |
| ** app_id - (input) application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns (tBTA_FS_CO_STATUS) status of the call. |
| ** [BTA_FS_CO_OK if successful] |
| ** [BTA_FS_CO_EACCES if read-only] |
| ** [BTA_FS_CO_ENOTEMPTY if directory is not empty] |
| ** [BTA_FS_CO_FAIL otherwise] |
| ** |
| *******************************************************************************/ |
| tBTA_FS_CO_STATUS bta_fs_co_rmdir(const char *p_path, UINT8 app_id) |
| { |
| int err, path_len; |
| tBTA_FS_CO_STATUS status = BTA_FS_CO_OK; |
| struct stat buffer; |
| char *dirName, *tmp = NULL; |
| |
| path_len = strlen( p_path )+1; |
| BTIF_TRACE_DEBUG2( "bta_fs_co_rmdir( app_id: %d ): path_len: %d", app_id, path_len ); |
| #if (TRUE==BTA_FS_DEBUG) |
| BTIF_TRACE_DEBUG1( "bta_fs_co_rmdir():path_len: %d, p_path", app_id ); |
| BTIF_TRACE_DEBUG0( p_path ); |
| #endif |
| |
| /* allocate a temp buffer for path with 0 char. make sure not to crash if path is too big! */ |
| dirName = (char*) calloc(1, path_len+1); |
| if ( NULL != dirName ) |
| { |
| strcpy( dirName, p_path ); |
| } |
| else |
| { |
| BTIF_TRACE_WARNING2( "bta_fs_co_rmdir( app_id: %d ) for path_len: %d::out of memory", |
| app_id, path_len ); |
| return BTA_FS_CO_FAIL; |
| } |
| |
| if (NULL!= (tmp = strrchr(dirName, '/'))) |
| { |
| *tmp = '\0'; |
| } |
| if (stat(dirName, &buffer) == 0) |
| { |
| status = getAccess(6, &buffer, dirName); |
| } |
| else |
| { |
| free(dirName); |
| #if (TRUE==BTA_FS_DEBUG) |
| BTIF_TRACE_WARNING0( "bta_fs_co_rmdir()::stat(dirName) failed" ); |
| #endif |
| return BTA_FS_CO_FAIL; |
| } |
| |
| free(dirName); |
| if (status != BTA_FS_CO_OK) |
| { |
| #if (TRUE==BTA_FS_DEBUG) |
| BTIF_TRACE_WARNING0( "bta_fs_co_rmdir()::getAccess(dirName) FAILED"); |
| #endif |
| return status; |
| } |
| |
| if (stat(p_path, &buffer) == 0) |
| { |
| status = getAccess(6, &buffer, (char*)p_path); |
| } |
| else |
| { |
| #if (TRUE==BTA_FS_DEBUG) |
| BTIF_TRACE_WARNING0( "bta_fs_co_rmdir()::stat(p_path) FAILED"); |
| #endif |
| return BTA_FS_CO_FAIL; |
| } |
| |
| if (status != BTA_FS_CO_OK) |
| { |
| #if (TRUE==BTA_FS_DEBUG) |
| BTIF_TRACE_DEBUG0( "bta_fs_co_rmdir()::getAccess(p_path) FAILED"); |
| #endif |
| return status; |
| } |
| //if ((rmdir (p_path)) != 0) |
| if (del_path(p_path) != 0) |
| { |
| err = errno; |
| BTIF_TRACE_WARNING1( "bta_fs_co_rmdir():rmdir/del_path FAILED with err: %d", err ); |
| if (err == EACCES) |
| status = BTA_FS_CO_EACCES; |
| else if (err == ENOTEMPTY) |
| status = BTA_FS_CO_ENOTEMPTY; |
| else |
| status = BTA_FS_CO_FAIL; |
| } |
| return (status); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_unlink |
| ** |
| ** Description This function is called to remove a file whose name |
| ** is given by p_path. |
| ** |
| ** Parameters p_path - (input) name of file to remove (fully qualified path). |
| ** app_id - (input) application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns (tBTA_FS_CO_STATUS) status of the call. |
| ** [BTA_FS_CO_OK if successful] |
| ** [BTA_FS_CO_EACCES if read-only] |
| ** [BTA_FS_CO_FAIL otherwise] |
| ** |
| *******************************************************************************/ |
| tBTA_FS_CO_STATUS bta_fs_co_unlink(const char *p_path, UINT8 app_id) |
| { |
| BTIF_TRACE_DEBUG0("bta_fs_co_unlink"); |
| int err; |
| tBTA_FS_CO_STATUS status = BTA_FS_CO_OK; |
| char *dirName, *tmp=NULL; |
| struct stat buffer; |
| |
| if(! p_path) |
| return BTA_FS_CO_FAIL; |
| |
| /* buffer needs to be NULL terminated - so add one more byte to be zero'd out */ |
| #if 0 |
| dirName= (char*) calloc(1, strlen(p_path)); /* <--- this can cause problems */ |
| #else |
| dirName= (char*) calloc(1, strlen(p_path) + 1); |
| #endif |
| |
| strncpy(dirName, p_path, strlen(p_path)); |
| if((tmp=strrchr(dirName, '/'))) |
| { |
| *tmp='\0'; |
| } |
| if (stat(dirName, &buffer) == 0) |
| { |
| status=getAccess (6, &buffer, dirName); |
| free(dirName); |
| } |
| else |
| { |
| BTIF_TRACE_DEBUG0("stat() failed! "); |
| free(dirName); |
| return BTA_FS_CO_FAIL; |
| } |
| |
| if(status!= BTA_FS_CO_OK) |
| return status; |
| |
| if ((unlink (p_path)) != 0) |
| { |
| err = errno; |
| if (err == EACCES) |
| status = BTA_FS_CO_EACCES; |
| else |
| status = BTA_FS_CO_FAIL; |
| } |
| return (status); |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_getdirentry |
| ** |
| ** Description This function is called to get a directory entry for the |
| ** specified p_path. The first/next directory should be filled |
| ** into the location specified by p_entry. |
| ** |
| ** Parameters p_path - directory to search (Fully qualified path) |
| ** first_item - TRUE if first search, FALSE if next search |
| ** (p_cur contains previous) |
| ** p_entry (input/output) - Points to last entry data (valid when |
| ** first_item is FALSE) |
| ** evt - event that must be passed into the call-in function. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| ** Note: Upon completion of the request, the status is passed |
| ** in the bta_fs_ci_direntry() call-in function. |
| ** BTA_FS_CO_OK is returned when p_entry is valid, |
| ** BTA_FS_CO_EODIR is returned when no more entries [finished] |
| ** BTA_FS_CO_FAIL is returned if an error occurred |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_getdirentry(const char *p_path, BOOLEAN first_item, |
| tBTA_FS_DIRENTRY *p_entry, UINT16 evt, UINT8 app_id) |
| { |
| tBTA_FS_CO_STATUS co_status = BTA_FS_CO_FAIL; |
| int status = -1; /* '0' - success, '-1' - fail */ |
| struct tm *p_tm; |
| DIR *dir; |
| struct dirent *dirent; |
| struct stat buf; |
| char fullname[500]; |
| |
| BTIF_TRACE_DEBUG0("Entered bta_fs_co_getdirentry"); |
| |
| /* First item is to be retrieved */ |
| if (first_item) |
| { |
| BTIF_TRACE_DEBUG1("bta_fs_co_getdirentry: path = %s", p_path); |
| |
| dir = opendir(p_path); |
| if(dir == NULL) |
| { |
| BTIF_TRACE_DEBUG1("bta_fs_co_getdirentry: dir is NULL so error out with errno=%d", errno); |
| co_status = BTA_FS_CO_EODIR; |
| bta_fs_ci_direntry(co_status, evt); |
| return; |
| } |
| |
| BTIF_TRACE_DEBUG1("bta_fs_co_getdirentry: dir = %p", dir); |
| if((dirent = readdir(dir)) != NULL) |
| { |
| p_entry->refdata = (UINT32) dir; /* Save this for future searches */ |
| status = 0; |
| BTIF_TRACE_DEBUG1("bta_fs_co_getdirentry: dirent = %p", dirent); |
| } |
| else |
| { |
| BTIF_TRACE_DEBUG1("bta_fs_co_getdirentry: dirent = %p", dirent); |
| /* Close the search if there are no more items */ |
| closedir( (DIR*) p_entry->refdata); |
| co_status = BTA_FS_CO_EODIR; |
| } |
| } |
| else /* Get the next entry based on the p_ref data from previous search */ |
| { |
| if ((dirent = readdir((DIR*)p_entry->refdata)) == NULL) |
| { |
| /* Close the search if there are no more items */ |
| closedir( (DIR*) p_entry->refdata); |
| co_status = BTA_FS_CO_EODIR; |
| BTIF_TRACE_DEBUG1("bta_fs_co_getdirentry: dirent = %p", dirent); |
| } |
| else |
| { |
| BTIF_TRACE_DEBUG1("bta_fs_co_getdirentry: dirent = %p", dirent); |
| status = 0; |
| } |
| } |
| |
| if (status == 0) |
| { |
| BTIF_TRACE_DEBUG0("bta_fs_co_getdirentry: status = 0"); |
| |
| sprintf(fullname, "%s/%s", p_path, dirent->d_name); |
| |
| /* Load new values into the return structure (refdata is left untouched) */ |
| if (stat(fullname, &buf) == 0) { |
| p_entry->filesize = buf.st_size; |
| p_entry->mode = 0; /* Default is normal read/write file access */ |
| |
| if (S_ISDIR(buf.st_mode)) |
| p_entry->mode |= BTA_FS_A_DIR; |
| else |
| p_entry->mode |= BTA_FS_A_RDONLY; |
| |
| strcpy(p_entry->p_name, dirent->d_name); |
| #if 0 |
| fprintf(stderr, "bta_fs_co_getdirentry(): %s %9d %d\n", |
| dirent->d_name, |
| buf.st_size, |
| p_entry->mode); |
| #endif |
| p_tm = localtime((const time_t*)&buf.st_mtime); |
| if (p_tm != NULL) |
| { |
| sprintf(p_entry->crtime, "%04d%02d%02dT%02d%02d%02dZ", |
| p_tm->tm_year + 1900, /* Base Year ISO 6201 */ |
| p_tm->tm_mon + 1, /* month starts at 0 */ |
| p_tm->tm_mday, |
| p_tm->tm_hour, |
| p_tm->tm_min, |
| p_tm->tm_sec); |
| } |
| else |
| p_entry->crtime[0] = '\0'; /* No valid time */ |
| #if 0 |
| fprintf(stderr, "bta_fs_co_getdirentry(): %s %9d %d %s\n", |
| dirent->d_name, |
| p_entry->filesize, |
| p_entry->mode, |
| p_entry->crtime); |
| #endif |
| co_status = BTA_FS_CO_OK; |
| } else { |
| BTIF_TRACE_WARNING0("stat() failed! "); |
| co_status = BTA_FS_CO_EACCES; |
| } |
| } |
| BTIF_TRACE_DEBUG0("bta_fs_co_getdirentry: calling bta_fs_ci_getdirentry"); |
| |
| bta_fs_ci_direntry(co_status, evt); |
| } |
| |
| |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_setdir |
| ** |
| ** Description This function is executed by BTA when the server changes the |
| ** local path |
| ** |
| ** Parameters p_path - the new path. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_setdir(const char *p_path, UINT8 app_id) |
| { |
| BTIF_TRACE_DEBUG2("Entered %s. New path: %s", __FUNCTION__, p_path); |
| } |
| |
| /******************************************************************************* |
| ** OBEX14 Reliable Session not supported. Stub associated callouts. |
| ******************************************************************************/ |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_resume |
| ** |
| ** Description This function is executed by BTA when resuming a session. |
| ** This is used to retrieve the session ID and related information |
| ** |
| ** Parameters evt - event that must be passed into the call-in function. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| ** Note: Upon completion of the request, the related session information, |
| ** if successful, and an error code (tBTA_FS_CO_STATUS) |
| ** are returned in the call-in function, bta_fs_ci_resume(). |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_resume(UINT16 evt, UINT8 app_id) |
| { |
| BTIF_TRACE_WARNING0("[CO] bta_fs_co_resume - NOT implemented"); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_set_perms |
| ** |
| ** Description This function is called to set the permission a file/directory |
| ** with name as p_src_path. |
| ** |
| ** Parameters p_src_path - (input) name of file/directory to set permission (fully qualified path). |
| ** p_perms - the permission . |
| ** app_id - (input) application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns (tBTA_FS_CO_STATUS) status of the call. |
| ** [BTA_FS_CO_OK if successful] |
| ** [BTA_FS_CO_EACCES if p_dest_path already exists or could not be created (invalid path); |
| ** or p_src_path is a directory and p_dest_path specifies a different path. ] |
| ** [BTA_FS_CO_FAIL otherwise] |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_set_perms(const char *p_src_path, UINT8 *p_perms, UINT16 evt, UINT8 app_id) |
| { |
| BTIF_TRACE_WARNING0("[CO] bta_fs_co_set_perms - NOT implemented"); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_rename |
| ** |
| ** Description This function is called to move a file/directory whose |
| ** name is given by p_src_path to p_dest_path. |
| ** |
| ** Parameters p_src_path - (input) name of file/directory to be moved (fully qualified path). |
| ** p_dest_path - (input) new name of file/directory(fully qualified path). |
| ** p_perms - the permission of the new object. |
| ** app_id - (input) application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns (tBTA_FS_CO_STATUS) status of the call. |
| ** [BTA_FS_CO_OK if successful] |
| ** [BTA_FS_CO_EACCES if p_dest_path already exists or could not be created (invalid path); |
| ** or p_src_path is a directory and p_dest_path specifies a different path. ] |
| ** [BTA_FS_CO_FAIL otherwise] |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_rename(const char *p_src_path, const char *p_dest_path, UINT8 *p_perms, UINT16 evt, UINT8 app_id) |
| { |
| BTIF_TRACE_WARNING0("[CO] bta_fs_co_rename - NOT implemented"); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_copy |
| ** |
| ** Description This function is called to copy a file/directory whose |
| ** name is given by p_src_path to p_dest_path. |
| ** |
| ** Parameters p_src_path - (input) name of file/directory to be copied (fully qualified path). |
| ** p_dest_path - (input) new name of file/directory(fully qualified path). |
| ** p_perms - the permission of the new object. |
| ** evt - event that must be passed into the call-in function. |
| ** app_id - (input) application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns (tBTA_FS_CO_STATUS) status of the call. |
| ** [BTA_FS_CO_OK if successful] |
| ** [BTA_FS_CO_EIS_DIR if p_src_path is a folder] |
| ** [BTA_FS_CO_EACCES if p_dest_path already exists or could not be created (invalid path); |
| ** or p_src_path is a directory and p_dest_path specifies a different path. ] |
| ** [BTA_FS_CO_FAIL otherwise] |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_copy(const char *p_src_path, const char *p_dest_path, UINT8 *p_perms, UINT16 evt, UINT8 app_id) |
| { |
| BTIF_TRACE_WARNING0("[CO] bta_fs_co_copy - NOT implemented"); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_resume_op |
| ** |
| ** Description This function is executed by BTA when a reliable session is |
| ** resumed and there was an interrupted operation. |
| ** |
| ** Parameters offset - the session ID and related information. |
| ** evt - event that must be passed into the call-in function. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_resume_op(UINT32 offset, UINT16 evt, UINT8 app_id) |
| { |
| BTIF_TRACE_WARNING0("[CO] bta_fs_co_resume_op - NOT implemented"); |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_session_info |
| ** |
| ** Description This function is executed by BTA when a reliable session is |
| ** established (p_sess_info != NULL) or ended (p_sess_info == NULL). |
| ** |
| ** Parameters bd_addr - the peer address |
| ** p_sess_info - the session ID and related information. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_session_info(BD_ADDR bd_addr, UINT8 *p_sess_info, UINT8 ssn, |
| tBTA_FS_CO_SESS_ST new_st, char *p_path, UINT8 *p_info, UINT8 app_id) |
| { |
| BTIF_TRACE_WARNING0("[CO] bta_fs_co_session_info - NOT implemented"); |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_suspend |
| ** |
| ** Description This function is executed by BTA when a reliable session is |
| ** suspended. |
| ** |
| ** Parameters bd_addr - the peer address |
| ** ssn - the session sequence number. |
| ** info - the BTA specific information (like last active operation). |
| ** p_offset- the location to receive object offset of the suspended session |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_suspend(BD_ADDR bd_addr, UINT8 *p_sess_info, UINT8 ssn, |
| UINT32 *p_timeout, UINT32 *p_offset, UINT8 info, UINT8 app_id) |
| { |
| BTIF_TRACE_WARNING0("[CO] bta_fs_co_suspend - NOT implemented"); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_fs_co_sess_ssn |
| ** |
| ** Description This function is executed by BTA when resuming a session. |
| ** This is used to inform call-out module if the ssn/file offset |
| ** needs to be adjusted. |
| ** |
| ** Parameters ssn - the session sequence number of the first request |
| ** after resume. |
| ** app_id - application ID specified in the enable functions. |
| ** It can be used to identify which profile is the caller |
| ** of the call-out function. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void bta_fs_co_sess_ssn(int fd, UINT8 ssn, UINT8 app_id) |
| { |
| BTIF_TRACE_WARNING0("[CO] bta_fs_co_suspend - NOT implemented"); |
| } |
| |
