Subversion Repositories freemyipod

Rev

Rev 478 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 478 Rev 479
Line 884... Line 884...
884 
        """
 884 
        """
885 
        volume = self._hexint(volume)
 885 
        volume = self._hexint(volume)
886 
        sector = self._hexint(sector)
 886 
        sector = self._hexint(sector)
887 
        count = self._hexint(count)
 887 
        count = self._hexint(count)
888 
        buffsize = self._hexint(buffsize)
 888 
        buffsize = self._hexint(buffsize)
889 
        if buffer is None:
 - 
 
890 
            buffer = self.emcore.malloc(buffsize)
 - 
 
891 
            malloc = True
 - 
 
892 
        else:
 - 
 
893 
            buffer = self._hexint(buffer)
 - 
 
894 
            malloc = False
 - 
 
895 
        try:
 889 
        try:
- 
 
 890 
            f = open(file, 'wb')
- 
 
 891 
        except IOError:
- 
 
 892 
            raise ArgumentError("Could not open local file for writing.")
- 
 
 893 
        try:
- 
 
 894 
            if buffer is None:
- 
 
 895 
                buffer = self.emcore.malloc(buffsize)
- 
 
 896 
                malloc = True
- 
 
 897 
            else:
- 
 
 898 
                buffer = self._hexint(buffer)
- 
 
 899 
                malloc = False
896 
            try:
 900 
            try:
897 
                f = open(file, 'wb')
 - 
 
898 
            except IOError:
 - 
 
899 
                raise ArgumentError("Could not open local file for writing.")
 - 
 
900 
            self.logger.info("Reading volume %s sectors %X - %X to %s..." % (volume, sector, sector + count - 1, file))
 901 
                self.logger.info("Reading volume %s sectors %X - %X to %s..." % (volume, sector, sector + count - 1, file))
901 
            storageinfo = self.emcore.storage_get_info(volume)
 902 
                storageinfo = self.emcore.storage_get_info(volume)
902 
            while count > 0:
 903 
                while count > 0:
903 
                sectors = min(count, int(buffsize / storageinfo.sectorsize))
 904 
                    sectors = min(count, int(buffsize / storageinfo.sectorsize))
904 
                self.emcore.storage_read_sectors_md(volume, sector, sectors, buffsize, buffer)
 905 
                    self.emcore.storage_read_sectors_md(volume, sector, sectors, buffsize, buffer)
905 
                f.write(self.emcore.read(buffer, storageinfo.sectorsize * sectors))
 906 
                    f.write(self.emcore.read(buffer, storageinfo.sectorsize * sectors))
906 
                sector = sector + sectors
 907 
                    sector = sector + sectors
907 
                count = count - sectors
 908 
                    count = count - sectors
908 
            f.close()
 909 
            finally:
- 
 
 910 
                if malloc == True:
- 
 
 911 
                    self.emcore.free(buffer)
909 
        finally:
 912 
        finally:
910 
            if malloc == True:
 913 
            f.close()
911 
                self.emcore.free(buffer)
 - 
 
912 
        self.logger.info("done\n")
 914 
        self.logger.info("done\n")
913 
 
 915 
 
914 
    @command
 916 
    @command
915 
    def writerawstoragefile(self, volume, sector, count, file, buffsize = 0x100000, buffer = None):
 917 
    def writerawstoragefile(self, volume, sector, count, file, buffsize = 0x100000, buffer = None):
916 
        """
 918 
        """
Line 919... Line 921...
919 
        """
 921 
        """
920 
        volume = self._hexint(volume)
 922 
        volume = self._hexint(volume)
921 
        sector = self._hexint(sector)
 923 
        sector = self._hexint(sector)
922 
        count = self._hexint(count)
 924 
        count = self._hexint(count)
923 
        buffsize = self._hexint(buffsize)
 925 
        buffsize = self._hexint(buffsize)
924 
        if buffer is None:
 - 
 
925 
            buffer = self.emcore.malloc(buffsize)
 - 
 
926 
            malloc = True
 - 
 
927 
        else:
 - 
 
928 
            buffer = self._hexint(buffer)
 - 
 
929 
            malloc = False
 - 
 
930 
        try:
 926 
        try:
- 
 
 927 
            f = open(file, 'rb')
- 
 
 928 
        except IOError:
- 
 
 929 
            raise ArgumentError("Could not open local file for reading.")
- 
 
 930 
        try:
- 
 
 931 
            if buffer is None:
- 
 
 932 
                buffer = self.emcore.malloc(buffsize)
- 
 
 933 
                malloc = True
