summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rwxr-xr-xmtp/MtpStorage.cpp1152
-rwxr-xr-xmtp/MtpStorage.h43
-rwxr-xr-xmtp/btree.cpp289
-rwxr-xr-xmtp/btree.hpp94
-rwxr-xr-xmtp/mtp_MtpDatabase.cpp103
-rwxr-xr-xmtp/node.cpp88
-rw-r--r--partition.cpp16
-rw-r--r--partitionmanager.cpp13
-rw-r--r--partitions.hpp7
9 files changed, 702 insertions, 1103 deletions
diff --git a/mtp/MtpStorage.cpp b/mtp/MtpStorage.cpp
index 57c87745e..4c55361fa 100755
--- a/mtp/MtpStorage.cpp
+++ b/mtp/MtpStorage.cpp
@@ -21,6 +21,7 @@
#include "MtpDataPacket.h"
#include "MtpServer.h"
#include "MtpEventPacket.h"
+#include "MtpDatabase.h"
#include <sys/types.h>
#include <sys/stat.h>
@@ -35,12 +36,9 @@
#include <signal.h>
#include <sys/inotify.h>
#include <fcntl.h>
-#include <sstream>
#define WATCH_FLAGS ( IN_CREATE | IN_DELETE | IN_MOVE | IN_MODIFY )
-static int mtpid = 0;
-
MtpStorage::MtpStorage(MtpStorageID id, const char* filePath,
const char* description, uint64_t reserveSpace,
bool removable, uint64_t maxFileSize, MtpServer* refserver)
@@ -54,9 +52,9 @@ MtpStorage::MtpStorage(MtpStorageID id, const char* filePath,
mServer(refserver)
{
MTPI("MtpStorage id: %d path: %s\n", id, filePath);
- mtpparentid = 0;
inotify_thread = 0;
sendEvents = false;
+ handleCurrentlySending = 0;
use_mutex = true;
if (pthread_mutex_init(&mtpMutex, NULL) != 0) {
MTPE("Failed to init mtpMutex\n");
@@ -71,8 +69,9 @@ MtpStorage::MtpStorage(MtpStorageID id, const char* filePath,
MtpStorage::~MtpStorage() {
if (inotify_thread) {
+ // TODO: what does this do? manpage says it does not kill the thread
pthread_kill(inotify_thread, 0);
- for (std::map<int, std::string>::iterator i = inotifymap.begin(); i != inotifymap.end(); i++) {
+ for (std::map<int, Tree*>::iterator i = inotifymap.begin(); i != inotifymap.end(); i++) {
inotify_rm_watch(inotify_fd, i->first);
}
close(inotify_fd);
@@ -124,12 +123,8 @@ const char* MtpStorage::getDescription() const {
int MtpStorage::createDB() {
std::string mtpParent = "";
mtpstorageparent = getPath();
- readParentDirs(getPath());
- while (!mtpParentList.empty()) {
- mtpParent = mtpParentList.front();
- mtpParentList.pop_front();
- readParentDirs(mtpParent);
- }
+ // root directory is special: handle 0, parent 0, and empty path
+ mtpmap[0] = new Tree(0, 0, "");
MTPD("MtpStorage::createDB DONE\n");
if (use_mutex) {
MTPD("Starting inotify thread\n");
@@ -138,524 +133,399 @@ int MtpStorage::createDB() {
} else {
MTPD("NOT starting inotify thread\n");
}
+ // for debugging and caching purposes, read the root dir already now
+ readDir(mtpstorageparent, mtpmap[0]);
+ // all other dirs are read on demand
return 0;
}
MtpObjectHandleList* MtpStorage::getObjectList(MtpStorageID storageID, MtpObjectHandle parent) {
- std::vector<int> mtpids;
- int local_mtpparentid;
- MTPD("MtpStorage::getObjectList\n");
- MTPD("parent: %d\n", parent);
+ MTPD("MtpStorage::getObjectList, parent: %u\n", parent);
//append object id (numerical #s) of database to int array
MtpObjectHandleList* list = new MtpObjectHandleList();
if (parent == MTP_PARENT_ROOT) {
MTPD("parent == MTP_PARENT_ROOT\n");
- local_mtpparentid = 1;
- }
- else {
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- MTPD("root: %d\n", i->second->Root());
- Node* node = i->second->findNode(parent, i->second->Root());
- if (node != NULL) {
- local_mtpparentid = i->second->getMtpParentId(node);
- MTPD("path: %s\n", i->second->getPath(node).c_str());
- MTPD("mtpparentid: %d going to endloop\n", local_mtpparentid);
- goto endloop;
- }
- }
+ parent = 0;
}
- MTPD("got to endloop\n");
- endloop:
- if (mtpmap[local_mtpparentid] == NULL) {
- MTPD("mtpmap[mtpparentid] == NULL, returning\n");
+ if (mtpmap.find(parent) == mtpmap.end()) {
+ MTPE("parent handle not found, returning empty list\n");
return list;
}
- MTPD("root: %d\n", mtpmap[local_mtpparentid]->Root());
- mtpmap[local_mtpparentid]->getmtpids(mtpmap[local_mtpparentid]->Root(), &mtpids);
- MTPD("here, mtpids->size(): %i\n", mtpids.size());
-
- for (unsigned index = 0; index < mtpids.size(); index++) {
- MTPD("mtpidhere[%i]: %d\n", index, mtpids.at(index));
- list->push(mtpids.at(index));
+ Tree* tree = mtpmap[parent];
+ if (!tree->wasAlreadyRead())
+ {
+ std::string path = getNodePath(tree);
+ MTPD("reading directory on demand for tree %p (%u), path: %s\n", tree, tree->Mtpid(), path.c_str());
+ readDir(path, tree);
}
+
+ mtpmap[parent]->getmtpids(list);
+ MTPD("returning %u objects in %s.\n", list->size(), tree->getName().c_str());
return list;
}
int MtpStorage::getObjectInfo(MtpObjectHandle handle, MtpObjectInfo& info) {
struct stat st;
uint64_t size = 0;
- MTPD("MtpStorage::getObjectInfo handle: %d\n", handle);
- for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- Node* node = i->second->findNode(handle, i->second->Root());
- MTPD("node returned: %d\n", node);
- if (node != NULL) {
- MTPD("found mtpid: %d\n", node->Mtpid());
- info.mStorageID = getStorageID();
- MTPD("info.mStorageID: %d\n", info.mStorageID);
- info.mParent = node->getMtpParentId();
- MTPD("mParent: %d\n", info.mParent);
- if (lstat(node->getPath().c_str(), &st) == 0)
- size = st.st_size;
- MTPD("size is: %llu\n", size);
- info.mCompressedSize = size;//(size > 0xFFFFFFFFLL ? 0xFFFFFFFF : size);
- info.mDateModified = st.st_mtime;
- if (S_ISDIR(st.st_mode)) {
- info.mFormat = MTP_FORMAT_ASSOCIATION;
- }
- else {
- info.mFormat = MTP_FORMAT_UNDEFINED;
- }
- info.mName = strdup(basename(node->getPath().c_str()));
- MTPD("MtpStorage::getObjectInfo found, Exiting getObjectInfo()\n");
- return 0;
- }
+ MTPD("MtpStorage::getObjectInfo, handle: %u\n", handle);
+ Node* node = findNode(handle);
+ if (!node) {
+ // Item is not on this storage device
+ return -1;
}
- // Item is not on this storage device
- return -1;
+
+ info.mStorageID = getStorageID();
+ MTPD("info.mStorageID: %u\n", info.mStorageID);
+ info.mParent = node->getMtpParentId();
+ MTPD("mParent: %u\n", info.mParent);
+ // TODO: do we want to lstat again here, or read from the node properties?
+ if (lstat(getNodePath(node).c_str(), &st) == 0)
+ size = st.st_size;
+ MTPD("size is: %llu\n", size);
+ info.mCompressedSize = (size > 0xFFFFFFFFLL ? 0xFFFFFFFF : size);
+ info.mDateModified = st.st_mtime;
+ if (S_ISDIR(st.st_mode)) {
+ info.mFormat = MTP_FORMAT_ASSOCIATION;
+ }
+ else {
+ info.mFormat = MTP_FORMAT_UNDEFINED;
+ }
+ info.mName = strdup(node->getName().c_str());
+ MTPD("MtpStorage::getObjectInfo found, Exiting getObjectInfo()\n");
+ return 0;
}
MtpObjectHandle MtpStorage::beginSendObject(const char* path,
MtpObjectFormat format,
MtpObjectHandle parent,
- MtpStorageID storage,
uint64_t size,
time_t modified) {
- MTPD("MtpStorage::beginSendObject(), path: '%s', parent: %d, storage: %d, format: %04x\n", path, parent, storage, format);
- Node* node;
- std::string parentdir;
+ MTPD("MtpStorage::beginSendObject(), path: '%s', parent: %u, format: %04x\n", path, parent, format);
+ iter it = mtpmap.find(parent);
+ if (it == mtpmap.end()) {
+ MTPE("parent node not found, returning error\n");
+ return kInvalidObjectHandle;
+ }
+ Tree* tree = it->second;
+
std::string pathstr(path);
- int parent_id;
- parentdir = pathstr.substr(0, pathstr.find_last_of('/'));
- MTPD("MtpStorage::beginSendObject() parentdir: %s\n", parentdir.c_str());
- if (parentdir.compare(mtpstorageparent) == 0) {
- // root directory
- MTPD("MtpStorage::beginSendObject() root dir\n");
- parent_id = 1;
- ++mtpid;
- node = mtpmap[parent_id]->addNode(mtpid, path);
- MTPD("node: %d\n", node);
- node->addProperties(storage, 0);
- if (format == MTP_FORMAT_ASSOCIATION) {
- createEmptyDir(path);
- }
- return mtpid;
- } else {
- for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- node = i->second->findNodePath(parentdir, i->second->Root());
- if (node != NULL) {
- MTPD("mtpid: %d\n", mtpid);
- MTPD("path: %s\n", i->second->getPath(node).c_str());
- parentdir = i->second->getPath(node);
- parent = i->second->getMtpParentId(node);
- if (parent == 0) {
- MTPD("MtpStorage::beginSendObject parent is 0, error.\n");
- return -1;
- } else {
- ++mtpid;
- node = mtpmap[parent]->addNode(mtpid, path);
- node->addProperties(getStorageID(), getParentObject(parentdir));
- for (iter i2 = mtpmap.begin(); i2 != mtpmap.end(); i2++) {
- node = i2->second->findNodePath(path, i2->second->Root());
- if (node != NULL) {
- i2->second->setMtpParentId(parent, node);
- }
- }
- if (format == MTP_FORMAT_ASSOCIATION) {
- createEmptyDir(path);
- }
- }
- return mtpid;
- }
- }
+ size_t slashpos = pathstr.find_last_of('/');
+ if (slashpos == std::string::npos) {
+ MTPE("path has no slash, returning error\n");
+ return kInvalidObjectHandle;
}
- MTPE("MtpStorage::beginSendObject(), path: '%s', parent: %d, storage: %d, format: %04x\n", path, parent, storage, format);
- return -1;
+ std::string parentdir = pathstr.substr(0, slashpos);
+ std::string basename = pathstr.substr(slashpos + 1);
+ if (parent != 0 && parentdir != getNodePath(tree)) {
+ MTPE("beginSendObject into path '%s' but parent tree has path '%s', returning error\n", parentdir.c_str(), getNodePath(tree).c_str());
+ return kInvalidObjectHandle;
+ }
+
+ MTPD("MtpStorage::beginSendObject() parentdir: %s basename: %s\n", parentdir.c_str(), basename.c_str());
+ // note: for directories, the mkdir call is done later in MtpServer, here we just reserve a handle
+ bool isDir = format == MTP_FORMAT_ASSOCIATION;
+ Node* node = addNewNode(isDir, tree, basename);
+ handleCurrentlySending = node->Mtpid(); // suppress inotify for this node while sending
+
+ return node->Mtpid();
+}
+
+void MtpStorage::endSendObject(const char* path, MtpObjectHandle handle, MtpObjectFormat format, bool succeeded)
+{
+ Node* node = findNode(handle);
+ if (!node)
+ return; // just ignore if this is for another storage
+
+ node->addProperties(path, mStorageID);
+ handleCurrentlySending = 0;
+ // TODO: are we supposed to send an event about an upload by the initiator?
+ if (sendEvents)
+ mServer->sendObjectAdded(node->Mtpid());
}
int MtpStorage::getObjectFilePath(MtpObjectHandle handle, MtpString& outFilePath, int64_t& outFileLength, MtpObjectFormat& outFormat) {
- struct stat st;
- Node* node;
- MTPD("MtpStorage::getObjectFilePath handle: %i\n", handle);
- for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- MTPD("handle: %d\n", handle);
- node = i->second->findNode(handle, i->second->Root());
- MTPD("node returned: %d\n", node);
- if (node != NULL) {
- if (lstat(node->getPath().c_str(), &st) == 0)
- outFileLength = st.st_size;
- else
- outFileLength = 0;
- outFilePath = strdup(node->getPath().c_str());
- MTPD("outFilePath: %s\n", node->getPath().c_str());
- goto end;
- }
+ MTPD("MtpStorage::getObjectFilePath handle: %u\n", handle);
+ Node* node = findNode(handle);
+ if (!node)
+ {
+ // Item is not on this storage device
+ return -1;
}
- // Item is not on this storage
- return -1;
-end:
- outFormat = MTP_FORMAT_ASSOCIATION;
+ // TODO: do we want to lstat here, or just read the info from the node?
+ struct stat st;
+ if (lstat(getNodePath(node).c_str(), &st) == 0)
+ outFileLength = st.st_size;
+ else
+ outFileLength = 0;
+ outFilePath = getNodePath(node).c_str();
+ MTPD("outFilePath: %s\n", outFilePath.string());
+ outFormat = node->isDir() ? MTP_FORMAT_ASSOCIATION : MTP_FORMAT_UNDEFINED;
return 0;
}
-int MtpStorage::readParentDirs(std::string path) {
+int MtpStorage::readDir(const std::string& path, Tree* tree)
+{
struct dirent *de;
- struct stat st;
- DIR *d;
- std::string parent, item, prevparent = "";
- Node* node;
int storageID = getStorageID();
+ MtpObjectHandle parent = tree->Mtpid();
- d = opendir(path.c_str());
- MTPD("opening '%s'\n", path.c_str());
+ DIR *d = opendir(path.c_str());
+ MTPD("reading dir '%s', parent handle %u\n", path.c_str(), parent);
if (d == NULL) {
- MTPD("error opening '%s' -- error: %s\n", path.c_str(), strerror(errno));
- closedir(d);
+ MTPE("error opening '%s' -- error: %s\n", path.c_str(), strerror(errno));
+ return -1;
}
+ // TODO: for refreshing dirs: capture old entries here
while ((de = readdir(d)) != NULL) {
// Because exfat-fuse causes issues with dirent, we will use stat
// for some things that dirent should be able to do
- item = path + "/" + de->d_name;
+ std::string item = path + "/" + de->d_name;
+ struct stat st;
if (lstat(item.c_str(), &st)) {
MTPE("Error running lstat on '%s'\n", item.c_str());
return -1;
}
- if ((st.st_mode & S_IFDIR) && strcmp(de->d_name, ".") == 0)
+ // TODO: if we want to use this for refreshing dirs too, first find existing name and overwrite
+ if (strcmp(de->d_name, ".") == 0)
continue;
- if ((st.st_mode & S_IFDIR) && strcmp(de->d_name, "..") != 0) {
- // Handle dirs
- MTPD("dir: %s\n", item.c_str());
- mtpParentList.push_back(item);
- parent = item.substr(0, item.find_last_of('/'));
- ++mtpid;
- MTPD("parent: %s\n", parent.c_str());
- MTPD("mtpid: %d\n", mtpid);
- if (prevparent != parent) {
- mtpparentid++;
- MTPD("Handle dirs, prevparent != parent, mtpparentid: %d\n", mtpparentid);
- mtpmap[mtpparentid] = new Tree();
- MTPD("prevparent addNode\n");
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- node = i->second->findNodePath(parent, i->second->Root());
- if (node != NULL) {
- i->second->setMtpParentId(mtpparentid, node);
- }
- }
- node = mtpmap[mtpparentid]->addNode(mtpid, item);
- node->addProperties(storageID, getParentObject(path));
- if (sendEvents)
- mServer->sendObjectAdded(mtpid);
- }
- else {
- MTPD("add node\n");
- mtpmap[mtpparentid]->addNode(mtpid, item);
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- node = i->second->findNodePath(item, i->second->Root());
- if (node != NULL) {
- i->second->setMtpParentId(mtpparentid, node);
- node->addProperties(storageID, getParentObject(path));
- }
- }
- if (sendEvents)
- mServer->sendObjectAdded(mtpid);
- }
- prevparent = parent;
- }
- else {
- if (strcmp(de->d_name, "..") != 0) {
- // Handle files
- item = path + "/" + de->d_name;
- MTPD("file: %s\n", item.c_str());
- parent = item.substr(0, item.find_last_of('/'));
- MTPD("parent: %s\n", parent.c_str());
- ++mtpid;
- MTPD("mtpid: %d\n", mtpid);
- if (prevparent != parent) {
- mtpparentid++;
- MTPD("mtpparentid1: %d\n", mtpparentid);
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- node = i->second->findNodePath(path, i->second->Root());
- if (node != NULL) {
- i->second->setMtpParentId(mtpparentid, node);
- node->addProperties(storageID, getParentObject(path));
- }
- }
- }
- if (mtpmap[mtpparentid] == NULL) {
- mtpmap[mtpparentid] = new Tree();
- }
- MTPD("blank addNode\n");
- node = mtpmap[mtpparentid]->addNode(mtpid, item);
- node->addProperties(storageID, getParentObject(path));
- prevparent = parent;
- if (sendEvents)
- mServer->sendObjectAdded(mtpid);
- }
- else {
- // Handle empty dirs?
- MTPD("checking for empty dir '%s'\n", path.c_str());
- int count = 0;
- DIR *dirc;
- struct dirent *ep;
- dirc = opendir(path.c_str());
- if (dirc != NULL) {
- while ((ep = readdir(dirc)))
- ++count;
- MTPD("count: %d\n", count);
- closedir(dirc);
- }
- if (count == 2) {
- MTPD("'%s' is an empty dir\n", path.c_str());
- createEmptyDir(path.c_str());
- goto end;
- }
- }
- }
- }
- end:
- closedir(d);
- return 0;
-}
-
-void MtpStorage::deleteTrees(int parent) {
- Node* node = mtpmap[parent]->Root();
- MTPD("MtpStorage::deleteTrees deleting %i\n", parent);
- while (node != NULL) {
- if (node->getIntProperty(MTP_PROPERTY_OBJECT_FORMAT) == MTP_FORMAT_ASSOCIATION) {
- deleteTrees(node->getMtpParentId());
- }
- node = mtpmap[parent]->getNext(node);
+ if (strcmp(de->d_name, "..") == 0)
+ continue;
+ Node* node = addNewNode(st.st_mode & S_IFDIR, tree, de->d_name);
+ node->addProperties(item, storageID);
+ //if (sendEvents)
+ // mServer->sendObjectAdded(node->Mtpid());
+ // sending events here makes simple-mtpfs very slow, and it is probably the wrong thing to do anyway
}
- delete mtpmap[parent];
- mtpmap.erase(parent);
- MTPD("MtpStorage::deleteTrees deleted %i\n", parent);
+ closedir(d);
+ // TODO: for refreshing dirs: remove entries that no longer exist (with their nodes)
+ tree->setAlreadyRead(true);
+ addInotify(tree);
+ return 0;
}
int MtpStorage::deleteFile(MtpObjectHandle handle) {
- int local_parent_id = 0;
- for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- MTPD("MtpStorage::deleteFile handle: %d\n", handle);
- Node* node = i->second->findNode(handle, i->second->Root());
- MTPD("MtpStorage::deleteFile node returned: %d\n", node);
- if (node != NULL) {
- if (node->getIntProperty(MTP_PROPERTY_OBJECT_FORMAT) == MTP_FORMAT_ASSOCIATION) {
- local_parent_id = node->getMtpParentId();
- }
- MTPD("deleting handle: %d\n", handle);
- i->second->deleteNode(handle);
- MTPD("deleted\n");
- goto end;
- }
+ MTPD("MtpStorage::deleteFile handle: %u\n", handle);
+ Node* node = findNode(handle);
+ if (!node) {
+ // Item is not on this storage device
+ return -1;
}
- return -1;
-end:
- if (local_parent_id) {
- deleteTrees(local_parent_id);
+ MtpObjectHandle parent = node->getMtpParentId();
+ Tree* tree = mtpmap[parent];
+ if (!tree) {
+ MTPE("parent tree for handle %u not found\n", parent);
+ return -1;
+ }
+ if (node->isDir()) {
+ MTPD("deleting tree from mtpmap: %u\n", handle);
+ mtpmap.erase(handle);
}
+
+ MTPD("deleting handle: %u\n", handle);
+ tree->deleteNode(handle);
+ MTPD("deleted\n");
return 0;
}
-int MtpStorage::getObjectPropertyList(MtpObjectHandle handle, uint32_t format, uint32_t property, int groupCode, int depth, MtpDataPacket& packet) {
- Node *n;
- int local_mtpid = 0;
- int local_mtpparentid = 0;
- std::vector<int> propertyCodes;
- std::vector<int> dataTypes;
- std::vector<std::string> valueStrs;
- std::vector<int> longValues;
- int count = 0;
- MTPD("MtpStorage::getObjectPropertyList handle: %d, format: %d, property: %lx\n", handle, format, property);
- if (property == MTP_PROPERTY_OBJECT_FORMAT) {
- MTPD("MtpStorage::getObjectPropertyList MTP_PROPERTY_OBJECT_FORMAT\n");
- for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- MTPD("root: %d\n", i->second->Root());
- Node *node = i->second->findNode(handle, i->second->Root());
- MTPD("index: %d\n", index);
- MTPD("node: %d\n", node);
- if (node != NULL) {
- uint64_t longval = node->getIntProperty(MTP_PROPERTY_OBJECT_FORMAT);
- local_mtpparentid = i->second->getMtpParentId(node);
- MTPD("object format longValue: %llu\n", longval);
- propertyCodes.push_back(MTP_PROPERTY_OBJECT_FORMAT);
- longValues.push_back(node->getIntProperty(MTP_PROPERTY_OBJECT_FORMAT));
- valueStrs.push_back("");
- dataTypes.push_back(4);
- count = 1;
- local_mtpid = node->Mtpid();
- goto endloop;
- }
+void MtpStorage::queryNodeProperties(std::vector<MtpStorage::PropEntry>& results, Node* node, uint32_t property, int groupCode, MtpStorageID storageID)
+{
+ MTPD("queryNodeProperties handle %u, path: %s\n", node->Mtpid(), getNodePath(node).c_str());
+ PropEntry pe;
+ pe.handle = node->Mtpid();
+ pe.property = property;
+
+ if (property == 0xffffffff)
+ {
+ // add all properties
+ MTPD("MtpStorage::queryNodeProperties for all properties\n");
+ std::vector<Node::mtpProperty> mtpprop = node->getMtpProps();
+ for (size_t i = 0; i < mtpprop.size(); ++i) {
+ pe.property = mtpprop[i].property;
+ pe.datatype = mtpprop[i].dataType;
+ pe.intvalue = mtpprop[i].valueInt;
+ pe.strvalue = mtpprop[i].valueStr;
+ results.push_back(pe);
}
- }
- else if (property == MTP_PROPERTY_STORAGE_ID) {
- MTPD("MtpStorage::getObjectPropertyList MTP_PROPERTY_STORAGE_ID\n");
- for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- MTPD("root: %d\n", i->second->Root());
- Node *node = i->second->findNode(handle, i->second->Root());
- if (node != NULL) {
- propertyCodes.push_back(MTP_PROPERTY_STORAGE_ID);
- longValues.push_back(getStorageID());
- valueStrs.push_back("");
- dataTypes.push_back(4);
- count = 1;
- local_mtpid = node->Mtpid();
- goto endloop;
- }
+ return;
+ }
+ else if (property == 0)
+ {
+ // TODO: use groupCode
+ }
+
+ // single property
+ // TODO: this should probably be moved to the Node class and/or merged with getObjectPropertyValue
+ switch (property) {
+// case MTP_PROPERTY_OBJECT_FORMAT:
+// pe.datatype = MTP_TYPE_UINT16;
+// pe.intvalue = node->getIntProperty(MTP_PROPERTY_OBJECT_FORMAT);
+// break;
+
+ case MTP_PROPERTY_STORAGE_ID:
+ pe.datatype = MTP_TYPE_UINT32;
+ pe.intvalue = storageID;
+ break;
+
+ case MTP_PROPERTY_PROTECTION_STATUS:
+ pe.datatype = MTP_TYPE_UINT16;
+ pe.intvalue = 0;
+ break;
+
+ case MTP_PROPERTY_OBJECT_SIZE:
+ {
+ pe.datatype = MTP_TYPE_UINT64;
+ struct stat st;
+ pe.intvalue = 0;
+ if (lstat(getNodePath(node).c_str(), &st) == 0)
+ pe.intvalue = st.st_size;
+ break;
}
- }
- else if (property == MTP_PARENT_ROOT) {
- MTPD("MtpStorage::getObjectPropertyList MTP_PARENT_ROOT\n");
- for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- MTPD("root: %d\n", i->second->Root());
- Node* node = i->second->findNode(handle, i->second->Root());
- if (node != NULL) {
- local_mtpparentid = i->second->getMtpParentId(node);
- MTPD("path: %s\n", i->second->getPath(node).c_str());
- MTPD("mtpparentid: %d going to endloop\n", local_mtpparentid);
- std::vector<Node::mtpProperty> mtpprop = node->getMtpProps();
- count = mtpprop.size();
- for (int i = 0; i < count; ++i) {
- propertyCodes.push_back(mtpprop[i].property);
- longValues.push_back(mtpprop[i].valueInt);
- valueStrs.push_back(mtpprop[i].valueStr);
- dataTypes.push_back(mtpprop[i].dataType);
- }
- local_mtpid = node->Mtpid();
- goto endloop;
+
+ default:
+ {
+ const Node::mtpProperty& prop = node->getProperty(property);
+ if (prop.property != property)
+ {
+ MTPD("queryNodeProperties: unknown property %x\n", property);
+ return;
}
+ pe.datatype = prop.dataType;
+ pe.intvalue = prop.valueInt;
+ pe.strvalue = prop.valueStr;
+ // TODO: all the special case stuff in MyMtpDatabase::getObjectPropertyValue is missing here
}
+
}
- else if (property == MTP_PROPERTY_PROTECTION_STATUS) {
- MTPD("MtpStorage::getObjectPropertyList MTP_PROPERTY_PROTECTION_STATUS\n");
- for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- MTPD("root: %d\n", i->second->Root());
- Node *node = i->second->findNode(handle, i->second->Root());
- if (node != NULL) {
- propertyCodes.push_back(MTP_PROPERTY_PROTECTION_STATUS);
- longValues.push_back(0);
- valueStrs.push_back("");
- dataTypes.push_back(8);
- count = 1;
- local_mtpid = node->Mtpid();
- goto endloop;
+ results.push_back(pe);
+}
+
+int MtpStorage::getObjectPropertyList(MtpObjectHandle handle, uint32_t format, uint32_t property, int groupCode, int depth, MtpDataPacket& packet) {
+ MTPD("MtpStorage::getObjectPropertyList handle: %u, format: %x, property: %x\n", handle, format, property);
+ if (groupCode != 0)
+ {
+ MTPE("getObjectPropertyList: groupCode unsupported\n");
+ return -1; // TODO: RESPONSE_SPECIFICATION_BY_GROUP_UNSUPPORTED
+ }
+ // TODO: support all the special stuff, like:
+ // handle == 0 -> all objects at the root level
+ // handle == 0xffffffff -> all objects (on all storages? how could we support that?)
+ // format == 0 -> all formats, otherwise filter by ObjectFormatCode
+ // property == 0xffffffff -> all properties except those with group code 0xffffffff
+ // if property == 0 then use groupCode
+ // groupCode == 0 -> return Specification_By_Group_Unsupported
+ // depth == 0xffffffff -> all objects incl. and below handle
+
+ std::vector<PropEntry> results;
+
+ if (handle == 0xffffffff) {
+ // TODO: all object on all storages (needs a different design, result packet needs to be built by server instead of storage)
+ } else if (handle == 0) {
+ // all objects at the root level
+ Tree* root = mtpmap[0];
+ MtpObjectHandleList list;
+ root->getmtpids(&list);
+ for (MtpObjectHandleList::iterator it = list.begin(); it != list.end(); ++it) {
+ Node* node = root->findNode(*it);
+ if (!node) {
+ MTPE("BUG: node not found for root entry with handle %u\n", *it);
+ break;
}
+ queryNodeProperties(results, node, property, groupCode, mStorageID);
}
- }
- else if (property == MTP_PROPERTY_OBJECT_SIZE) {
- MTPD("MtpStorage::getObjectPropertyList MTP_PROPERTY_OBJECT_SIZE\n");
- for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- MTPD("root: %d\n", i->second->Root());
- Node *node = i->second->findNode(handle, i->second->Root());
- if (node != NULL) {
- struct stat st;
- uint64_t size = 0;
- if (lstat(node->getPath().c_str(), &st) == 0)
- size = st.st_size;
- propertyCodes.push_back(MTP_PROPERTY_OBJECT_SIZE);
- longValues.push_back(size);
- valueStrs.push_back("");
- dataTypes.push_back(8);
- count = 1;
- local_mtpid = node->Mtpid();
- goto endloop;
- }
+ } else {
+ // single object
+ Node* node = findNode(handle);
+ if (!node) {
+ // Item is not on this storage device
+ return -1;
}
- }
- else {
- // Either the property is not supported or the handle is not on this storage
- return -1;
- }
- // handle not found on this storage
- return -1;
-
-endloop:
- MTPD("mtpparentid: %d\n", local_mtpparentid);
- MTPD("count: %d\n", count);
- packet.putUInt32(count);
-
- if (count > 0) {
- std::string stringValuesArray;
- for (int i = 0; i < count; ++i) {
- packet.putUInt32(local_mtpid);
- packet.putUInt16(propertyCodes[i]);
- MTPD("dataTypes: %d\n", dataTypes[i]);
- packet.putUInt16(dataTypes[i]);
- MTPD("propertyCode: %s\n", MtpDebug::getObjectPropCodeName(propertyCodes[i]));
- MTPD("longValues: %d\n", longValues[i]);
- switch (dataTypes[i]) {
- case MTP_TYPE_INT8:
- MTPD("MTP_TYPE_INT8\n");
- packet.putInt8(longValues[i]);
- break;
- case MTP_TYPE_UINT8:
- MTPD("MTP_TYPE_UINT8\n");
- packet.putUInt8(longValues[i]);
- break;
- case MTP_TYPE_INT16:
- MTPD("MTP_TYPE_INT16\n");
- packet.putInt16(longValues[i]);
- break;
- case MTP_TYPE_UINT16:
- MTPD("MTP_TYPE_UINT16\n");
- packet.putUInt16(longValues[i]);
- break;
- case MTP_TYPE_INT32:
- MTPD("MTP_TYPE_INT32\n");
- packet.putInt32(longValues[i]);
- break;
- case MTP_TYPE_UINT32:
- MTPD("MTP_TYPE_UINT32\n");
- packet.putUInt32(longValues[i]);
- break;
- case MTP_TYPE_INT64:
- MTPD("MTP_TYPE_INT64\n");
- packet.putInt64(longValues[i]);
- break;
- case MTP_TYPE_UINT64:
- MTPD("MTP_TYPE_UINT64\n");
- packet.putUInt64(longValues[i]);
- break;
- case MTP_TYPE_INT128:
- MTPD("MTP_TYPE_INT128\n");
- packet.putInt128(longValues[i]);
- break;
- case MTP_TYPE_UINT128:
- MTPD("MTP_TYPE_UINT128\n");
- packet.putUInt128(longValues[i]);
- break;
- case MTP_TYPE_STR:
- MTPD("MTP_TYPE_STR: %s\n", valueStrs[i].c_str());
- packet.putString((const char*) valueStrs[i].c_str());
- break;
- default:
- MTPE("bad or unsupported data type: %i in MyMtpDatabase::getObjectPropertyList", dataTypes[i]);
- break;
- }
+ queryNodeProperties(results, node, property, groupCode, mStorageID);
+ }
+
+ MTPD("count: %u\n", results.size());
+ packet.putUInt32(results.size());
+
+ for (size_t i = 0; i < results.size(); ++i) {
+ PropEntry& p = results[i];
+ MTPD("handle: %u, propertyCode: %x = %s, datatype: %x, value: %llu\n",
+ p.handle, p.property, MtpDebug::getObjectPropCodeName(p.property),
+ p.datatype, p.intvalue);
+ packet.putUInt32(p.handle);
+ packet.putUInt16(p.property);
+ packet.putUInt16(p.datatype);
+ switch (p.datatype) {
+ case MTP_TYPE_INT8:
+ MTPD("MTP_TYPE_INT8\n");
+ packet.putInt8(p.intvalue);
+ break;
+ case MTP_TYPE_UINT8:
+ MTPD("MTP_TYPE_UINT8\n");
+ packet.putUInt8(p.intvalue);
+ break;
+ case MTP_TYPE_INT16:
+ MTPD("MTP_TYPE_INT16\n");
+ packet.putInt16(p.intvalue);
+ break;
+ case MTP_TYPE_UINT16:
+ MTPD("MTP_TYPE_UINT16\n");
+ packet.putUInt16(p.intvalue);
+ break;
+ case MTP_TYPE_INT32:
+ MTPD("MTP_TYPE_INT32\n");
+ packet.putInt32(p.intvalue);
+ break;
+ case MTP_TYPE_UINT32:
+ MTPD("MTP_TYPE_UINT32\n");
+ packet.putUInt32(p.intvalue);
+ break;
+ case MTP_TYPE_INT64:
+ MTPD("MTP_TYPE_INT64\n");
+ packet.putInt64(p.intvalue);
+ break;
+ case MTP_TYPE_UINT64:
+ MTPD("MTP_TYPE_UINT64\n");
+ packet.putUInt64(p.intvalue);
+ break;
+ case MTP_TYPE_INT128:
+ MTPD("MTP_TYPE_INT128\n");
+ packet.putInt128(p.intvalue);
+ break;
+ case MTP_TYPE_UINT128:
+ MTPD("MTP_TYPE_UINT128\n");
+ packet.putUInt128(p.intvalue);
+ break;
+ case MTP_TYPE_STR:
+ MTPD("MTP_TYPE_STR: %s\n", p.strvalue.c_str());
+ packet.putString(p.strvalue.c_str());
+ break;
+ default:
+ MTPE("bad or unsupported data type: %x in MyMtpDatabase::getObjectPropertyList", p.datatype);
+ break;
}
}
return 0;
}
int MtpStorage::renameObject(MtpObjectHandle handle, std::string newName) {
- int index;
- MTPD("MtpStorage::renameObject, handle: %d, new name: '%s'\n", handle, newName.c_str());
+ MTPD("MtpStorage::renameObject, handle: %u, new name: '%s'\n", handle, newName.c_str());
if (handle == MTP_PARENT_ROOT) {
MTPE("parent == MTP_PARENT_ROOT, cannot rename root\n");
return -1;
} else {
for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- MTPD("root: %d\n", i->second->Root());
- Node* node = i->second->findNode(handle, i->second->Root());
+ Node* node = i->second->findNode(handle);
if (node != NULL) {
- std::string oldName = i->second->getPath(node);
+ std::string oldName = getNodePath(node);
std::string parentdir = oldName.substr(0, oldName.find_last_of('/'));
std::string newFullName = parentdir + "/" + newName;
MTPD("old: '%s', new: '%s'\n", oldName.c_str(), newFullName.c_str());
if (rename(oldName.c_str(), newFullName.c_str()) == 0) {
- node->rename(newFullName);
+ node->rename(newName);
return 0;
} else {
- MTPE("MtpStorage::renameObject failed, handle: %d, new name: '%s'\n", handle, newName.c_str());
+ MTPE("MtpStorage::renameObject failed, handle: %u, new name: '%s'\n", handle, newName.c_str());
return -1;
}
}
@@ -665,32 +535,28 @@ int MtpStorage::renameObject(MtpObjectHandle handle, std::string newName) {
return -1;
}
-void MtpStorage::createEmptyDir(const char* path) {
- Node *node;
- ++mtpparentid;
- MtpStorageID storage = getStorageID();
- MTPD("MtpStorage::createEmptyDir path: '%s', storage: %i, mtpparentid: %d\n", path, storage, mtpparentid);
- mtpmap[mtpparentid] = new Tree();
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- node = i->second->findNodePath(path, i->second->Root());
- if (node != NULL) {
- mtpmap[mtpparentid]->setMtpParentId(mtpparentid, node);
- }
- }
-}
-
-int MtpStorage::getObjectPropertyValue(MtpObjectHandle handle, MtpObjectProperty property, uint64_t &longValue) {
+int MtpStorage::getObjectPropertyValue(MtpObjectHandle handle, MtpObjectProperty property, MtpStorage::PropEntry& pe) {
Node *node;
for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
- node = i->second->findNode(handle, i->second->Root());
+ node = i->second->findNode(handle);
if (node != NULL) {
- longValue = node->getIntProperty(property);
+ const Node::mtpProperty& prop = node->getProperty(property);
+ if (prop.property != property) {
+ MTPD("getObjectPropertyValue: unknown property %x for handle %u\n", property, handle);
+ return -1;
+ }
+ pe.datatype = prop.dataType;
+ pe.intvalue = prop.valueInt;
+ pe.strvalue = prop.valueStr;
+ pe.handle = handle;
+ pe.property = property;
return 0;
}
}
// handle not found on this storage
return -1;
}
+
pthread_t MtpStorage::inotify(void) {
pthread_t thread;
ThreadPtr inotifyptr = &MtpStorage::inotify_t;
@@ -699,229 +565,227 @@ pthread_t MtpStorage::inotify(void) {
return thread;
}
-int MtpStorage::addInotifyDirs(std::string path) {
- struct dirent *de;
- DIR *d;
- struct stat st;
- std::string inotifypath;
-
- d = opendir(path.c_str());
- if (d == NULL) {
- MTPE("MtpStorage::addInotifyDirs unable to open '%s'\n", path.c_str());
- closedir(d);
+int MtpStorage::addInotify(Tree* tree) {
+ std::string path = getNodePath(tree);
+ MTPD("adding inotify for tree %x, dir: %s\n", tree, path.c_str());
+ int wd = inotify_add_watch(inotify_fd, path.c_str(), WATCH_FLAGS);
+ if (wd < 0) {
+ MTPE("inotify_add_watch failed: %s\n", strerror(errno));
return -1;
}
+ inotifymap[wd] = tree;
+ return 0;
+}
- while ((de = readdir(d)) != NULL) {
- inotifypath = path + "/" + de->d_name;
- if (lstat(inotifypath.c_str(), &st)) {
- MTPE("Error using lstat on '%s'\n", inotifypath.c_str());
- return -1;
+void MtpStorage::handleInotifyEvent(struct inotify_event* event)
+{
+ std::map<int, Tree*>::iterator it = inotifymap.find(event->wd);
+ if (it == inotifymap.end()) {
+ MTPE("Unable to locate inotify_wd: %i\n", event->wd);
+ return;
+ }
+ Tree* tree = it->second;
+ MTPD("inotify_t tree: %x '%s'\n", tree, tree->getName().c_str());
+ Node* node = tree->findEntryByName(basename(event->name));
+ if (node && node->Mtpid() == handleCurrentlySending) {
+ MTPD("ignoring inotify event for currently uploading file, handle: %u\n", node->Mtpid());
+ return;
+ }
+ if (event->mask & IN_CREATE || event->mask & IN_MOVED_TO) {
+ if (event->mask & IN_ISDIR) {
+ MTPD("inotify_t create is dir\n");
+ } else {
+ MTPD("inotify_t create is file\n");
}
- if (!(st.st_mode & S_IFDIR) || strcmp(de->d_name, ".") == 0 || strcmp(de->d_name, "..") == 0)
- continue;
- if (addInotifyDirs(inotifypath)) {
- closedir(d);
- return -1;
+ if (node == NULL) {
+ node = addNewNode(event->mask & IN_ISDIR, tree, event->name);
+ std::string item = getNodePath(tree) + "/" + event->name;
+ node->addProperties(item, getStorageID());
+ mServer->sendObjectAdded(node->Mtpid());
+ } else {
+ MTPD("inotify_t item already exists.\n");
+ }
+ if (event->mask & IN_ISDIR) {
+ // TODO: do we need to do anything here? probably not until someone reads from the dir...
+ }
+ } else if (event->mask & IN_DELETE || event->mask & IN_MOVED_FROM) {
+ if (event->mask & IN_ISDIR) {
+ MTPD("inotify_t Directory %s deleted\n", event->name);
+ } else {
+ MTPD("inotify_t File %s deleted\n", event->name);
+ }
+ if (node)
+ {
+ if (event->mask & IN_ISDIR) {
+ for (std::map<int, Tree*>::iterator it = inotifymap.begin(); it != inotifymap.end(); ++it) {
+ if (it->second == node) {
+ inotify_rm_watch(inotify_fd, it->first);
+ MTPD("inotify_t removing watch on '%s'\n", getNodePath(it->second).c_str());
+ inotifymap.erase(it->first);
+ break;
+ }
+
+ }
+ }
+ MtpObjectHandle handle = node->Mtpid();
+ deleteFile(handle);
+ mServer->sendObjectRemoved(handle);
+ } else {
+ MTPD("inotify_t already removed.\n");
+ }
+ } else if (event->mask & IN_MODIFY) {
+ MTPD("inotify_t item %s modified.\n", event->name);
+ if (node != NULL) {
+ uint64_t orig_size = node->getProperty(MTP_PROPERTY_OBJECT_SIZE).valueInt;
+ struct stat st;
+ uint64_t new_size = 0;
+ if (lstat(getNodePath(node).c_str(), &st) == 0)
+ new_size = (uint64_t)st.st_size;
+ if (orig_size != new_size) {
+ MTPD("size changed from %llu to %llu on mtpid: %u\n", orig_size, new_size, node->Mtpid());
+ node->updateProperty(MTP_PROPERTY_OBJECT_SIZE, new_size, "", MTP_TYPE_UINT64);
+ mServer->sendObjectUpdated(node->Mtpid());
+ }
+ } else {
+ MTPE("inotify_t modified item not found\n");
}
- inotify_wd = inotify_add_watch(inotify_fd, inotifypath.c_str(), WATCH_FLAGS);
- inotifymap[inotify_wd] = inotifypath;
- MTPD("added inotify dir: '%s'\n", inotifypath.c_str());
+ } else if (event->mask & IN_DELETE_SELF || event->mask & IN_MOVE_SELF) {
+ // TODO: is this always already handled by IN_DELETE for the parent dir?
}
- closedir(d);
- return 0;
}
int MtpStorage::inotify_t(void) {
- int len, i = 0;
- int local_mtpparentid;
- Node* node = NULL;
- struct stat st;
#define EVENT_SIZE ( sizeof(struct inotify_event) )
#define EVENT_BUF_LEN ( 1024 * ( EVENT_SIZE + 16) )
char buf[EVENT_BUF_LEN];
- std::string item, parent = "";
- MTPD("starting inotify thread\n");
+ MTPD("inotify thread: inotify_init\n");
inotify_fd = inotify_init();
- if (inotify_fd < 0){
- MTPE("Can't run inotify for mtp server\n");
- }
-
- inotify_wd = inotify_add_watch(inotify_fd, getPath(), WATCH_FLAGS);
- inotifymap[inotify_wd] = getPath();
- if (addInotifyDirs(getPath())) {
- MTPE("MtpStorage::inotify_t failed to add watches to directories\n");
- for (std::map<int, std::string>::iterator i = inotifymap.begin(); i != inotifymap.end(); i++) {
- inotify_rm_watch(inotify_fd, i->first);
- }
- close(inotify_fd);
+ if (inotify_fd < 0) {
+ MTPE("Can't run inotify for mtp server: %s\n", strerror(errno));
return -1;
}
while (true) {
- i = 0;
- len = read(inotify_fd, buf, EVENT_BUF_LEN);
+ int i = 0;
+ int len = read(inotify_fd, buf, EVENT_BUF_LEN);
if (len < 0) {
+ if (errno == EINTR)
+ continue;
MTPE("inotify_t Can't read inotify events\n");
}
while (i < len) {
- struct inotify_event *event = ( struct inotify_event * ) &buf[ i ];
- if ( event->len ) {
- if (inotifymap[event->wd].empty()) {
- MTPE("Unable to locate inotify_wd: %i\n", event->wd);
- goto end;
- } else {
- item = inotifymap[event->wd];
- item = item + "/" + event->name;
- MTPD("inotify_t item: '%s'\n", item.c_str());
- if (event->mask & IN_CREATE || event->mask & IN_MOVED_TO) {
- lockMutex(1);
- if (event->mask & IN_ISDIR) {
- MTPD("inotify_t create is dir\n");
- } else {
- MTPD("inotify_t create is file\n");
- }
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- node = i->second->findNodePath(item, i->second->Root());
- if (node != NULL)
- break;
- }
- if (node == NULL) {
- parent = item.substr(0, item.find_last_of('/'));
- MTPD("parent: %s\n", parent.c_str());
- if (parent == getPath()) {
- local_mtpparentid = 1;
- } else {
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- node = i->second->findNodePath(parent, i->second->Root());
- MTPD("searching for node: %d\n", (int)node);
- if (node != NULL) {
- local_mtpparentid = i->second->getMtpParentId(node);
- break;
- }
- }
- if (node == NULL) {
- MTPE("inotify_t unable to locate mtparentid\n");
- goto end;
- }
- }
- ++mtpid;
- MTPD("mtpid: %d\n", mtpid);
- MTPD("mtpparentid1: %d\n", local_mtpparentid);
- node = mtpmap[local_mtpparentid]->addNode(mtpid, item);
- mtpmap[local_mtpparentid]->setMtpParentId(local_mtpparentid, node);
- node->addProperties(getStorageID(), getParentObject(parent));
- if (event->mask & IN_ISDIR) {
- createEmptyDir(item.c_str());
- }
- mServer->sendObjectAdded(mtpid);
- } else {
- MTPD("inotify_t item already exists.\n");
- }
- if (event->mask & IN_ISDIR) {
- inotify_wd = inotify_add_watch(inotify_fd, item.c_str(), WATCH_FLAGS);
- inotifymap[inotify_wd] = item;
- MTPD("added inotify dir: '%s'\n", item.c_str());
- MTPD("inotify_t scanning new dir\n");
- readParentDirs(item);
- std::string mtpParent;
- while (!mtpParentList.empty()) {
- mtpParent = mtpParentList.front();
- mtpParentList.pop_front();
- readParentDirs(mtpParent);
- inotify_wd = inotify_add_watch(inotify_fd, mtpParent.c_str(), WATCH_FLAGS);
- inotifymap[inotify_wd] = mtpParent;
- MTPD("added inotify dir: '%s'\n", mtpParent.c_str());
- }
- }
- } else if (event->mask & IN_DELETE || event->mask & IN_MOVED_FROM) {
- lockMutex(1);
- if (event->mask & IN_ISDIR) {
- MTPD("inotify_t Directory %s deleted\n", event->name);
- } else {
- MTPD("inotify_t File %s deleted\n", event->name);
- }
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- node = i->second->findNodePath(item, i->second->Root());
- if (node != NULL)
- break;
- }
- if (node != NULL && node->Mtpid() > 0) {
- int local_id = node->Mtpid();
- node = NULL;
- deleteFile(local_id);
- mServer->sendObjectRemoved(local_id);
- } else {
- MTPD("inotify_t already removed.\n");
- }
- if (event->mask & IN_ISDIR) {
- std::string orig_item = item + "/";
- size_t item_size = orig_item.size();
- std::string path_check;
- for (std::map<int, std::string>::iterator i = inotifymap.begin(); i != inotifymap.end(); i++) {
- if ((i->second.size() > item_size && i->second.substr(0, item_size) == orig_item) || i->second == item) {
- inotify_rm_watch(inotify_fd, i->first);
- MTPD("inotify_t removing watch on '%s'\n", i->second.c_str());
- inotifymap.erase(i->first);
- }
- }
- }
- } else if (event->mask & IN_MODIFY) {
- MTPD("inotify_t item %s modified.\n", event->name);
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- node = i->second->findNodePath(item, i->second->Root());
- if (node != NULL)
- break;
- }
- if (node != NULL) {
- uint64_t orig_size = node->getIntProperty(MTP_PROPERTY_OBJECT_SIZE);
- struct stat st;
- uint64_t new_size = 0;
- if (lstat(item.c_str(), &st) == 0)
- new_size = (uint64_t)st.st_size;
- if (orig_size != new_size) {
- MTPD("size changed from %llu to %llu on mtpid: %i\n", orig_size, new_size, node->Mtpid());
- node->updateProperty(MTP_PROPERTY_OBJECT_SIZE, new_size, "", MTP_TYPE_UINT64);
- mServer->sendObjectUpdated(node->Mtpid());
- }
- } else {
- MTPE("inotify_t modified item not found\n");
- }
- }
- }
+ struct inotify_event *event = (struct inotify_event *) &buf[i];
+ if (event->len) {
+ MTPD("inotify event: wd: %i, mask: %x, name: %s\n", event->wd, event->mask, event->name);
+ lockMutex(1);
+ handleInotifyEvent(event);
+ unlockMutex(1);
}
-end:
- unlockMutex(1);
i += EVENT_SIZE + event->len;
}
}
- for (std::map<int, std::string>::iterator i = inotifymap.begin(); i != inotifymap.end(); i++) {
+ for (std::map<int, Tree*>::iterator i = inotifymap.begin(); i != inotifymap.end(); i++) {
inotify_rm_watch(inotify_fd, i->first);
}
close(inotify_fd);
return 0;
}
-int MtpStorage::getParentObject(std::string parent_path) {
- Node* node;
- if (parent_path == getPath()) {
- MTPD("MtpStorage::getParentObject for: '%s' returning: 0 for root\n", parent_path.c_str());
- return 0;
+Node* MtpStorage::findNodeByPath(const std::string& path) {
+ MTPD("findNodeByPath: %s\n", path.c_str());
+ std::string match = path.substr(0, mtpstorageparent.size());
+ if (match != mtpstorageparent) {
+ // not on this device
+ MTPD("no match: %s is not on storage %s\n", match.c_str(), mtpstorageparent.c_str());
+ return NULL;
}
- for (iter i = mtpmap.begin(); i != mtpmap.end(); ++i) {
- node = i->second->findNodePath(parent_path, i->second->Root());
+
+ // TODO: fix and test this
+ std::string p = path.substr(mtpstorageparent.size()+1); // cut off "/" after storage root too
+ Tree* tree = mtpmap[0]; // start at storage root
+
+ Node* node = NULL;
+ while (!p.empty()) {
+ size_t slashpos = p.find('/');
+ std::string e;
+ if (slashpos != std::string::npos) {
+ e = p;
+ p.clear();
+ } else {
+ e = p.substr(0, slashpos);
+ p = p.substr(slashpos + 1);
+ }
+ MTPD("path element: %s, rest: %s\n", e.c_str(), p.c_str());
+ node = tree->findEntryByName(e);
+ if (!node) {
+ MTPE("path element of %s not found: %s\n", path.c_str(), e.c_str());
+ return NULL;
+ }
+ if (node->isDir())
+ tree = static_cast<Tree*>(node);
+ else if (!p.empty()) {
+ MTPE("path element of %s is not a directory: %s node: %p\n", path.c_str(), e.c_str(), node);
+ return NULL;
+ }
+ }
+ MTPD("findNodeByPath: found node %p, handle: %u, name: %s\n", node, node->Mtpid(), node->getName().c_str());
+ return node;
+}
+
+Node* MtpStorage::addNewNode(bool isDir, Tree* tree, const std::string& name)
+{
+ // global counter for new object handles
+ static MtpObjectHandle mtpid = 0;
+
+ ++mtpid;
+ MTPD("adding new %s node for %s, new handle: %u\n", isDir ? "dir" : "file", name.c_str(), mtpid);
+ MtpObjectHandle parent = tree->Mtpid();
+ MTPD("parent tree: %x, handle: %u, name: %s\n", tree, parent, tree->getName().c_str());
+ Node* node;
+ if (isDir)
+ node = mtpmap[mtpid] = new Tree(mtpid, parent, name);
+ else
+ node = new Node(mtpid, parent, name);
+ tree->addEntry(node);
+ return node;
+}
+
+Node* MtpStorage::findNode(MtpObjectHandle handle) {
+ for (iter i = mtpmap.begin(); i != mtpmap.end(); i++) {
+ Node* node = i->second->findNode(handle);
if (node != NULL) {
- MTPD("MtpStorage::getParentObject for: '%s' returning: %i\n", parent_path.c_str(), node->Mtpid());
- return node->Mtpid();
+ MTPD("findNode: found node %p for handle %u, name: %s\n", node, handle, node->getName().c_str());
+ if (node->Mtpid() != handle)
+ {
+ MTPE("BUG: entry for handle %u points to node with handle %u\n", handle, node->Mtpid());
+ }
+ return node;
}
}
- MTPE("MtpStorage::getParentObject for: '%s' unable to locate node\n", parent_path.c_str());
- return -1;
+ // Item is not on this storage device
+ MTPE("MtpStorage::findNode: no node found for handle %u, searched %u trees\n", handle, mtpmap.size());
+ return NULL;
+}
+
+std::string MtpStorage::getNodePath(Node* node) {
+ std::string path;
+ MTPD("getNodePath: node %p, handle %u\n", node, node->Mtpid());
+ while (node)
+ {
+ path = "/" + node->getName() + path;
+ MtpObjectHandle parent = node->getMtpParentId();
+ if (parent == 0) // root
+ break;
+ node = findNode(parent);
+ }
+ path = mtpstorageparent + path;
+ MTPD("getNodePath: path %s\n", path.c_str());
+ return path;
}
void MtpStorage::lockMutex(int thread_type) {
diff --git a/mtp/MtpStorage.h b/mtp/MtpStorage.h
index ad828d163..418e3db8c 100755
--- a/mtp/MtpStorage.h
+++ b/mtp/MtpStorage.h
@@ -30,6 +30,7 @@
#include "MtpServer.h"
class MtpDatabase;
+struct inotify_event;
class MtpStorage {
@@ -43,16 +44,10 @@ private:
uint64_t mReserveSpace;
bool mRemovable;
MtpServer* mServer;
- std::deque<std::string> mtpParentList;
- int mtpparentid;
- Tree *mtpdbtree;
typedef std::map<int, Tree*> maptree;
typedef maptree::iterator iter;
maptree mtpmap;
std::string mtpstorageparent;
- pthread_t inotify_thread;
- int inotify_fd;
- int inotify_wd;
android::Mutex mMutex;
public:
@@ -71,30 +66,50 @@ public:
inline const char* getPath() const { return (const char *)mFilePath; }
inline bool isRemovable() const { return mRemovable; }
inline uint64_t getMaxFileSize() const { return mMaxFileSize; }
- int readParentDirs(std::string path);
+
+ struct PropEntry {
+ MtpObjectHandle handle;
+ uint16_t property;
+ uint16_t datatype;
+ uint64_t intvalue;
+ std::string strvalue;
+ };
+
+ int readDir(const std::string& path, Tree* tree);
int createDB();
MtpObjectHandleList* getObjectList(MtpStorageID storageID, MtpObjectHandle parent);
int getObjectInfo(MtpObjectHandle handle, MtpObjectInfo& info);
- MtpObjectHandle beginSendObject(const char* path, MtpObjectFormat format, MtpObjectHandle parent, MtpStorageID storage, uint64_t size, time_t modified);
+ MtpObjectHandle beginSendObject(const char* path, MtpObjectFormat format, MtpObjectHandle parent, uint64_t size, time_t modified);
+ void endSendObject(const char* path, MtpObjectHandle handle, MtpObjectFormat format, bool succeeded);
int getObjectPropertyList(MtpObjectHandle handle, uint32_t format, uint32_t property, int groupCode, int depth, MtpDataPacket& packet);
int getObjectFilePath(MtpObjectHandle handle, MtpString& outFilePath, int64_t& outFileLength, MtpObjectFormat& outFormat);
int deleteFile(MtpObjectHandle handle);
int renameObject(MtpObjectHandle handle, std::string newName);
- int getObjectPropertyValue(MtpObjectHandle handle, MtpObjectProperty property, uint64_t &longValue);
+ int getObjectPropertyValue(MtpObjectHandle handle, MtpObjectProperty property, PropEntry& prop);
void lockMutex(int thread_type);
void unlockMutex(int thread_type);
private:
- void createEmptyDir(const char* path);
pthread_t inotify();
int inotify_t();
typedef int (MtpStorage::*ThreadPtr)(void);
typedef void* (*PThreadPtr)(void *);
- std::map<int, std::string> inotifymap;
- int addInotifyDirs(std::string path);
- void deleteTrees(int parent);
+ std::map<int, Tree*> inotifymap; // inotify wd -> tree
+ pthread_t inotify_thread;
+ int inotify_fd;
+ int addInotify(Tree* tree);
+ void handleInotifyEvent(struct inotify_event* event);
+
bool sendEvents;
- int getParentObject(std::string parent_path);
+ MtpObjectHandle handleCurrentlySending;
+
+ Node* addNewNode(bool isDir, Tree* tree, const std::string& name);
+ Node* findNode(MtpObjectHandle handle);
+ Node* findNodeByPath(const std::string& path);
+ std::string getNodePath(Node* node);
+
+ void queryNodeProperties(std::vector<PropEntry>& results, Node* node, uint32_t property, int groupCode, MtpStorageID storageID);
+
bool use_mutex;
pthread_mutex_t inMutex; // inotify mutex
pthread_mutex_t mtpMutex; // main mtp mutex
diff --git a/mtp/btree.cpp b/mtp/btree.cpp
index 7976ac325..3a5648db0 100755
--- a/mtp/btree.cpp
+++ b/mtp/btree.cpp
@@ -20,289 +20,60 @@
#include "MtpDebug.h"
// Constructor
-Tree::Tree() {
- root = NULL;
- count = 0;
+Tree::Tree(MtpObjectHandle handle, MtpObjectHandle parent, const std::string& name)
+ : Node(handle, parent, name), alreadyRead(false) {
}
// Destructor
Tree::~Tree() {
- freeNode(root);
-}
-
-// Free the node
-void Tree::freeNode(Node* leaf)
-{
- if ( leaf != NULL )
- {
- freeNode(leaf->Left());
- freeNode(leaf->Right());
- delete leaf;
- }
+ for (std::map<MtpObjectHandle, Node*>::iterator it = entries.begin(); it != entries.end(); ++it)
+ delete it->second;
}
int Tree::getCount(void) {
+ int count = entries.size();
MTPD("node count: %d\n", count);
return count;
}
-Node* Tree::addNode(int mtpid, std::string path)
-{
- MTPD("root: %d\n", root);
- // No elements. Add the root
- if ( root == NULL ) {
- Node* n = new Node();
- count++;
- MTPD("node count: %d\n", count);
- MTPD("adding node address: %d\n", n);
- MTPD("adding mtpid: %d\n", mtpid);
- n->setMtpid(mtpid);
- n->setPath(path);
- root = n;
- MTPD("set root to %d\n", root);
- return n;
- }
- else {
- count++;
- MTPD("node count: %d\n", count);
- MTPD("adding new child node\n");
- return addNode(mtpid, root, path);
- }
-}
-
-// Add a node (private)
-Node* Tree::addNode(int mtpid, Node* leaf, std::string path) {
- Node* n;
- if ( mtpid <= leaf->Mtpid() )
- {
- if ( leaf->Left() != NULL )
- return addNode(mtpid, leaf->Left(), path);
- else {
- n = new Node();
- MTPD("adding mtpid: %d node: %d\n", mtpid, n);
- n->setMtpid(mtpid);
- n->setPath(path);
- n->setParent(leaf);
- leaf->setLeft(n);
- }
- }
- else
- {
- if ( leaf->Right() != NULL )
- return addNode(mtpid, leaf->Right(), path);
- else {
- n = new Node();
- MTPD("adding mtpid: %d node: %d\n", mtpid, n);
- n->setMtpid(mtpid);
- n->setPath(path);
- n->setParent(leaf);
- leaf->setRight(n);
- }
- }
- return n;
-}
-
-void Tree::setMtpParentId(int mtpparentid, Node* node) {
- node->setMtpParentId(mtpparentid);
-}
-
-std::string Tree::getPath(Node* node) {
- return node->getPath();
-}
-
-int Tree::getMtpParentId(Node* node) {
- return node->getMtpParentId();
-}
-
-Node* Tree::findNodePath(std::string path, Node* node) {
- Node* n;
- if ( node == NULL ) {
- return NULL;
- }
- if ( node->getPath().compare(path) == 0 && node->Mtpid() > 0) {
- return node;
- }
- else {
- n = findNodePath(path, node->Left());
- if (n)
- return n;
- n = findNodePath(path, node->Right());
- if (n)
- return n;
- }
- return NULL;
-}
-
-Node* Tree::getNext(Node *node) {
- if (node == NULL)
- return NULL;
- else {
- if (node->Left() != NULL)
- return node->Left();
- if (node->Right() != NULL)
- return node->Right();
- }
- return NULL;
-}
-
-Node* Tree::findNode(int key, Node* node) {
- //MTPD("key: %d\n", key);
- //MTPD("node: %d\n", node);
- if ( node == NULL ) {
- return NULL;
- }
- else if ( node->Mtpid() == key ) {
- return node;
- }
- else if ( key <= node->Mtpid() ) {
- return findNode(key, node->Left());
- }
- else if ( key > node->Mtpid() ) {
- return findNode(key, node->Right());
+void Tree::addEntry(Node* node) {
+ if (node->Mtpid() == 0) {
+ MTPE("Tree::addEntry: not adding node with 0 handle.\n");
+ return;
}
- else {
- return NULL;
+ if (node->Mtpid() == node->getMtpParentId()) {
+ MTPE("Tree::addEntry: not adding node with handle %u == parent.\n", node->Mtpid());
+ return;
}
- return NULL;
+ entries[node->Mtpid()] = node;
}
-void Tree::getmtpids(Node* node, std::vector<int>* mtpids)
-{
- if ( node )
+Node* Tree::findEntryByName(std::string name) {
+ for (std::map<MtpObjectHandle, Node*>::iterator it = entries.begin(); it != entries.end(); ++it)
{
- MTPD("node: %d\n", node->Mtpid());
- mtpids->push_back(node->Mtpid());
- if (node->Left())
- getmtpids(node->Left(), mtpids);
- if (node->Right())
- getmtpids(node->Right(), mtpids);
- } else {
- mtpids->push_back(0);
+ Node* node = it->second;
+ if (node->getName().compare(name) == 0 && node->Mtpid() > 0)
+ return node;
}
- return;
-}
-
-// Find the node with min key
-// Traverse the left sub-tree recursively
-// till left sub-tree is empty to get min
-Node* Tree::min(Node* node)
-{
- if ( node == NULL )
- return NULL;
-
- if ( node->Left() )
- min(node->Left());
- else
- return node;
- return NULL;
-}
-
-// Find the node with max key
-// Traverse the right sub-tree recursively
-// till right sub-tree is empty to get max
-Node* Tree::max(Node* node)
-{
- if ( node == NULL )
- return NULL;
-
- if ( node->Right() )
- max(node->Right());
- else
- return node;
return NULL;
}
-// Find successor to a node
-// Find the node, get the node with max value
-// for the right sub-tree to get the successor
-Node* Tree::successor(int key, Node *node)
-{
- Node* thisKey = findNode(key, node);
- if ( thisKey )
- return max(thisKey->Right());
+Node* Tree::findNode(MtpObjectHandle handle) {
+ std::map<MtpObjectHandle, Node*>::iterator it = entries.find(handle);
+ if (it != entries.end())
+ return it->second;
return NULL;
}
-// Find predecessor to a node
-// Find the node, get the node with max value
-// for the left sub-tree to get the predecessor
-Node* Tree::predecessor(int key, Node *node)
-{
- Node* thisKey = findNode(key, node);
- if ( thisKey )
- return max(thisKey->Left());
- return NULL;
+void Tree::getmtpids(MtpObjectHandleList* mtpids) {
+ for (std::map<MtpObjectHandle, Node*>::iterator it = entries.begin(); it != entries.end(); ++it)
+ mtpids->push_back(it->second->Mtpid());
}
-void Tree::deleteNode(int key)
-{
- // Find the node.
- Node* thisKey = findNode(key, root);
- MTPD("Tree::deleteNode found node: %d\n", thisKey);
- MTPD("handle: %d\n", thisKey->Mtpid());
-
- if (thisKey == root) {
- if (thisKey->Right()) {
- root = thisKey->Right();
- root->setParent(NULL);
- return;
- }
- if (thisKey->Left()) {
- root = thisKey->Left();
- root->setParent(NULL);
- return;
- }
- root = NULL;
- delete thisKey;
- return;
- }
-
- if ( thisKey->Left() == NULL && thisKey->Right() == NULL )
- {
- if ( thisKey->Mtpid() > thisKey->Parent()->Mtpid() ) {
- thisKey->Parent()->setRight(NULL);
- }
- else {
- thisKey->Parent()->setLeft(NULL);
- }
- delete thisKey;
- return;
- }
-
- if ( thisKey->Left() == NULL && thisKey->Right() != NULL )
- {
- if ( thisKey->Mtpid() > thisKey->Parent()->Mtpid() )
- thisKey->Parent()->setRight(thisKey->Right());
- else
- thisKey->Parent()->setLeft(thisKey->Right());
- thisKey->Right()->setParent(thisKey->Parent());
- delete thisKey;
- return;
- }
- if ( thisKey->Left() != NULL && thisKey->Right() == NULL )
- {
- if ( thisKey->Mtpid() > thisKey->Parent()->Mtpid() )
- thisKey->Parent()->setRight(thisKey->Left());
- else
- thisKey->Parent()->setLeft(thisKey->Left());
- thisKey->Left()->setParent(thisKey->Parent());
- delete thisKey;
- return;
- }
-
- if ( thisKey->Left() != NULL && thisKey->Right() != NULL )
- {
- Node* sub = predecessor(thisKey->Mtpid(), thisKey);
- if ( sub == NULL )
- sub = successor(thisKey->Mtpid(), thisKey);
-
- if ( sub->Parent()->Mtpid() <= sub->Mtpid() )
- sub->Parent()->setRight(sub->Right());
- else
- sub->Parent()->setLeft(sub->Left());
-
- thisKey->setMtpid(sub->Mtpid());
- delete sub;
- return;
+void Tree::deleteNode(MtpObjectHandle handle) {
+ std::map<MtpObjectHandle, Node*>::iterator it = entries.find(handle);
+ if (it != entries.end()) {
+ delete it->second;
+ entries.erase(it);
}
}
diff --git a/mtp/btree.hpp b/mtp/btree.hpp
index 1fa8d2800..b284e4f4b 100755
--- a/mtp/btree.hpp
+++ b/mtp/btree.hpp
@@ -17,79 +17,65 @@
#ifndef BTREE_HPP
#define BTREE_HPP
-#include <iostream>
#include <vector>
-#include <utils/threads.h>
-#include "MtpDebug.h"
+#include <map>
+#include "MtpTypes.h"
-// A generic tree node class
+// A directory entry
class Node {
- int mtpid;
- int mtpparentid;
- std::string path;
- int parentID;
- Node* left;
- Node* right;
- Node* parent;
+ MtpObjectHandle handle;
+ MtpObjectHandle parent;
+ std::string name; // name only without path
public:
Node();
- void setMtpid(int aMtpid);
- void setPath(std::string aPath);
- void rename(std::string aPath);
- void setLeft(Node* aLeft);
- void setRight(Node* aRight);
- void setParent(Node* aParent);
- void setMtpParentId(int id);
- int Mtpid();
- int getMtpParentId();
- std::string getPath();
- Node* Left();
- Node* Right();
- Node* Parent();
- void addProperty(uint64_t property, uint64_t valueInt, std::string valueStr, int dataType);
- void updateProperty(uint64_t property, uint64_t valueInt, std::string valueStr, int dataType);
- void addProperties(int storageID, int parent_object);
- uint64_t getIntProperty(uint64_t property);
+ Node(MtpObjectHandle handle, MtpObjectHandle parent, const std::string& name);
+ virtual ~Node() {}
+
+ virtual bool isDir() const { return false; }
+
+ void rename(const std::string& newName);
+ MtpObjectHandle Mtpid() const;
+ MtpObjectHandle getMtpParentId() const;
+ const std::string& getName() const;
+
+ void addProperty(MtpPropertyCode property, uint64_t valueInt, std::string valueStr, MtpDataType dataType);
+ void updateProperty(MtpPropertyCode property, uint64_t valueInt, std::string valueStr, MtpDataType dataType);
+ void addProperties(const std::string& path, int storageID);
+ uint64_t getIntProperty(MtpPropertyCode property);
struct mtpProperty {
- uint64_t property;
+ MtpPropertyCode property;
+ MtpDataType dataType;
uint64_t valueInt;
std::string valueStr;
- int dataType;
+ mtpProperty() : property(0), dataType(0), valueInt(0) {}
};
std::vector<mtpProperty>& getMtpProps();
std::vector<mtpProperty> mtpProp;
+ const mtpProperty& getProperty(MtpPropertyCode property);
};
-// Binary Search Tree class
-class Tree {
- Node* root;
+// A directory
+class Tree : public Node {
+ std::map<MtpObjectHandle, Node*> entries;
+ bool alreadyRead;
public:
- Tree();
+ Tree(MtpObjectHandle handle, MtpObjectHandle parent, const std::string& name);
~Tree();
- Node* Root() {
- MTPD("root: %d\n", root);
- return root;
- };
- Node* addNode(int mtpid, std::string path);
- void setMtpParentId(int mtpparentid, Node* node);
- Node* findNode(int key, Node* parent);
- void getmtpids(Node* node, std::vector<int>* mtpids);
- void deleteNode(int key);
- Node* min(Node* node);
- Node* max(Node* node);
- Node* successor(int key, Node* parent);
- Node* predecessor(int key, Node* parent);
+
+ virtual bool isDir() const { return true; }
+
+ void addEntry(Node* node);
+ Node* findNode(MtpObjectHandle handle);
+ void getmtpids(MtpObjectHandleList* mtpids);
+ void deleteNode(MtpObjectHandle handle);
std::string getPath(Node* node);
+ int getMtpParentId() { return Node::getMtpParentId(); }
int getMtpParentId(Node* node);
- Node* findNodePath(std::string path, Node* node);
- Node* getNext(Node* node);
+ Node* findEntryByName(std::string name);
int getCount();
-
-private:
- Node* addNode(int mtpid, Node* leaf, std::string path);
- void freeNode(Node* leaf);
- int count;
+ bool wasAlreadyRead() const { return alreadyRead; }
+ void setAlreadyRead(bool b) { alreadyRead = b; }
};
#endif
diff --git a/mtp/mtp_MtpDatabase.cpp b/mtp/mtp_MtpDatabase.cpp
index b5096fe76..05bb5d9fb 100755
--- a/mtp/mtp_MtpDatabase.cpp
+++ b/mtp/mtp_MtpDatabase.cpp
@@ -42,7 +42,7 @@
#include "MtpUtils.h"
#include "mtp.h"
#include "mtp_MtpDatabase.hpp"
-#include "btree.hpp"
+//#include "btree.hpp"
MyMtpDatabase::MyMtpDatabase()
{
@@ -75,6 +75,7 @@ int MyMtpDatabase::FILE_PROPERTIES[10] = {
MTP_PROPERTY_PARENT_OBJECT,
MTP_PROPERTY_PERSISTENT_UID,
MTP_PROPERTY_NAME,
+ // TODO: why is DISPLAY_NAME not here?
MTP_PROPERTY_DATE_ADDED
};
@@ -214,8 +215,9 @@ MtpObjectHandle MyMtpDatabase::beginSendObject(const char* path,
MtpStorageID storage,
uint64_t size,
time_t modified) {
- MTPD("MyMtpDatabase::beginSendObject() which passes to MtpStorage.cpp\n");
- return storagemap[storage]->beginSendObject(path, format, parent, storage, size, modified);
+ if (storagemap.find(storage) == storagemap.end())
+ return kInvalidObjectHandle;
+ return storagemap[storage]->beginSendObject(path, format, parent, size, modified);
}
void MyMtpDatabase::endSendObject(const char* path, MtpObjectHandle handle,
@@ -225,6 +227,9 @@ void MyMtpDatabase::endSendObject(const char* path, MtpObjectHandle handle,
MTPE("endSendObject() failed, unlinking %s\n", path);
unlink(path);
}
+ std::map<int, MtpStorage*>::iterator storit;
+ for (storit = storagemap.begin(); storit != storagemap.end(); storit++)
+ storit->second->endSendObject(path, handle, format, succeeded);
}
void MyMtpDatabase::createDB(MtpStorage* storage, MtpStorageID storageID) {
@@ -236,8 +241,7 @@ MtpObjectHandleList* MyMtpDatabase::getObjectList(MtpStorageID storageID,
MtpObjectFormat format,
MtpObjectHandle parent) {
MTPD("storageID: %d\n", storageID);
- MtpObjectHandleList* list = new MtpObjectHandleList();
- list = storagemap[storageID]->getObjectList(storageID, parent);
+ MtpObjectHandleList* list = storagemap[storageID]->getObjectList(storageID, parent);
MTPD("list: %d\n", list->size());
return list;
}
@@ -245,22 +249,20 @@ MtpObjectHandleList* MyMtpDatabase::getObjectList(MtpStorageID storageID,
int MyMtpDatabase::getNumObjects(MtpStorageID storageID,
MtpObjectFormat format,
MtpObjectHandle parent) {
- MTPE("MyMtpDatabase::getNumObjects not implemented, returning 0\n");
- int result = 0;
- //get number of objects on filesystem storage
- return result;
+ MtpObjectHandleList* list = storagemap[storageID]->getObjectList(storageID, parent);
+ int size = list->size();
+ delete list;
+ return size;
}
MtpObjectFormatList* MyMtpDatabase::getSupportedPlaybackFormats() {
// This function tells the host PC which file formats the device supports
- int* formats;
MtpObjectFormatList* list = new MtpObjectFormatList();
- formats = SUPPORTED_PLAYBACK_FORMATS;
- int length = sizeof(formats)/ sizeof(int);
+ int length = sizeof(SUPPORTED_PLAYBACK_FORMATS) / sizeof(SUPPORTED_PLAYBACK_FORMATS[0]);
MTPD("MyMtpDatabase::getSupportedPlaybackFormats length: %i\n", length);
for (int i = 0; i < length; i++) {
- MTPD("supported playback format: %d\n", formats[i]);
- list->push(formats[i]);
+ MTPD("supported playback format: %x\n", SUPPORTED_PLAYBACK_FORMATS[i]);
+ list->push(SUPPORTED_PLAYBACK_FORMATS[i]);
}
return list;
}
@@ -284,25 +286,29 @@ MtpObjectPropertyList* MyMtpDatabase::getSupportedObjectProperties(MtpObjectForm
case MTP_FORMAT_AAC:
properties = AUDIO_PROPERTIES;
length = sizeof(AUDIO_PROPERTIES) / sizeof(AUDIO_PROPERTIES[0]);
+ break;
case MTP_FORMAT_MPEG:
case MTP_FORMAT_3GP_CONTAINER:
case MTP_FORMAT_WMV:
properties = VIDEO_PROPERTIES;
length = sizeof(VIDEO_PROPERTIES) / sizeof(VIDEO_PROPERTIES[0]);
+ break;
case MTP_FORMAT_EXIF_JPEG:
case MTP_FORMAT_GIF:
case MTP_FORMAT_PNG:
case MTP_FORMAT_BMP:
properties = IMAGE_PROPERTIES;
length = sizeof(IMAGE_PROPERTIES) / sizeof(IMAGE_PROPERTIES[0]);
+ break;
case 0:
properties = ALL_PROPERTIES;
length = sizeof(ALL_PROPERTIES) / sizeof(ALL_PROPERTIES[0]);
+ break;
default:
properties = FILE_PROPERTIES;
length = sizeof(FILE_PROPERTIES) / sizeof(FILE_PROPERTIES[0]);
}
- MTPD("MyMtpDatabase::getSupportedObjectProperties length is: %i, format: %x, sizeof: %i", length, format);
+ MTPD("MyMtpDatabase::getSupportedObjectProperties length is: %i, format: %x", length, format);
for (int i = 0; i < length; i++) {
MTPD("supported object property: %x\n", properties[i]);
list->push(properties[i]);
@@ -313,35 +319,37 @@ MtpObjectPropertyList* MyMtpDatabase::getSupportedObjectProperties(MtpObjectForm
MtpDevicePropertyList* MyMtpDatabase::getSupportedDeviceProperties() {
MtpDevicePropertyList* list = new MtpDevicePropertyList();
int length = sizeof(DEVICE_PROPERTIES) / sizeof(DEVICE_PROPERTIES[0]);
- MTPD("MyMtpDatabase::getSupportedDeviceProperties length was: %i\n");
+ MTPD("MyMtpDatabase::getSupportedDeviceProperties length was: %i\n", length);
for (int i = 0; i < length; i++)
list->push(DEVICE_PROPERTIES[i]);
return list;
}
+
MtpResponseCode MyMtpDatabase::getObjectPropertyValue(MtpObjectHandle handle,
MtpObjectProperty property,
MtpDataPacket& packet) {
- MTPD("MyMtpDatabase::getObjectPropertyValue mtpid: %i, property: %x\n", handle, property);
+ MTPD("MyMtpDatabase::getObjectPropertyValue mtpid: %u, property: %x\n", handle, property);
int type;
MtpResponseCode result = MTP_RESPONSE_INVALID_OBJECT_HANDLE;
- uint64_t longValue;
+ MtpStorage::PropEntry prop;
if (!getObjectPropertyInfo(property, type)) {
- MTPE("MyMtpDatabase::setObjectPropertyValue returning MTP_RESPONSE_OBJECT_PROP_NOT_SUPPORTED\n");
+ MTPE("MyMtpDatabase::getObjectPropertyValue returning MTP_RESPONSE_OBJECT_PROP_NOT_SUPPORTED\n");
return MTP_RESPONSE_OBJECT_PROP_NOT_SUPPORTED;
}
std::map<int, MtpStorage*>::iterator storit;
for (storit = storagemap.begin(); storit != storagemap.end(); storit++) {
- if (storit->second->getObjectPropertyValue(handle, property, longValue) == 0) {
+ if (storit->second->getObjectPropertyValue(handle, property, prop) == 0) {
result = MTP_RESPONSE_OK;
break;
}
}
if (result != MTP_RESPONSE_OK) {
- MTPE("MyMtpDatabase::setObjectPropertyValue unable to locate handle: %i\n", handle);
+ MTPE("MyMtpDatabase::getObjectPropertyValue unable to locate handle: %u\n", handle);
return MTP_RESPONSE_INVALID_OBJECT_HANDLE;
}
+ uint64_t longValue = prop.intvalue;
// special case date properties, which are strings to MTP
// but stored internally as a uint64
if (property == MTP_PROPERTY_DATE_MODIFIED || property == MTP_PROPERTY_DATE_ADDED) {
@@ -387,7 +395,7 @@ MtpResponseCode MyMtpDatabase::getObjectPropertyValue(MtpObjectHandle handle,
packet.putInt128(longValue);
break;
case MTP_TYPE_UINT128:
- packet.putInt128(longValue);
+ packet.putUInt128(longValue);
break;
case MTP_TYPE_STR:
{
@@ -401,8 +409,10 @@ MtpResponseCode MyMtpDatabase::getObjectPropertyValue(MtpObjectHandle handle,
} else {
packet.putEmptyString();
}*/
- MTPE("STRING unsupported type in getObjectPropertyValue\n");
- result = MTP_RESPONSE_INVALID_OBJECT_PROP_FORMAT;
+ packet.putString(prop.strvalue.c_str());
+ MTPD("MTP_TYPE_STR: %x = %s\n", prop.property, prop.strvalue.c_str());
+ //MTPE("STRING unsupported type in getObjectPropertyValue\n");
+ //result = MTP_RESPONSE_INVALID_OBJECT_PROP_FORMAT;
break;
}
default:
@@ -764,26 +774,21 @@ MtpProperty* MyMtpDatabase::getObjectPropertyDesc(MtpObjectProperty property,
switch (property) {
case MTP_PROPERTY_OBJECT_FORMAT:
// use format as default value
- MTPD("MyMtpDatabase::getObjectPropertyDesc format\n");
result = new MtpProperty(property, MTP_TYPE_UINT16, false, format);
break;
case MTP_PROPERTY_PROTECTION_STATUS:
case MTP_PROPERTY_TRACK:
- MTPD("MyMtpDatabase::getObjectPropertyDesc track\n");
result = new MtpProperty(property, MTP_TYPE_UINT16);
break;
case MTP_PROPERTY_STORAGE_ID:
case MTP_PROPERTY_PARENT_OBJECT:
case MTP_PROPERTY_DURATION:
- MTPD("MyMtpDatabase::getObjectPropertyDesc duration\n");
result = new MtpProperty(property, MTP_TYPE_UINT32);
break;
case MTP_PROPERTY_OBJECT_SIZE:
- MTPD("MyMtpDatabase::getObjectPropertyDesc size\n");
result = new MtpProperty(property, MTP_TYPE_UINT64);
break;
case MTP_PROPERTY_PERSISTENT_UID:
- MTPD("MyMtpDatabase::getObjectPropertyDesc persistent uid\n");
result = new MtpProperty(property, MTP_TYPE_UINT128);
break;
case MTP_PROPERTY_NAME:
@@ -794,18 +799,15 @@ MtpProperty* MyMtpDatabase::getObjectPropertyDesc(MtpObjectProperty property,
case MTP_PROPERTY_GENRE:
case MTP_PROPERTY_COMPOSER:
case MTP_PROPERTY_DESCRIPTION:
- MTPD("MyMtpDatabase::getObjectPropertyDesc description\n");
result = new MtpProperty(property, MTP_TYPE_STR);
break;
case MTP_PROPERTY_DATE_MODIFIED:
case MTP_PROPERTY_DATE_ADDED:
case MTP_PROPERTY_ORIGINAL_RELEASE_DATE:
- MTPD("MyMtpDatabase::getObjectPropertyDesc date\n");
result = new MtpProperty(property, MTP_TYPE_STR);
result->setFormDateTime();
break;
case MTP_PROPERTY_OBJECT_FILE_NAME:
- MTPD("MyMtpDatabase::getObjectPropertyDesc file name\n");
// We allow renaming files and folders
result = new MtpProperty(property, MTP_TYPE_STR, true);
break;
@@ -816,26 +818,19 @@ MtpProperty* MyMtpDatabase::getObjectPropertyDesc(MtpObjectProperty property,
MtpProperty* MyMtpDatabase::getDevicePropertyDesc(MtpDeviceProperty property) {
MtpProperty* result = NULL;
int ret;
- bool writable = true;
+ bool writable = false;
switch (property) {
case MTP_DEVICE_PROPERTY_SYNCHRONIZATION_PARTNER:
case MTP_DEVICE_PROPERTY_DEVICE_FRIENDLY_NAME:
- ret = MTP_RESPONSE_OK;
+ writable = true;
// fall through
case MTP_DEVICE_PROPERTY_IMAGE_SIZE:
result = new MtpProperty(property, MTP_TYPE_STR, writable);
- ret = MTP_RESPONSE_OK;
// get current value
- if (ret == MTP_RESPONSE_OK) {
- result->setCurrentValue('\0');
- result->setDefaultValue('\0');
- } else {
- MTPE("unable to read device property, response: %04X", ret);
- }
- break;
- default:
- ret = MTP_RESPONSE_DEVICE_PROP_NOT_SUPPORTED;
+ // TODO: add actual values
+ result->setCurrentValue('\0');
+ result->setDefaultValue('\0');
break;
}
@@ -854,26 +849,6 @@ void MyMtpDatabase::sessionEnded() {
// ----------------------------------------------------------------------------
-static void
-android_mtp_MtpDatabase_setup()
-{
- MyMtpDatabase* database = new MyMtpDatabase();
-}
-
-static void
-android_mtp_MtpDatabase_finalize()
-{
- return;
-}
-
-static std::string
-android_mtp_MtpPropertyGroup_format_date_time(long seconds)
-{
- char date[20];
- formatDateTime(seconds, date, sizeof(date));
- return date;
-}
-
void MyMtpDatabase::lockMutex(void) {
std::map<int, MtpStorage*>::iterator storit;
for (storit = storagemap.begin(); storit != storagemap.end(); storit++) {
diff --git a/mtp/node.cpp b/mtp/node.cpp
index 17047ce87..1bca1d96f 100755
--- a/mtp/node.cpp
+++ b/mtp/node.cpp
@@ -33,38 +33,28 @@
#include "MtpDebug.h"
-Node::Node() {
- mtpid= -1;
- path = "";
- left = NULL;
- right = NULL;
- parent = NULL;
- mtpparentid = 0;
+Node::Node()
+ : handle(-1), parent(0), name("")
+{
}
-void Node::setMtpid(int aMtpid) { mtpid = aMtpid; }
-void Node::setPath(std::string aPath) { path = aPath; }
-void Node::rename(std::string aPath) {
- path = aPath;
- updateProperty(MTP_PROPERTY_OBJECT_FILE_NAME, 0, basename(aPath.c_str()), MTP_TYPE_STR);
- updateProperty(MTP_PROPERTY_NAME, 0, basename(aPath.c_str()), MTP_TYPE_STR);
- updateProperty(MTP_PROPERTY_DISPLAY_NAME, 0, basename(aPath.c_str()), MTP_TYPE_STR);
+Node::Node(MtpObjectHandle handle, MtpObjectHandle parent, const std::string& name)
+ : handle(handle), parent(parent), name(name)
+{
}
-void Node::setLeft(Node* aLeft) { left = aLeft; }
-void Node::setRight(Node* aRight) { right = aRight; }
-void Node::setParent(Node* aParent) { parent = aParent; }
-void Node::setMtpParentId(int id) {
- mtpparentid = id;
- MTPD("setting mtpparentid: %i on mtpid: %i\n", mtpparentid, mtpid);
+
+void Node::rename(const std::string& newName) {
+ name = newName;
+ updateProperty(MTP_PROPERTY_OBJECT_FILE_NAME, 0, name.c_str(), MTP_TYPE_STR);
+ updateProperty(MTP_PROPERTY_NAME, 0, name.c_str(), MTP_TYPE_STR);
+ updateProperty(MTP_PROPERTY_DISPLAY_NAME, 0, name.c_str(), MTP_TYPE_STR);
}
-int Node::Mtpid() { return mtpid; }
-int Node::getMtpParentId() { return mtpparentid; }
-std::string Node::getPath() { return path; }
-Node* Node::Left() { return left; }
-Node* Node::Right() { return right; }
-Node* Node::Parent() { return parent; }
-uint64_t Node::getIntProperty(uint64_t property) {
+MtpObjectHandle Node::Mtpid() const { return handle; }
+MtpObjectHandle Node::getMtpParentId() const { return parent; }
+const std::string& Node::getName() const { return name; }
+
+uint64_t Node::getIntProperty(MtpPropertyCode property) {
for (unsigned index = 0; index < mtpProp.size(); ++index) {
if (mtpProp[index].property == property)
return mtpProp[index].valueInt;
@@ -73,8 +63,18 @@ uint64_t Node::getIntProperty(uint64_t property) {
return -1;
}
-void Node::addProperty(uint64_t property, uint64_t valueInt, std::string valueStr, int dataType) {
- MTPD("adding str property: %lld, valueInt: %lld, valueStr: %s, dataType: %d\n", property, valueInt, valueStr.c_str(), dataType);
+const Node::mtpProperty& Node::getProperty(MtpPropertyCode property) {
+ static const mtpProperty dummyProp;
+ for (size_t i = 0; i < mtpProp.size(); ++i) {
+ if (mtpProp[i].property == property)
+ return mtpProp[i];
+ }
+ MTPE("Node::getProperty failed to find property %x, returning dummy property\n", (unsigned)property);
+ return dummyProp;
+}
+
+void Node::addProperty(MtpPropertyCode property, uint64_t valueInt, std::string valueStr, MtpDataType dataType) {
+// MTPD("adding property: %lld, valueInt: %lld, valueStr: %s, dataType: %d\n", property, valueInt, valueStr.c_str(), dataType);
struct mtpProperty prop;
prop.property = property;
prop.valueInt = valueInt;
@@ -83,7 +83,7 @@ void Node::addProperty(uint64_t property, uint64_t valueInt, std::string valueSt
mtpProp.push_back(prop);
}
-void Node::updateProperty(uint64_t property, uint64_t valueInt, std::string valueStr, int dataType) {
+void Node::updateProperty(MtpPropertyCode property, uint64_t valueInt, std::string valueStr, MtpDataType dataType) {
for (unsigned i = 0; i < mtpProp.size(); i++) {
if (mtpProp[i].property == property) {
mtpProp[i].valueInt = valueInt;
@@ -99,43 +99,45 @@ std::vector<Node::mtpProperty>& Node::getMtpProps() {
return mtpProp;
}
-void Node::addProperties(int storageID, int parent_object) {
+void Node::addProperties(const std::string& path, int storageID) {
+ MTPD("addProperties: handle: %u, filename: '%s'\n", handle, getName().c_str());
struct stat st;
int mFormat = 0;
uint64_t puid;
off_t file_size = 0;
- std::string mtimeStr = "00101T000000";
- std::string mtpidStr = static_cast<std::ostringstream*>( &(std::ostringstream() << mtpid) )->str();
+ std::string mtpidStr = static_cast<std::ostringstream*>( &(std::ostringstream() << handle) )->str();
std::string storageIDStr = static_cast<std::ostringstream*>( &(std::ostringstream() << storageID) )->str();
std::string puidStr = storageIDStr + mtpidStr;
if ( ! (std::istringstream(puidStr) >> puid) ) puid = 0;
mFormat = MTP_FORMAT_UNDEFINED; // file
- if (lstat(getPath().c_str(), &st) == 0) {
+ if (lstat(path.c_str(), &st) == 0) {
file_size = st.st_size;
if (S_ISDIR(st.st_mode))
mFormat = MTP_FORMAT_ASSOCIATION; // folder
- mtimeStr = static_cast<std::ostringstream*>( &(std::ostringstream() << st.st_mtime) )->str();
}
+ // TODO: don't store properties with constant values at all, add them at query time instead
addProperty(MTP_PROPERTY_STORAGE_ID, storageID, "", MTP_TYPE_UINT32);
addProperty(MTP_PROPERTY_OBJECT_FORMAT, mFormat, "", MTP_TYPE_UINT16);
addProperty(MTP_PROPERTY_PROTECTION_STATUS, 0, "", MTP_TYPE_UINT16);
addProperty(MTP_PROPERTY_OBJECT_SIZE, file_size, "", MTP_TYPE_UINT64);
- addProperty(MTP_PROPERTY_OBJECT_FILE_NAME, 0, basename(getPath().c_str()), MTP_TYPE_STR);
- MTPD("mtpid: %i, filename: '%s', parent object: %i\n", mtpid, basename(getPath().c_str()), parent_object);
- addProperty(MTP_PROPERTY_DATE_MODIFIED, 0, mtimeStr, MTP_TYPE_STR);
- addProperty(MTP_PROPERTY_PARENT_OBJECT, parent_object, "", MTP_TYPE_UINT32);
+ addProperty(MTP_PROPERTY_OBJECT_FILE_NAME, 0, getName().c_str(), MTP_TYPE_STR);
+ addProperty(MTP_PROPERTY_DATE_MODIFIED, st.st_mtime, "", MTP_TYPE_UINT64);
+ addProperty(MTP_PROPERTY_PARENT_OBJECT, parent, "", MTP_TYPE_UINT32);
addProperty(MTP_PROPERTY_PERSISTENT_UID, puid, "", MTP_TYPE_UINT128);
- addProperty(MTP_PROPERTY_NAME, 0, basename(getPath().c_str()), MTP_TYPE_STR);
- addProperty(MTP_PROPERTY_DISPLAY_NAME, 0, basename(getPath().c_str()), MTP_TYPE_STR);
- addProperty(MTP_PROPERTY_DATE_ADDED, 0, mtimeStr, MTP_TYPE_STR);
+ // TODO: we can't really support persistent UIDs without a persistent DB.
+ // probably a combination of volume UUID + st_ino would come close.
+ // doesn't help for fs with no native inodes numbers like fat though...
+ addProperty(MTP_PROPERTY_NAME, 0, getName().c_str(), MTP_TYPE_STR);
+ addProperty(MTP_PROPERTY_DISPLAY_NAME, 0, getName().c_str(), MTP_TYPE_STR);
+ addProperty(MTP_PROPERTY_DATE_ADDED, st.st_mtime, "", MTP_TYPE_UINT64);
addProperty(MTP_PROPERTY_DESCRIPTION, 0, "", MTP_TYPE_STR);
addProperty(MTP_PROPERTY_ARTIST, 0, "", MTP_TYPE_STR);
addProperty(MTP_PROPERTY_ALBUM_NAME, 0, "", MTP_TYPE_STR);
addProperty(MTP_PROPERTY_ALBUM_ARTIST, 0, "", MTP_TYPE_STR);
addProperty(MTP_PROPERTY_TRACK, 0, "", MTP_TYPE_UINT16);
- addProperty(MTP_PROPERTY_ORIGINAL_RELEASE_DATE, 0, "00101T000000", MTP_TYPE_STR);
+ addProperty(MTP_PROPERTY_ORIGINAL_RELEASE_DATE, 2014, "", MTP_TYPE_UINT64); // TODO: extract year from st.st_mtime?
addProperty(MTP_PROPERTY_DURATION, 0, "", MTP_TYPE_UINT32);
addProperty(MTP_PROPERTY_GENRE, 0, "", MTP_TYPE_STR);
addProperty(MTP_PROPERTY_COMPOSER, 0, "", MTP_TYPE_STR);
diff --git a/partition.cpp b/partition.cpp
index 31a3f8fae..add9460fc 100644
--- a/partition.cpp
+++ b/partition.cpp
@@ -108,8 +108,7 @@ static struct flag_list mount_flags[] = {
{ 0, 0 },
};
-TWPartition::TWPartition(int *id) {
- initmtpid = id;
+TWPartition::TWPartition() {
Can_Be_Mounted = false;
Can_Be_Wiped = false;
Can_Be_Backed_Up = false;
@@ -161,7 +160,6 @@ TWPartition::TWPartition(int *id) {
#ifdef TW_INCLUDE_CRYPTO_SAMSUNG
EcryptFS_Password = "";
#endif
- mtpid = 0;
}
TWPartition::~TWPartition(void) {
@@ -275,7 +273,7 @@ bool TWPartition::Process_Fstab_Line(string Line, bool Display_Error) {
Can_Encrypt_Backup = true;
Use_Userdata_Encryption = true;
if (datamedia)
- Setup_Data_Media(0);
+ Setup_Data_Media();
#ifdef TW_INCLUDE_CRYPTO
Can_Be_Encrypted = true;
char crypto_blkdev[255];
@@ -411,12 +409,6 @@ bool TWPartition::Process_Fstab_Line(string Line, bool Display_Error) {
}
}
- // Generate MTP ID
- if (Is_Storage) {
- (*initmtpid)++;
- mtpid = *initmtpid;
- }
-
// Process any custom flags
if (Flags.size() > 0)
Process_Flags(Flags, Display_Error);
@@ -682,7 +674,7 @@ void TWPartition::Setup_AndSec(void) {
Mount_Storage_Retry();
}
-void TWPartition::Setup_Data_Media(int mtp) {
+void TWPartition::Setup_Data_Media() {
LOGINFO("Setting up '%s' as data/media emulated storage.\n", Mount_Point.c_str());
Storage_Name = "Internal Storage";
Has_Data_Media = true;
@@ -703,8 +695,6 @@ void TWPartition::Setup_Data_Media(int mtp) {
DataManager::SetValue(TW_INTERNAL_PATH, "/data/media/0");
UnMount(true);
}
- if (mtp)
- mtpid = mtp;
DataManager::SetValue("tw_has_internal", 1);
DataManager::SetValue("tw_has_data_media", 1);
du.add_absolute_dir("/data/media");
diff --git a/partitionmanager.cpp b/partitionmanager.cpp
index 0063ff3ea..b2d7b4e02 100644
--- a/partitionmanager.cpp
+++ b/partitionmanager.cpp
@@ -59,7 +59,6 @@ extern "C" {
extern bool datamedia;
TWPartitionManager::TWPartitionManager(void) {
- mtpid = 100;
mtp_was_enabled = false;
}
@@ -81,7 +80,7 @@ int TWPartitionManager::Process_Fstab(string Fstab_Filename, bool Display_Error)
if (fstab_line[strlen(fstab_line) - 1] != '\n')
fstab_line[strlen(fstab_line)] = '\n';
- TWPartition* partition = new TWPartition(&mtpid);
+ TWPartition* partition = new TWPartition();
string line = fstab_line;
memset(fstab_line, 0, sizeof(fstab_line));
@@ -108,7 +107,7 @@ int TWPartitionManager::Process_Fstab(string Fstab_Filename, bool Display_Error)
if (Dat) {
LOGINFO("Using automatic handling for /data/media emulated storage device.\n");
datamedia = true;
- Dat->Setup_Data_Media(++mtpid);
+ Dat->Setup_Data_Media();
settings_partition = Dat;
}
}
@@ -283,8 +282,6 @@ void TWPartitionManager::Output_Partition(TWPartition* Part) {
printf(" Backup_Method: %s\n", back_meth.c_str());
if (Part->Mount_Flags || !Part->Mount_Options.empty())
printf(" Mount_Flags=0x%8x, Mount_Options=%s\n", Part->Mount_Flags, Part->Mount_Options.c_str());
- if (Part->mtpid)
- printf(" MTP Storage ID: %i\n", Part->mtpid);
printf("\n");
}
@@ -2187,10 +2184,12 @@ bool TWPartitionManager::Enable_MTP(void) {
* twrp set tw_mtp_debug 1
*/
twrpMtp *mtp = new twrpMtp(DataManager::GetIntValue("tw_mtp_debug"));
+ unsigned int storageid = 1 << 16; // upper 16 bits are for physical storage device, we pretend to have only one
for (iter = Partitions.begin(); iter != Partitions.end(); iter++) {
if ((*iter)->Is_Storage && (*iter)->Is_Present && (*iter)->Mount(false)) {
- printf("twrp mtpid: %d\n", (*iter)->mtpid);
- mtp->addStorage((*iter)->Storage_Name, (*iter)->Storage_Path, (*iter)->mtpid);
+ ++storageid;
+ printf("twrp addStorage %s, mtpstorageid: %u\n", (*iter)->Storage_Path.c_str(), storageid);
+ mtp->addStorage((*iter)->Storage_Name, (*iter)->Storage_Path, storageid);
count++;
}
}
diff --git a/partitions.hpp b/partitions.hpp
index 652d73357..0a57f6506 100644
--- a/partitions.hpp
+++ b/partitions.hpp
@@ -45,7 +45,7 @@ public:
};
public:
- TWPartition(int *id);
+ TWPartition();
virtual ~TWPartition();
public:
@@ -76,7 +76,7 @@ public:
protected:
bool Has_Data_Media; // Indicates presence of /data/media, may affect wiping and backup methods
- void Setup_Data_Media(int mtp); // Sets up a partition as a /data/media emulated storage partition
+ void Setup_Data_Media(); // Sets up a partition as a /data/media emulated storage partition
private:
bool Process_Fstab_Line(string Line, bool Display_Error); // Processes a fstab line
@@ -133,8 +133,6 @@ private:
string Decrypted_Block_Device; // Decrypted block device available after decryption
bool Removable; // Indicates if this partition is removable -- affects how often we check overall size, if present, etc.
int Length; // Used by make_ext4fs to leave free space at the end of the partition block for things like a crypto footer
- int *initmtpid; // Initial MTP ID
- int mtpid; // Store MTP ID
unsigned long long Size; // Overall size of the partition
unsigned long long Used; // Overall used space
unsigned long long Free; // Overall free space
@@ -241,7 +239,6 @@ private:
void Output_Partition(TWPartition* Part);
TWPartition* Find_Next_Storage(string Path, string Exclude);
int Open_Lun_File(string Partition_Path, string Lun_File);
- int mtpid;
pid_t mtppid;
bool mtp_was_enabled;
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 03:47:38 +0100