Subversion Repositories freemyipod

Rev

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

Rev 479 Rev 482
Line 889... Line 889...
889 
        try:
 889 
        try:
890 
            f = open(file, 'wb')
 890 
            f = open(file, 'wb')
891 
        except IOError:
 891 
        except IOError:
892 
            raise ArgumentError("Could not open local file for writing.")
 892 
            raise ArgumentError("Could not open local file for writing.")
893 
        try:
 893 
        try:
- 
 
 894 
            storageinfo = self.emcore.storage_get_info(volume)
- 
 
 895 
            buffsize = min(buffsize, storageinfo.sectorsize * count)
894 
            if buffer is None:
 896 
            if buffer is None:
895 
                buffer = self.emcore.malloc(buffsize)
 897 
                buffer = self.emcore.malloc(buffsize)
896 
                malloc = True
 898 
                malloc = True
897 
            else:
 899 
            else:
898 
                buffer = self._hexint(buffer)
 900 
                buffer = self._hexint(buffer)
899 
                malloc = False
 901 
                malloc = False
900 
            try:
 902 
            try:
901 
                self.logger.info("Reading volume %s sectors %X - %X to %s..." % (volume, sector, sector + count - 1, file))
 903 
                self.logger.info("Reading volume %s sectors %X - %X to %s..." % (volume, sector, sector + count - 1, file))
902 
                storageinfo = self.emcore.storage_get_info(volume)
 - 
 
903 
                while count > 0:
 904 
                while count > 0:
904 
                    sectors = min(count, int(buffsize / storageinfo.sectorsize))
 905 
                    sectors = min(count, int(buffsize / storageinfo.sectorsize))
905 
                    self.emcore.storage_read_sectors_md(volume, sector, sectors, buffsize, buffer)
 906 
                    self.emcore.storage_read_sectors_md(volume, sector, sectors, buffsize, buffer)
906 
                    f.write(self.emcore.read(buffer, storageinfo.sectorsize * sectors))
 907 
                    f.write(self.emcore.read(buffer, storageinfo.sectorsize * sectors))
907 
                    sector = sector + sectors
 908 
                    sector = sector + sectors
Line 926... Line 927...
926 
        try:
 927 
        try:
927 
            f = open(file, 'rb')
 928 
            f = open(file, 'rb')
928 
        except IOError:
 929 
        except IOError:
929 
            raise ArgumentError("Could not open local file for reading.")
 930 
            raise ArgumentError("Could not open local file for reading.")
930 
        try:
 931 
        try:
- 
 
 932 
            storageinfo = self.emcore.storage_get_info(volume)
- 
 
 933 
            buffsize = min(buffsize, storageinfo.sectorsize * count)
931 
            if buffer is None:
 934 
            if buffer is None:
932 
                buffer = self.emcore.malloc(buffsize)
 935 
                buffer = self.emcore.malloc(buffsize)
933 
                malloc = True
 936 
                malloc = True
934 
            else:
 937 
            else:
935 
                buffer = self._hexint(buffer)
 938 
                buffer = self._hexint(buffer)
936 
                malloc = False
 939 
                malloc = False
937 
            try:
 940 
            try:
938 
                self.logger.info("Writing %s to volume %s sectors %X - %X..." % (file, volume, sector, sector + count - 1))
 941 
                self.logger.info("Writing %s to volume %s sectors %X - %X..." % (file, volume, sector, sector + count - 1))
939 
                storageinfo = self.emcore.storage_get_info(volume)
 - 
 
940 
                while count > 0:
 942 
                while count > 0:
941 
                    sectors = min(count, int(buffsize / storageinfo.sectorsize))
 943 
                    sectors = min(count, int(buffsize / storageinfo.sectorsize))
942 
                    bytes = storageinfo.sectorsize * sectors
 944 
                    bytes = storageinfo.sectorsize * sectors
943 
                    data = f.read(bytes)
 945 
                    data = f.read(bytes)
944 
                    if len(data) == 0: break
 946 
                    if len(data) == 0: break
Line 1021... Line 1023...
1021 
        try:
 1023 
        try:
1022 
            f = open(localname, 'wb')
 1024 
            f = open(localname, 'wb')
1023 
        except IOError:
 1025 
        except IOError:
1024 
            raise ArgumentError("Could not open local file for writing.")
 1026 
            raise ArgumentError("Could not open local file for writing.")
1025 
        try:
 1027 
        try:
1026 
            if buffer is None:
 - 
 
1027 
                buffer = self.emcore.malloc(buffsize)
 1028 
            fd = self.emcore.file_open(remotename, 0)
1028 
                malloc = True
 - 
 
1029 
            else:
 - 
 
1030 
                buffer = self._hexint(buffer)
 - 
 
1031 
                malloc = False
 - 
 
1032 
            try:
 1029 
            try:
1033 
                self.logger.info("Downloading file " + remotename + " to " + localname + "...")
 1030 
                size = self.emcore.file_size(fd)
- 
 
 1031 
                buffsize = min(buffsize, size)
- 
 
 1032 
                if buffer is None:
1034 
                fd = self.emcore.file_open(remotename, 0)
 1033 
                    buffer = self.emcore.malloc(buffsize)
- 
 
 1034 
                    malloc = True
- 
 
 1035 
                else:
- 
 
 1036 
                    buffer = self._hexint(buffer)
- 
 
 1037 
                    malloc = False
1035 
                try:
 1038 
                try:
1036 
                    size = self.emcore.file_size(fd)
 1039 
                    self.logger.info("Downloading file " + remotename + " to " + localname + "...")
1037 
                    while size > 0:
 1040 
                    while size > 0:
1038 
                        bytes = self.emcore.file_read(fd, buffsize, buffer)
 1041 
                        bytes = self.emcore.file_read(fd, buffsize, buffer)
1039 
                        f.write(self.emcore.read(buffer, bytes))
 1042 
                        f.write(self.emcore.read(buffer, bytes))
1040 
                        size = size - bytes
 1043 
                        size = size - bytes
1041 
                finally:
 1044 
                finally:
- 
 
 1045 
                    if malloc == True:
1042 
                    self.emcore.file_close(fd)
 1046 
                        self.emcore.free(buffer)
1043 
            finally:
 1047 
            finally:
1044 
                if malloc == True:
 - 
 
1045 
                    self.emcore.free(buffer)
 1048 
                self.emcore.file_close(fd)
1046 
        finally:
 1049 
        finally:
1047 
            f.close()
 1050 
            f.close()
1048 
        self.logger.info(" done\n")
 1051 
        self.logger.info(" done\n")
1049 
 
 1052 
 
1050 
    @command
 1053 
    @command
Line 1095... Line 1098...
1095 
        try:
 1098 
        try:
1096 
            f = open(localname, 'rb')
 1099 
            f = open(localname, 'rb')
1097 
        except IOError:
 1100 
        except IOError:
1098 
            raise ArgumentError("Could not open local file for reading.")
 1101 
            raise ArgumentError("Could not open local file for reading.")
1099 
        try:
 1102 
        try:
- 
 
 1103 
            buffsize = min(buffsize, os.path.getsize(localname))
1100 
            if buffer is None:
 1104 
            if buffer is None:
1101 
                buffer = self.emcore.malloc(buffsize)
 1105 
                buffer = self.emcore.malloc(buffsize)
1102 
                malloc = True
 1106 
                malloc = True
1103 
            else:
 1107 
            else:
1104 
                buffer = self._hexint(buffer)
 1108 
                buffer = self._hexint(buffer)