- 
 
 934 
            else:
- 
 
 935 
                buffer = self._hexint(buffer)
- 
 
 936 
                malloc = False
931 
            try:
 937 
            try:
932 
                f = open(file, 'rb')
 - 
 
933 
            except IOError:
 - 
 
934 
                raise ArgumentError("Could not open local file for reading.")
 - 
 
935 
            self.logger.info("Writing %s to volume %s sectors %X - %X..." % (file, volume, sector, sector + count - 1))
 938 
                self.logger.info("Writing %s to volume %s sectors %X - %X..." % (file, volume, sector, sector + count - 1))
936 
            storageinfo = self.emcore.storage_get_info(volume)
 939 
                storageinfo = self.emcore.storage_get_info(volume)
937 
            while count > 0:
 940 
                while count > 0:
938 
                sectors = min(count, int(buffsize / storageinfo.sectorsize))
 941 
                    sectors = min(count, int(buffsize / storageinfo.sectorsize))
939 
                bytes = storageinfo.sectorsize * sectors
 942 
                    bytes = storageinfo.sectorsize * sectors
940 
                data = f.read(bytes)
 943 
                    data = f.read(bytes)
941 
                if len(data) == 0: break
 944 
                    if len(data) == 0: break
942 
                while len(data) < bytes: data = data + f.read(bytes - len(data))
 945 
                    while len(data) < bytes: data = data + f.read(bytes - len(data))
943 
                self.emcore.write(buffer, data)
 946 
                    self.emcore.write(buffer, data)
944 
                self.emcore.storage_write_sectors_md(volume, sector, sectors, buffsize, buffer)
 947 
                    self.emcore.storage_write_sectors_md(volume, sector, sectors, buffsize, buffer)
945 
                sector = sector + sectors
 948 
                    sector = sector + sectors
946 
                count = count - sectors
 949 
                    count = count - sectors
947 
            f.close()
 950 
            finally:
- 
 
 951 
                if malloc == True:
- 
 
 952 
                    self.emcore.free(buffer)
948 
        finally:
 953 
        finally:
949 
            if malloc == True:
 954 
            f.close()
950 
                self.emcore.free(buffer)
 - 
 
951 
        self.logger.info("done\n")
 955 
        self.logger.info("done\n")
952 
 
 956 
 
953 
    @command
 957 
    @command
954 
    def mkdir(self, dirname):
 958 
    def mkdir(self, dirname):
955 
        """
 959 
        """
Line 1012... Line 1016...
1012 
            <localname>: filename on the computer
 1016 
            <localname>: filename on the computer
1013 
            [buffsize]: buffer size (optional)
 1017 
            [buffsize]: buffer size (optional)
1014 
            [buffer]: buffer address (optional)
 1018 
            [buffer]: buffer address (optional)
1015 
        """
 1019 
        """
1016 
        buffsize = self._hexint(buffsize)
 1020 
        buffsize = self._hexint(buffsize)
1017 
        if buffer is None:
 - 
 
1018 
            buffer = self.emcore.malloc(buffsize)
 - 
 
1019 
            malloc = True
 - 
 
1020 
        else:
 - 
 
1021 
            buffer = self._hexint(buffer)
 - 
 
1022 
            malloc = False
 - 
 
1023 
        try:
 1021 
        try:
- 
 
 1022 
            f = open(localname, 'wb')
- 
 
 1023 
        except IOError:
- 
 
 1024 
            raise ArgumentError("Could not open local file for writing.")
- 
 
 1025 
        try:
- 
 
 1026 
            if buffer is None:
- 
 
 1027 
                buffer = self.emcore.malloc(buffsize)
- 
 
 1028 
                malloc = True
- 
 
 1029 
            else:
- 
 
 1030 
                buffer = self._hexint(buffer)
- 
 
 1031 
                malloc = False
1024 
            try:
 1032 
            try:
1025 
                f = open(localname, 'wb')
 - 
 
1026 
            except IOError:
 - 
 
1027 
                raise ArgumentError("Could not open local file for writing.")
 - 
 
1028 
            self.logger.info("Downloading file " + remotename + " to " + localname + "...")
 1033 
                self.logger.info("Downloading file " + remotename + " to " + localname + "...")
1029 
            fd = self.emcore.file_open(remotename, 0)
 1034 
                fd = self.emcore.file_open(remotename, 0)
- 
 
 1035 
                try:
1030 
            size = self.emcore.file_size(fd)
 1036 
                    size = self.emcore.file_size(fd)
