contrib/lar/lar.c

   1 #include "lar.h"
   2
   3 int lar_read32( int fd, uint32_t *val )
   4 {
   5         uint8_t buffer[5];
   6
   7         if( read(fd, buffer, 4) < 4 )
   8                 LAR_DIE("Unexpected EOF while reading data");
   9
  10         buffer[4] = 0;
  11         *val = ntohl(*((uint32_t *) buffer));
  12
  13         return 0;
  14 }
  15
  16 int lar_read16( int fd, uint16_t *val )
  17 {
  18         uint8_t buffer[3];
  19
  20         if( read(fd, buffer, 2) < 2 )
  21                 LAR_DIE("Unexpected EOF while reading data");
  22
  23         buffer[2] = 0;
  24         *val = ntohs(*((uint16_t *) buffer));
  25
  26         return 0;
  27 }
  28
  29 lar_index * lar_get_index( lar_archive *ar )
  30 {
  31         uint32_t i;
  32         uint32_t idx_offset;
  33         uint32_t idx_length;
  34         lar_index *idx_map, *idx_ptr;
  35
  36         if( lseek(ar->fd, -(sizeof(idx_offset)), SEEK_END) == -1 )
  37                 LAR_DIE("Unable to seek to end of archive");
  38
  39         lar_read32(ar->fd, &idx_offset);
  40         idx_length = ( ar->length - idx_offset - sizeof(idx_offset) );
  41
  42         if( lseek(ar->fd, idx_offset, SEEK_SET) == -1 )
  43                 LAR_DIE("Unable to seek to archive index");
  44
  45
  46         idx_map = NULL;
  47
  48         for( i = 0; i < idx_length; \
  49                 i += (sizeof(lar_index) - sizeof(char *))
  50         ) {
  51                 idx_ptr = (lar_index *)malloc(sizeof(lar_index));
  52
  53                 lar_read32(ar->fd, &idx_ptr->noffset);
  54                 lar_read32(ar->fd, &idx_ptr->nlength);
  55                 lar_read32(ar->fd, &idx_ptr->foffset);
  56                 lar_read32(ar->fd, &idx_ptr->flength);
  57                 lar_read16(ar->fd, &idx_ptr->type);
  58                 lar_read16(ar->fd, &idx_ptr->flags);
  59
  60                 idx_ptr->next = idx_map;
  61                 idx_map = idx_ptr;
  62         }
  63
  64         return idx_map;
  65 }
  66
  67 uint32_t lar_get_filename( lar_archive *ar,
  68         lar_index *idx_ptr, char *filename
  69 ) {
  70         if( idx_ptr->nlength >= LAR_FNAME_BUFFER )
  71                 LAR_DIE("Filename exceeds maximum allowed length");
  72
  73         if( lseek(ar->fd, idx_ptr->noffset, SEEK_SET) == -1 )
  74                 LAR_DIE("Unexpected EOF while seeking filename");
  75
  76         if( read(ar->fd, filename, idx_ptr->nlength) < idx_ptr->nlength )
  77                 LAR_DIE("Unexpected EOF while reading filename");
  78
  79         filename[idx_ptr->nlength] = 0;
  80
  81         return idx_ptr->nlength;
  82 }
  83
  84 lar_member * lar_open_member( lar_archive *ar, const char *name )
  85 {
  86         lar_index *idx_ptr = ar->index;
  87         lar_member *member;
  88         char memberfile[LAR_FNAME_BUFFER];
  89         char *memberdata;
  90         size_t pgsz  = getpagesize();
  91
  92         while(idx_ptr)
  93         {
  94                 lar_get_filename(ar, idx_ptr, memberfile);
  95
  96                 if( !strncmp(memberfile, name, idx_ptr->nlength) )
  97                 {
  98                         memberdata = mmap(
  99                                 0, idx_ptr->flength + ( idx_ptr->foffset % pgsz ),
 100                                 PROT_READ, MAP_PRIVATE, ar->fd,
 101                                 idx_ptr->foffset - ( idx_ptr->foffset % pgsz )
 102                         );
 103
 104                         if( memberdata == MAP_FAILED )
 105                                 LAR_DIE("Failed to mmap() member data");
 106
 107                         member = (lar_member *)malloc(sizeof(lar_member));
 108                         member->type   = idx_ptr->type;
 109                         member->flags  = idx_ptr->flags;
 110                         member->length = idx_ptr->flength;
 111                         member->data   = &memberdata[idx_ptr->foffset % pgsz];
 112
 113                         member->mmap   = memberdata;
 114                         member->mlen   = idx_ptr->flength + ( idx_ptr->foffset % pgsz );
 115
 116                         return member;
 117                 }
 118
 119                 idx_ptr = idx_ptr->next;
 120         }
 121
 122         return NULL;
 123 }
 124
 125 int lar_close_member( lar_member *member )
 126 {
 127         int stat = munmap(member->mmap, member->mlen);
 128         free(member);
 129
 130         return stat;
 131 }
 132
 133 lar_archive * lar_open( const char *filename )
 134 {
 135         int fd;
 136         struct stat as;
 137         lar_archive *ar;
 138
 139         if( stat(filename, &as) == -1 )
 140                 return NULL;
 141
 142         if( !(as.st_mode & S_IFREG) )
 143                 return NULL;
 144
 145         if( (fd = open(filename, O_RDONLY)) != -1 )
 146         {
 147                 ar = (lar_archive *)malloc(sizeof(lar_archive));
 148                 ar->fd       = fd;
 149                 ar->length   = as.st_size;
 150                 ar->index    = lar_get_index(ar);
 151                 strncpy(ar->filename, filename, sizeof(ar->filename));
 152
 153                 return ar;
 154         }
 155
 156         return NULL;
 157 }
 158
 159 int lar_close( lar_archive *ar )
 160 {
 161         lar_index *idx_head;
 162         lar_index *idx_next;
 163
 164         close(ar->fd);
 165
 166         idx_head = ar->index;
 167         do {
 168                 idx_next = idx_head->next;
 169                 free(idx_head);
 170         } while( (idx_head = idx_next) != NULL );
 171
 172         free(ar);
 173
 174         return 0;
 175 }
 176
 177 lar_archive * lar_find_archive( const char *package, const char *path )
 178 {
 179         int seg = 1;
 180         int len = 0;
 181         int pln = 0;
 182         int i, j;
 183         struct stat s;
 184         LAR_FNAME(buffer);
 185
 186         if( path )
 187         {
 188                 for( pln = 0; path[pln] != '\0'; pln++ )
 189                         if( pln >= (sizeof(buffer) - 5) )
 190                                 LAR_DIE("Library path exceeds maximum allowed length");
 191
 192                 memcpy(buffer, path, pln);
 193         }
 194
 195         for( len = 0; package[len] != '\0'; len++ )
 196         {
 197                 if( len >= (sizeof(buffer) - 5 - pln) )
 198                         LAR_DIE("Package name exceeds maximum allowed length");
 199
 200                 if( package[len] == '.' ) seg++;
 201         }
 202
 203         while( seg > 0 )
 204         {
 205                 for( i = 0, j = 1; (i < len) && (j <= seg); i++ )
 206                 {
 207                         if( package[i] == '.' ) {
 208                                 if( j < seg ) j++; else break;
 209                         }
 210
 211                         buffer[pln+i] = ( package[i] == '.' ) ? LAR_DIRSEP : package[i];
 212                 }
 213
 214                 buffer[pln+i+0] = '.'; buffer[pln+i+1] = 'l'; buffer[pln+i+2] = 'a';
 215                 buffer[pln+i+3] = 'r'; buffer[pln+i+4] = '\0';
 216
 217                 if( (stat(buffer, &s) > -1) && (s.st_mode & S_IFREG) )
 218                         return lar_open(buffer);
 219
 220                 seg--;
 221         }
 222
 223         return NULL;
 224 }
 225
 226 lar_member * lar_find_member( lar_archive *ar, const char *package )
 227 {
 228         int len;
 229         LAR_FNAME(buffer);
 230
 231         for( len = 0; package[len] != '\0'; len++ )
 232         {
 233                 if( len >= (sizeof(buffer) - 5) )
 234                         LAR_DIE("Package name exceeds maximum allowed length");
 235
 236                 buffer[len] = ( package[len] == '.' ) ? '/' : package[len];
 237         }
 238
 239         buffer[len+0] = '.'; buffer[len+1] = 'l'; buffer[len+2] = 'u';
 240         buffer[len+3] = 'a'; buffer[len+4] = '\0';
 241
 242         return lar_open_member(ar, buffer);
 243 }