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;
  35         lar_index *idx_ptr;
  36
  37         if( lseek(ar->fd, -(sizeof(idx_offset)), SEEK_END) == -1 )
  38                 LAR_DIE("Unable to seek to end of archive");
  39
  40         lar_read32(ar->fd, &idx_offset);
  41         idx_length = ( ar->length - idx_offset - sizeof(idx_offset) );
  42
  43         if( lseek(ar->fd, idx_offset, SEEK_SET) == -1 )
  44                 LAR_DIE("Unable to seek to archive index");
  45
  46
  47         idx_map = NULL;
  48
  49         for( i = 0; i < idx_length; i += (sizeof(lar_index) - sizeof(char *)) ) {
  50                 idx_ptr = (lar_index *)malloc(sizeof(lar_index));
  51
  52                 lar_read32(ar->fd, &idx_ptr->noffset);
  53                 lar_read32(ar->fd, &idx_ptr->nlength);
  54                 lar_read32(ar->fd, &idx_ptr->foffset);
  55                 lar_read32(ar->fd, &idx_ptr->flength);
  56                 lar_read16(ar->fd, &idx_ptr->type);
  57                 lar_read16(ar->fd, &idx_ptr->flags);
  58
  59                 idx_ptr->next = idx_map;
  60                 idx_map = idx_ptr;
  61         }
  62
  63         return idx_map;
  64 }
  65
  66 uint32_t lar_get_filename( lar_archive *ar, lar_index *idx_ptr, char *filename )
  67 {
  68         if( idx_ptr->nlength >= LAR_FNAME_BUFFER )
  69                 LAR_DIE("Filename exceeds maximum allowed length");
  70
  71         if( lseek(ar->fd, idx_ptr->noffset, SEEK_SET) == -1 )
  72                 LAR_DIE("Unexpected EOF while seeking filename");
  73
  74         if( read(ar->fd, filename, idx_ptr->nlength) < idx_ptr->nlength )
  75                 LAR_DIE("Unexpected EOF while reading filename");
  76
  77         filename[idx_ptr->nlength] = '\0';
  78
  79         return idx_ptr->nlength;
  80 }
  81
  82 lar_member * lar_open_member( lar_archive *ar, const char *name )
  83 {
  84         lar_index *idx_ptr = ar->index;
  85         lar_member *member;
  86         char *memberdata;
  87         size_t pgof;
  88         size_t pgsz = getpagesize();
  89         LAR_FNAME(memberfile);
  90
  91         while(idx_ptr)
  92         {
  93                 lar_get_filename(ar, idx_ptr, memberfile);
  94
  95                 if( !strncmp(memberfile, name, idx_ptr->nlength) )
  96                 {
  97                         pgof = ( idx_ptr->foffset % pgsz );
  98
  99                         memberdata = mmap(
 100                                 0, idx_ptr->flength + pgof, PROT_READ, MAP_PRIVATE,
 101                                 ar->fd, idx_ptr->foffset - pgof
 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[pgof];
 112
 113                         member->mmap   = memberdata;
 114                         member->mlen   = idx_ptr->flength + pgof;
 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         uint32_t i;
 180         uint32_t j;
 181         uint32_t seg = 1;
 182         uint32_t len = 0;
 183         uint32_t pln = 0;
 184         struct stat s;
 185         LAR_FNAME(buffer);
 186
 187         if( path )
 188         {
 189                 for( pln = 0; path[pln] != '\0'; pln++ )
 190                         if( pln >= (sizeof(buffer) - 5) )
 191                                 LAR_DIE("Library path exceeds maximum allowed length");
 192
 193                 memcpy(buffer, path, pln);
 194         }
 195
 196         for( len = 0; package[len] != '\0'; len++ )
 197         {
 198                 if( len >= (sizeof(buffer) - 5 - pln) )
 199                         LAR_DIE("Package name exceeds maximum allowed length");
 200
 201                 if( package[len] == '.' ) seg++;
 202         }
 203
 204         while( seg > 0 )
 205         {
 206                 for( i = 0, j = 1; (i < len) && (j <= seg); i++ )
 207                 {
 208                         if( package[i] == '.' ) {
 209                                 if( j < seg ) j++; else break;
 210                         }
 211
 212                         buffer[pln+i] = ( package[i] == '.' ) ? LAR_DIRSEP : package[i];
 213                 }
 214
 215                 strcpy(&buffer[pln+i], ".lar");
 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         strcpy(&buffer[len], ".lua");
 240
 241         return lar_open_member(ar, buffer);
 242 }