1031 
            while size > 0:
 1037 
                    while size > 0:
1032 
                bytes = self.emcore.file_read(fd, buffsize, buffer)
 1038 
                        bytes = self.emcore.file_read(fd, buffsize, buffer)
1033 
                f.write(self.emcore.read(buffer, bytes))
 1039 
                        f.write(self.emcore.read(buffer, bytes))
1034 
                size = size - bytes
 1040 
                        size = size - bytes
- 
 
 1041 
                finally:
1035 
            self.emcore.file_close(fd)
 1042 
                    self.emcore.file_close(fd)
1036 
            f.close()
 1043 
            finally:
- 
 
 1044 
                if malloc == True:
- 
 
 1045 
                    self.emcore.free(buffer)
1037 
        finally:
 1046 
        finally:
1038 
            if malloc == True:
 1047 
            f.close()
1039 
                self.emcore.free(buffer)
 - 
 
1040 
        self.logger.info(" done\n")
 1048 
        self.logger.info(" done\n")
1041 
 
 1049 
 
1042 
    @command
 1050 
    @command
1043 
    def gettree(self, remotepath, localpath, buffsize = 0x10000, buffer = None):
 1051 
    def gettree(self, remotepath, localpath, buffsize = 0x10000, buffer = None):
1044 
        """
 1052 
        """
Line 1047... Line 1055...
1047 
            <localpath>: path on the computer
 1055 
            <localpath>: path on the computer
1048 
            [buffsize]: buffer size (optional)
 1056 
            [buffsize]: buffer size (optional)
1049 
            [buffer]: buffer address (optional)
 1057 
            [buffer]: buffer address (optional)
1050 
        """
 1058 
        """
1051 
        buffsize = self._hexint(buffsize)
 1059 
        buffsize = self._hexint(buffsize)
1052 
        if buffer is None:
 - 
 
1053 
            buffer = self.emcore.malloc(buffsize)
 1060 
        handle = self.emcore.dir_open(remotepath)
1054 
            malloc = True
 - 
 
1055 
        else:
 - 
 
1056 
            buffer = self._hexint(buffer)
 - 
 
1057 
            malloc = False
 - 
 
1058 
        try:
 1061 
        try:
- 
 
 1062 
            if buffer is None:
- 
 
 1063 
                buffer = self.emcore.malloc(buffsize)
1059 
            try: os.mkdir(localpath)
 1064 
                malloc = True
1060 
            except: pass
 1065 
            else:
1061 
 
 - 
 
- 
 
 1066 
                buffer = self._hexint(buffer)
- 
 
 1067 
                malloc = False
- 
 
 1068 
            try:
1062 
            handle = self.emcore.dir_open(remotepath)
 1069 
                try: os.mkdir(localpath)
- 
 
 1070 
                except: pass
1063 
            while True:
 1071 
                while True:
1064 
                try:
 1072 
                    try:
1065 
                    entry = self.emcore.dir_read(handle)
 1073 
                        entry = self.emcore.dir_read(handle)
1066 
                    if entry.name == "." or entry.name == "..": continue
 1074 
                        if entry.name == "." or entry.name == "..": continue
1067 
                    elif entry.attributes & 0x10:
 1075 
                        elif entry.attributes & 0x10:
1068 
                        self.gettree(remotepath + "/" + entry.name, localpath + "/" + entry.name, buffsize, buffer)
 1076 
                            self.gettree(remotepath + "/" + entry.name, localpath + "/" + entry.name, buffsize, buffer)
1069 
                    else: self.get(remotepath + "/" + entry.name, localpath + "/" + entry.name, buffsize, buffer)
 1077 
                        else: self.get(remotepath + "/" + entry.name, localpath + "/" + entry.name, buffsize, buffer)
1070 
                except: break
 1078 
                    except: break
- 
 
 1079 
            finally:
- 
 
 1080 
                if malloc == True:
1071 
            self.emcore.dir_close(handle)
 1081 
                    self.emcore.free(buffer)
1072 
        finally:
 1082 
        finally:
1073 
            if malloc == True:
 - 
 
1074 
                self.emcore.free(buffer)
 1083 
            self.emcore.dir_close(handle)
1075 
 
 1084 
 
1076 
    @command
 1085 
    @command
1077 
    def put(self, localname, remotename, buffsize = 0x10000, buffer = None):
 1086 
    def put(self, localname, remotename, buffsize = 0x10000, buffer = None):
1078 
        """
 1087 
        """
1079 
            Uploads a file
 1088 
            Uploads a file
