Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset abb8737 in mainline


Ignore:
Timestamp:
2012-04-01T18:44:23Z (9 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master
Children:
aa91105, d3ee35b
Parents:
d9faae91 (diff), ec351c3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge improvemens from GSOC12 "how-do-you-do period"

Files:
4 edited

Legend:

Unmodified
Added
Removed
  • tools/check.sh

    rd9faae91 rabb8737  
    6666do
    6767        echo -n ">>>> Building $P... "
    68         ( make distclean && make PROFILE=$P HANDS_OFF=y $1 ) >>/dev/null 2>>/dev/null
     68        ( make distclean && make PROFILE=$P HANDS_OFF=y "$@" ) >>/dev/null 2>>/dev/null
    6969        if [ $? -ne 0 ];
    7070        then
  • tools/mkfat.py

    rd9faae91 rabb8737  
    168168"""
    169169
    170 def mangle_fname(name):
     170LFN_ENTRY = """little:
     171        uint8_t pos
     172        uint16_t name1[5]
     173        uint8_t attr
     174        uint8_t type
     175        uint8_t csum
     176        uint16_t name2[6]
     177        uint16_t fc
     178        uint16_t name3[2]
     179"""
     180
     181# Global variable to hold the file names in 8.3 format. Needed to
     182# keep track of "number" when creating a short fname from a LFN.
     183name83_list = []
     184
     185def name83(fname):
     186        "Create a 8.3 name for the given fname"
     187
    171188        # FIXME: filter illegal characters
    172         parts = name.split('.')
    173        
     189        parts = fname.split('.')
     190       
     191        name = ''
     192        ext = ''
     193        lfn = False
     194
     195        if len(fname) > 11 :
     196                lfn = True
     197
    174198        if len(parts) > 0:
    175                 fname = parts[0]
    176         else:
    177                 fname = ''
    178        
    179         if len(fname) > 8:
    180                 sys.stdout.write("mkfat.py: error: Directory entry " + name +
    181                     " base name is longer than 8 characters\n")
    182                 sys.exit(1);
    183        
    184         return (fname + '          ').upper()[0:8]
    185 
    186 def mangle_ext(name):
    187         # FIXME: filter illegal characters
    188         parts = name.split('.')
    189        
    190         if len(parts) > 1:
    191                 ext = parts[1]
    192         else:
    193                 ext = ''
    194        
    195         if len(parts) > 2:
    196                 sys.stdout.write("mkfat.py: error: Directory entry " + name +
    197                     " has more than one extension\n")
    198                 sys.exit(1);
    199        
    200         if len(ext) > 3:
    201                 sys.stdout.write("mkfat.py: error: Directory entry " + name +
    202                     " extension is longer than 3 characters\n")
    203                 sys.exit(1);
    204        
    205         return (ext + '   ').upper()[0:3]
     199                name = parts[0]
     200                if len(name) > 8 :
     201                        lfn = True
     202
     203        if len(parts) > 1 :
     204                ext = parts[-1]
     205                if len(ext) > 3 :
     206                        lfn = True
     207
     208        if len(parts) > 2 :
     209                lfn = True
     210
     211        if (lfn == False) :
     212                return (name.ljust(8)[0:8], ext.ljust(3)[0:3], False)
     213
     214        # For filenames with multiple extensions, we treat the last one
     215        # as the actual extension. The rest of the filename is stripped
     216        # of dots and concatenated to form the short name
     217        for _name in parts[1:-1]:
     218                name = name + _name             
     219
     220        global name83_list
     221        for number in range(1, 10000) :
     222                number_str = '~' + str(number)
     223
     224                if len(name) + len(number_str) > 8 :
     225                        name = name[0:8 - len(number_str)]
     226
     227                name = name + number_str;
     228
     229                if (name + ext) not in name83_list :
     230                        break
     231                       
     232        name83_list.append(name + ext) 
     233
     234        return (name.ljust(8)[0:8], ext.ljust(3)[0:3], True)
     235
     236def get_utf16(name, l) :
     237        "Create a int array out of a string which we can store in uint16_t arrays"
     238
     239        bs = [0xFFFF for i in range(l)]
     240
     241        for i in range(len(name)) :
     242                bs[i] = ord(name[i])
     243       
     244        if (len(name) < l) :
     245                bs[len(name)] = 0;
     246       
     247        return bs
     248
     249def create_lfn_entry((name, index)) :
     250        entry = xstruct.create(LFN_ENTRY)
     251
     252        entry.name1 = get_utf16(name[0:5], 5)
     253        entry.name2 = get_utf16(name[5:11], 6)
     254        entry.name3 = get_utf16(name[11:13], 2)
     255        entry.pos = index
     256
     257        entry.attr = 0xF
     258        entry.fc = 0
     259        entry.type = 0
     260
     261        return entry
    206262
    207263def create_dirent(name, directory, cluster, size):
     264       
    208265        dir_entry = xstruct.create(DIR_ENTRY)
    209266       
    210         dir_entry.name = mangle_fname(name).encode('ascii')
    211         dir_entry.ext = mangle_ext(name).encode('ascii')
    212        
     267        dir_entry.name, dir_entry.ext, lfn = name83(name)
     268
     269        dir_entry.name = dir_entry.name.upper().encode('ascii')
     270        dir_entry.ext = dir_entry.ext.upper().encode('ascii')
     271
    213272        if (directory):
    214273                dir_entry.attr = 0x30
     
    230289                dir_entry.size = size
    231290       
    232         return dir_entry
     291
     292        if not lfn:
     293                return [dir_entry]
     294
     295        n = len(name) / 13 + 1
     296        names = [(name[i * 13: (i + 1) * 13 + 1], i + 1) for i in range(n)]
     297
     298        entries = sorted(map (create_lfn_entry, names), reverse = True, key = lambda e : e.pos)
     299        entries[0].pos |= 0x40
     300
     301        fname11 = dir_entry.name + dir_entry.ext
     302
     303        csum = 0
     304        for i in range(0, 11) :
     305                csum = ((csum & 1) << 7) + (csum  >> 1) + ord(fname11[i])
     306                csum = csum & 0xFF
     307       
     308        for e in entries :
     309                e.csum = csum;
     310       
     311        entries.append(dir_entry)
     312
     313        return entries
    233314
    234315def create_dot_dirent(empty_cluster):
     
    288369                if item.is_file:
    289370                        rv = write_file(item, outf, cluster_size, data_start, fat, reserved_clusters)
    290                         directory.append(create_dirent(item.name, False, rv[0], rv[1]))
     371                        directory.extend(create_dirent(item.name, False, rv[0], rv[1]))
    291372                elif item.is_dir:
    292373                        rv = recursion(False, item.path, outf, cluster_size, root_start, data_start, fat, reserved_clusters, dirent_size, empty_cluster)
    293                         directory.append(create_dirent(item.name, True, rv[0], rv[1]))
     374                        directory.extend(create_dirent(item.name, True, rv[0], rv[1]))
    294375       
    295376        if (head):
  • uspace/app/bdsh/cmds/modules/cat/cat.c

    rd9faae91 rabb8737  
    5252#define CAT_VERSION "0.0.1"
    5353#define CAT_DEFAULT_BUFLEN 1024
    54 
    55 static const char *cat_oops = "That option is not yet supported\n";
     54#define CAT_FULL_FILE 0
     55
    5656static const char *hexchars = "0123456789abcdef";
    5757
     
    163163}
    164164
    165 static unsigned int cat_file(const char *fname, size_t blen, bool hex)
     165static unsigned int cat_file(const char *fname, size_t blen, bool hex,
     166    off64_t head, off64_t tail, bool tail_first)
    166167{
    167168        int fd, bytes = 0, count = 0, reads = 0;
    168169        char *buff = NULL;
    169170        int i;
    170         size_t offset = 0;
     171        size_t offset = 0, copied_bytes = 0;
     172        off64_t file_size = 0, length = 0;
    171173
    172174        fd = open(fname, O_RDONLY);
     
    183185        }
    184186
     187        if (tail != CAT_FULL_FILE) {
     188                file_size = lseek(fd, 0, SEEK_END);
     189                if (head == CAT_FULL_FILE) {
     190                        head = file_size;
     191                        length = tail;
     192                } else if (tail_first) {
     193                        length = head;
     194                } else {
     195                        if (tail > head)
     196                                tail = head;
     197                        length = tail;
     198                }
     199
     200                if (tail_first) {
     201                        lseek(fd, (tail >= file_size) ? 0 : (file_size - tail), SEEK_SET);
     202                } else {
     203                        lseek(fd, ((head - tail) >= file_size) ? 0 : (head - tail), SEEK_SET);
     204                }
     205        } else
     206                length = head;
     207
    185208        do {
    186                 bytes = read(fd, buff, blen);
     209                bytes = read(fd, buff + copied_bytes, (
     210                        (length != CAT_FULL_FILE && length - (off64_t)count <= (off64_t)(blen - copied_bytes)) ?
     211                        (size_t)(length - count) :
     212                        (blen - copied_bytes) ) );
     213                bytes += copied_bytes;
     214                copied_bytes = 0;
     215
    187216                if (bytes > 0) {
    188                         count += bytes;
    189217                        buff[bytes] = '\0';
    190218                        offset = 0;
     
    193221                                        paged_char(hexchars[((uint8_t)buff[i])/16]);
    194222                                        paged_char(hexchars[((uint8_t)buff[i])%16]);
     223                                        paged_char(((count+i+1) & 0xf) == 0 ? '\n' : ' ');
    195224                                }
    196225                                else {
     
    199228                                                /* Reached end of string */
    200229                                                break;
     230                                        } else if (c == U_SPECIAL && offset + 2 >= (size_t)bytes) {
     231                                                /* If an extended character is cut off due to the size of the buffer,
     232                                                   we will copy it over to the next buffer so it can be read correctly. */
     233                                                copied_bytes = bytes - offset + 1;
     234                                                memcpy(buff, buff + offset - 1, copied_bytes);
     235                                                break;
    201236                                        }
    202237                                        paged_char(c);
     
    204239                               
    205240                        }
     241                        count += bytes;
    206242                        reads++;
    207243                }
    208         } while (bytes > 0 && !should_quit);
     244        } while (bytes > 0 && !should_quit && (count < length || length == CAT_FULL_FILE));
    209245
    210246        close(fd);
     
    223259int cmd_cat(char **argv)
    224260{
    225         unsigned int argc, i, ret = 0, buffer = 0;
     261        unsigned int argc, i, ret = 0;
     262        size_t buffer = 0;
    226263        int c, opt_ind;
     264        aoff64_t head = CAT_FULL_FILE, tail = CAT_FULL_FILE;
    227265        bool hex = false;
    228266        bool more = false;
     267        bool tailFirst = false;
    229268        sysarg_t rows, cols;
    230269        int rc;
     
    254293                        return CMD_SUCCESS;
    255294                case 'H':
    256                         printf("%s", cat_oops);
    257                         return CMD_FAILURE;
     295                        if (!optarg || str_uint64_t(optarg, NULL, 10, false, &head) != EOK ) {
     296                                puts("Invalid head size\n");
     297                                return CMD_FAILURE;
     298                        }
     299                        break;
    258300                case 't':
    259                         printf("%s", cat_oops);
    260                         return CMD_FAILURE;
     301                        if (!optarg || str_uint64_t(optarg, NULL, 10, false, &tail) != EOK ) {
     302                                puts("Invalid tail size\n");
     303                                return CMD_FAILURE;
     304                        }
     305                        if (head == CAT_FULL_FILE)
     306                                tailFirst = true;
     307                        break;
    261308                case 'b':
    262                         printf("%s", cat_oops);
     309                        if (!optarg || str_size_t(optarg, NULL, 10, false, &buffer) != EOK ) {
     310                                puts("Invalid buffer size\n");
     311                                return CMD_FAILURE;
     312                        }
    263313                        break;
    264314                case 'm':
     
    279329        }
    280330
    281         if (buffer <= 0)
     331        if (buffer < 4)
    282332                buffer = CAT_DEFAULT_BUFLEN;
    283333       
     
    295345
    296346        for (i = optind; argv[i] != NULL && !should_quit; i++)
    297                 ret += cat_file(argv[i], buffer, hex);
     347                ret += cat_file(argv[i], buffer, hex, head, tail, tailFirst);
    298348
    299349        if (ret)
  • uspace/app/bdsh/cmds/modules/cat/cat.h

    rd9faae91 rabb8737  
    44/* Prototypes for the cat command, excluding entry points */
    55
    6 static unsigned int cat_file(const char *, size_t, bool);
     6static unsigned int cat_file(const char *, size_t, bool, off64_t, off64_t, bool);
    77
    88#endif /* CAT_H */
Note: See TracChangeset for help on using the changeset viewer.