path: root/mtpfuse/mtpfuse.cpp

/*
 * Copyright (C) 2012 Texas Instruments
 *
 * 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 <usbhost/usbhost.h>
#include <fuse.h>
#include <MtpStorageInfo.h>
#include <MtpObjectInfo.h>
#include <utils/String8.h>
#include <utils/Vector.h>
#include <utils/KeyedVector.h>
#include <stdio.h>
#include <string.h>
#include <MtpDevice.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/statfs.h>
#include <sys/mman.h>


#undef FUSE_USE_VERSION
#define FUSE_USE_VERSION 25

#ifdef DEBUG
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
#define DBG(a...) {printf(a);}
#else
#define DBG(a...)
#endif

using namespace android;

MtpDevice* mtp_device			= NULL;
int mtp_device_found 			= 0;
MtpStorageIDList* storageAreaList	= NULL;
KeyedVector<uint32_t, char*> storageEntries;

static struct fuse_operations mtpfuse_oper;
typedef Vector <String8*> PathTokenList;
typedef Vector <MtpObjectInfo*> childList;
KeyedVector<uint32_t, childList*> mtpEntries;
KeyedVector<uint32_t, String8> fileDescriptorTable;

static int usb_device_listed(const char *devname, void* client_data) {
		int fd;
		usb_device* device = usb_device_open(devname);
		if (device == NULL) {
			DBG("Error opening device\n");
			return 0;
		}
		fd = usb_device_get_fd(device);
		if (fd < 0) {
			DBG("Error getting fd\n");
			return 0;
		}

		MtpDevice *mtp = MtpDevice::open(devname, fd);
		if (mtp!= NULL) {
			DBG("MTP device found\n");
			mtp_device_found = 1;
			mtp_device = mtp;
		}
		return 0;
}

static int list_devices () {
	struct usb_host_context* context = usb_host_init();
	usb_host_load(context, usb_device_listed, NULL, NULL, NULL);
	return 0;
}

static int get_storage_id(PathTokenList* tokens) {
	String8* storage = tokens->itemAt(0);
	DBG("Storage %s\n", storage->string());
	if (storage == NULL) {
		return -1;
	}
	for (size_t i = 0;i < storageEntries.size();i++) {
		char* desc = storageEntries.valueAt(i);
		if (strcmp(desc, storage->string()) == 0) {
			return storageEntries.keyAt(i);
		}
	}
	return -1;
}

static int mtpfuse_release (const char *path,
			    struct fuse_file_info *fi) {
	return 0;
}

static PathTokenList* tokenize_path(String8* path) {
	String8* remain = path;
	PathTokenList* tokens = new PathTokenList();
	do {
		String8* token = new String8(remain->walkPath(remain));
		tokens->add(token);
	} while (*remain != "");
	return tokens;
}

static MtpObjectInfo* get_mtp_obj_for_path(const char *path) {
	PathTokenList* tokens;
	MtpObjectInfo* ret = NULL;
	String8* path_str = new String8();
	path_str->setPathName(path);
	tokens = tokenize_path(path_str);
	//Go through mtp entries to get the entries
	int storageId = get_storage_id(tokens);
	if (storageId == -1) {
		DBG("Could not get Storage Id\n");
		tokens->removeItemsAt(0, tokens->size());
		delete tokens;
		delete path_str;
		return NULL;
	}
	int found = 0;
	int index = mtpEntries.indexOfKey(storageId);
	childList *list = mtpEntries.valueAt(index);
	if (list != NULL) {
		found = 1;
	}
	MtpObjectInfo *target = NULL;
	if (tokens->size() > 1) {
		found = 0;
		for (size_t i = 1;i < tokens->size();i++) {
			for (size_t j = 0;j < list->size();j++) {
				if (strcmp(list->itemAt(j)->mName, tokens->itemAt(i)->string()) == 0) {
					uint32_t handle = list->itemAt(j)->mHandle;
					target = list->itemAt(j);
					int indx = mtpEntries.indexOfKey(handle);
					list = NULL;
					list = mtpEntries.valueAt(indx);
					if (i == tokens->size() - 1) {
						found = 1;
					}
					break;
				}
			}
		}
	}

	if (found) {
		ret = target;
	}
	tokens->removeItemsAt(0, tokens->size());
	delete tokens;
	delete path_str;
	return target;
}


static int mtpfuse_open (const char * path, struct fuse_file_info *fi) {
	MtpObjectInfo *obj = get_mtp_obj_for_path(path);
	if (obj == NULL) {
		return -ENOENT;
	}
	fi->fh = (uint64_t)obj->mHandle;
	DBG("Handle is %llu %s\n", fi->fh, obj->mName);
	return 0;
}

static int mtpfuse_readdir (const char * path,
			  void *buf, fuse_fill_dir_t filler,
			  off_t offset, struct fuse_file_info *fi) {
	PathTokenList* tokens;
	filler (buf, ".", NULL, 0);
	filler (buf, "..", NULL, 0);

	if (strcmp(path, "/") == 0) {
		//First get the storages
		for (size_t i = 0;i < storageEntries.size();i++) {
			struct stat st;
			memset (&st, 0, sizeof (st));
			st.st_nlink = 2;
			st.st_ino = storageEntries.keyAt(i);
			st.st_mode = S_IFDIR | 0777;
			char *desc = storageEntries.valueAt(i);
			filler (buf, desc, &st, 0);
		}
		return 0;
	} else {
		String8* path_str = new String8();
		path_str->setPathName(path);
		tokens = tokenize_path(path_str);
		//Go through mtp entries to get the entries
		int storageId = get_storage_id(tokens);
		if (storageId == -1) {
			tokens->removeItemsAt(0, tokens->size());
			delete tokens;
			delete path_str;
			return -ENOENT;
		}
		int found = 0;
		int index = mtpEntries.indexOfKey(storageId);
		childList *list = mtpEntries.valueAt(index);
		if (list != NULL) {
			found = 1;
		}

		if (tokens->size() > 1) {
			found = 0;
			for (size_t i = 1;i < tokens->size();i++) {
				for (size_t j = 0;j < list->size();j++) {
					if (strcmp(list->itemAt(j)->mName, tokens->itemAt(i)->string()) == 0) {
						uint32_t handle = list->itemAt(j)->mHandle;
						int indx = mtpEntries.indexOfKey(handle);
						list = NULL;
						list = mtpEntries.valueAt(indx);
						if (i == tokens->size() - 1) {
							found = 1;
						}
						break;
					}
				}
			}
		}

		if (found) {
			if (list != NULL) {
				childList *leaves = NULL;
				for (size_t i = 0;i < list->size();i++) {
					uint32_t handle = list->itemAt(i)->mHandle;
					int indx = mtpEntries.indexOfKey(handle);
					leaves = mtpEntries.valueAt(indx);
					if (leaves) {
						if (leaves->size() == 0) {
							struct stat st;
							memset (&st, 0, sizeof (st));
							st.st_ino = list->itemAt(i)->mHandle;
							st.st_mode = S_IFREG | 0777;
							filler (buf, list->itemAt(i)->mName, &st, 0);
						}else {
							struct stat st;
							memset (&st, 0, sizeof (st));
							st.st_ino = list->itemAt(i)->mHandle;
							st.st_mode = S_IFDIR | 0777;
							filler (buf, list->itemAt(i)->mName, &st, 0);
						}
					}
				}
			}
		}
		tokens->removeItemsAt(0, tokens->size());
		delete tokens;
		delete path_str;
	}
	return 0;
}


static int mtpfuse_get_mtp_objects(const char * path) {
	//First get the storages
	for (size_t i = 0;i < storageAreaList->size();i++) {
		uint32_t storageId = storageAreaList->itemAt(i);
		//Each storage has handle
		childList *forRoot = new childList;
		mtpEntries.add(storageId, forRoot);
		MtpObjectHandleList* mo_list =
				mtp_device->getObjectHandles(storageId, 0, 0);
		if (mo_list != NULL) {
			//Each mtp object handle is associated with a Vector of child nodes.
			//The object is stored as a KeyedVector which has an associated child Vector
			for (size_t i = 0;i < mo_list->size();i++) {
				MtpObjectInfo* info =  mtp_device->getObjectInfo
							(mo_list->itemAt(i));
				childList *c = new childList;
				mtpEntries.add(info->mHandle, c);
				//Handle to childList
				childList* parent_child_list = NULL;
				int index = -1;
				if (info->mParent != 0) {
					index = mtpEntries.indexOfKey(info->mParent);
				}else {
					index = mtpEntries.indexOfKey(storageId);
				}
				if (index == -1) {
					continue;
				}
				parent_child_list = mtpEntries.valueAt(index);
				if (parent_child_list != NULL) {
					parent_child_list->add(info);
				}else {
					DBG("No handle to parent's list\n");
				}
			}
		}
	}
	return 0;
}

static int mtpfuse_getattr (const char * path, struct stat *stbuf) {
	PathTokenList* tokens;

	memset (stbuf, 0, sizeof (struct stat));

	struct fuse_context *fc;
	fc = fuse_get_context();
	stbuf->st_uid = fc->uid;
	stbuf->st_gid = fc->gid;

	if (strcmp(path, "/") == 0) {
		stbuf->st_mode = S_IFDIR | 0777;
		stbuf->st_nlink = 2;
		return 0;

	} else {
		String8* path_str = new String8();
		path_str->setPathName(path);
		tokens = tokenize_path(path_str);
		//Go through mtp entries to get the entries
		int storageId = get_storage_id(tokens);
		if (storageId == -1) {
			tokens->removeItemsAt(0, tokens->size());
			delete tokens;
			delete path_str;
			return -ENOENT;
		}
		int found = 0;
		int index = mtpEntries.indexOfKey(storageId);
		childList *list = mtpEntries.valueAt(index);
		if (list != NULL) {
			found = 1;
		}
		MtpObjectInfo *target = NULL;
		if (tokens->size() > 1) {
			found = 0;
			for (size_t i = 1;i < tokens->size();i++) {
				for (size_t j = 0;j < list->size();j++) {
					if (strcmp(list->itemAt(j)->mName, tokens->itemAt(i)->string()) == 0) {
						uint32_t handle = list->itemAt(j)->mHandle;
						target = list->itemAt(j);
						int indx = mtpEntries.indexOfKey(handle);
						list = NULL;
						list = mtpEntries.valueAt(indx);
						if (i == tokens->size() - 1) {
							found = 1;
						}
						break;
					}
				}
			}
		}
		if (found) {
			if (list != NULL) {
				//If an object has no child nodes, assume it to be a directory
				if (list->size() == 0) {
					DBG("File\n");
					stbuf->st_ino = target->mHandle;
					stbuf->st_size = target->mCompressedSize;
					stbuf->st_blocks = (target->mCompressedSize / 512) +
						(target->mCompressedSize % 512 > 0 ? 1 : 0);
					stbuf->st_nlink = 1;
					stbuf->st_mode = S_IFREG | 0777;
					stbuf->st_uid = 1000;
					stbuf->st_gid = 1015;
					stbuf->st_mtime = target->mDateModified;
					stbuf->st_ctime = target->mDateModified;
					stbuf->st_atime = target->mDateModified;
				}else {
					DBG("Directory\n");
					if (target != NULL)
						stbuf->st_ino = target->mHandle;
					stbuf->st_mode = S_IFDIR | 0777;
					stbuf->st_nlink = 2;
					stbuf->st_uid = 1000;
					stbuf->st_gid = 1015;
				}
			}
		}
		tokens->removeItemsAt(0, tokens->size());
		delete tokens;
		delete path_str;
	}
	return 0;
}

bool read_callback (void* data, int offset, int length, void* clientData) {
	//DBG("Received read callback %d %d\n", offset, length);
	memcpy((char *)clientData + offset, data, length);
	return true;
}

static int mtpfuse_read (const char * path, char * buf,
		       			  size_t size, off_t offset,
		                  struct fuse_file_info *fi) {
	int ret;
	MtpObjectHandle h = (MtpObjectHandle)fi->fh;
	bool status = mtp_device->readObject(h, read_callback, size, offset, buf);
	if (status == false) {
		ret = 0;
	}else {
		ret = size;
	}
	return ret;
}

static void start_media_scanner() {
	const char* cmd =
	"am broadcast -a android.intent.action.MEDIA_MOUNTED -d file:///mnt/shell/emulated/0";
	system(cmd);
}

void mtpfuse_destroy (void *) {
	//Release mtp entries
	for (size_t i = 0;i < mtpEntries.size();i++) {
		childList* list = mtpEntries.valueAt(i);
		list->clear();
	}
	mtpEntries.clear();
	mtp_device->close();
	storageEntries.clear();
	start_media_scanner();
}

void * mtpfuse_init (struct fuse_conn_info *conn) {
	return 0;
}

int main(int argc, char* argv[]) {
	int fuse_stat;

	/*Create the mount directory, if it doesn't exist*/
	struct stat st;
	if (stat(argv[1], &st) != 0) {
		if (mkdir(argv[1], S_IRWXU) != 0 && errno != EEXIST) {
			printf("Could not create mount point %d\n", errno);
			exit(0);
		}
	}

	list_devices();
	if (mtp_device_found && mtp_device != NULL) {
		storageAreaList = mtp_device->getStorageIDs();
		if (storageAreaList == NULL) {
			return 0;
		}

		if (storageAreaList->size() == 0) {
			printf("No storages found\n");
			return 0;
		}
		printf("Found %d storage(s)\n", storageAreaList->size());
		for (size_t i = 0;i < storageAreaList->size();i++) {
			MtpStorageInfo* storageInfo = mtp_device->getStorageInfo(storageAreaList->itemAt(i));
			printf("Desc: %s\n", storageInfo->mStorageDescription);
			storageEntries.add(storageAreaList->itemAt(i), storageInfo->mStorageDescription);
		}
		mtpfuse_get_mtp_objects("/");
		mtpfuse_oper.readdir = mtpfuse_readdir;
		mtpfuse_oper.release = mtpfuse_release;
		mtpfuse_oper.getattr = mtpfuse_getattr;
		mtpfuse_oper.open = mtpfuse_open;
		mtpfuse_oper.read = mtpfuse_read;
		mtpfuse_oper.destroy = mtpfuse_destroy;
		//Mount fuse
		DBG("Setting up FUSE\n");
		fuse_stat = fuse_main(argc, argv, &mtpfuse_oper);
		return fuse_stat;
	}
	return 0;
}