Line 1081... Line 1090...
1081 
            <remotename>: filename on the device
 1090 
            <remotename>: filename on the device
1082 
            [buffsize]: buffer size (optional)
 1091 
            [buffsize]: buffer size (optional)
1083 
            [buffer]: buffer address (optional)
 1092 
            [buffer]: buffer address (optional)
1084 
        """
 1093 
        """
1085 
        buffsize = self._hexint(buffsize)
 1094 
        buffsize = self._hexint(buffsize)
1086 
        if buffer is None:
 - 
 
1087 
            buffer = self.emcore.malloc(buffsize)
 - 
 
1088 
            malloc = True
 - 
 
1089 
        else:
 - 
 
1090 
            buffer = self._hexint(buffer)
 - 
 
1091 
            malloc = False
 - 
 
1092 
        try:
 1095 
        try:
- 
 
 1096 
            f = open(localname, 'rb')
- 
 
 1097 
        except IOError:
- 
 
 1098 
            raise ArgumentError("Could not open local file for reading.")
- 
 
 1099 
        try:
- 
 
 1100 
            if buffer is None:
- 
 
 1101 
                buffer = self.emcore.malloc(buffsize)
- 
 
 1102 
                malloc = True
- 
 
 1103 
            else:
- 
 
 1104 
                buffer = self._hexint(buffer)
- 
 
 1105 
                malloc = False
1093 
            try:
 1106 
            try:
1094 
                f = open(localname, 'rb')
 - 
 
1095 
            except IOError:
 - 
 
1096 
                raise ArgumentError("Could not open local file for reading.")
 - 
 
1097 
            self.logger.info("Uploading file " + localname + " to " + remotename + "...\n")
 1107 
                self.logger.info("Uploading file " + localname + " to " + remotename + "...")
1098 
            fd = self.emcore.file_open(remotename, 0x15)
 1108 
                fd = self.emcore.file_open(remotename, 0x15)
- 
 
 1109 
                try:
1099 
            while True:
 1110 
                    while True:
1100 
                data = f.read(buffsize)
 1111 
                        data = f.read(buffsize)
1101 
                if len(data) == 0: break
 1112 
                        if len(data) == 0: break
1102 
                self.emcore.write(buffer, data)
 1113 
                        self.emcore.write(buffer, data)
1103 
                bytes = 0
 1114 
                        bytes = 0
1104 
                while bytes < len(data):
 1115 
                        while bytes < len(data):
1105 
                    bytes = bytes + self.emcore.file_write(fd, len(data) - bytes, buffer + bytes)
 1116 
                            bytes = bytes + self.emcore.file_write(fd, len(data) - bytes, buffer + bytes)
- 
 
 1117 
                finally:
1106 
            self.emcore.file_close(fd)
 1118 
                    self.emcore.file_close(fd)
1107 
            f.close()
 1119 
            finally:
- 
 
 1120 
                if malloc == True:
- 
 
 1121 
                    self.emcore.free(buffer)
1108 
        finally:
 1122 
        finally:
1109 
            if malloc == True:
 1123 
            f.close()
1110 
                self.emcore.free(buffer)
 - 
 
1111 
        self.logger.info(" done\n")
 1124 
        self.logger.info(" done\n")
1112 
 
 1125 
 
1113 
    @command
 1126 
    @command
1114 
    def puttree(self, localpath, remotepath, buffsize = 0x10000, buffer = None):
 1127 
    def puttree(self, localpath, remotepath, buffsize = 0x10000, buffer = None):
1115 
        """
 1128 
        """
Line 1135... Line 1148...
1135 
                for dir in d[1]:
 1148 
                for dir in d[1]:
1136 
                    if dir != ".svn":
 1149 
                    if dir != ".svn":
1137 
                        try: self.mkdir(prefix + dir)
 1150 
                        try: self.mkdir(prefix + dir)
1138 
                        except: self.logger.info(" failed\n")
 1151 
                        except: self.logger.info(" failed\n")
1139 
                for f in d[2]:
 1152 
                for f in d[2]:
1140 
                    if not prefix.find("/.svn/") > -1:
 1153 
                    if prefix.find("/.svn/") == -1:
1141 
                        self.put(d[0] + "/" + f, prefix + f, buffsize, buffer)
 1154 
                        self.put(d[0] + "/" + f, prefix + f, buffsize, buffer)
1142 
        finally:
 1155 
        finally:
1143 
            if malloc == True:
 1156 
            if malloc == True:
1144 
                self.emcore.free(buffer)
 1157 
                self.emcore.free(buffer)
1145 
 
 1158