applications/luci-upnp: add a note that up and download speeds are informational...
[project/luci.git] / contrib / lar / lar.c
1 /*
2  * lar - Lua Archive Library
3  *
4  *   Copyright (C) 2009 Jo-Philipp Wich <xm@subsignal.org>
5  *
6  *  Licensed under the Apache License, Version 2.0 (the "License");
7  *  you may not use this file except in compliance with the License.
8  *  You may obtain a copy of the License at
9  *
10  *      http://www.apache.org/licenses/LICENSE-2.0
11  *
12  *  Unless required by applicable law or agreed to in writing, software
13  *  distributed under the License is distributed on an "AS IS" BASIS,
14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  *  See the License for the specific language governing permissions and
16  *  limitations under the License.
17  */
18
19
20 #include "lar.h"
21
22 static int lar_read32( int fd, uint32_t *val )
23 {
24         uint8_t buffer[5];
25
26         if( read(fd, buffer, 4) < 4 )
27                 LAR_DIE("Unexpected EOF while reading data");
28
29         buffer[4] = 0;
30         *val = ntohl(*((uint32_t *) buffer));
31
32         return 0;
33 }
34
35 static int lar_read16( int fd, uint16_t *val )
36 {
37         uint8_t buffer[3];
38
39         if( read(fd, buffer, 2) < 2 )
40                 LAR_DIE("Unexpected EOF while reading data");
41
42         buffer[2] = 0;
43         *val = ntohs(*((uint16_t *) buffer));
44
45         return 0;
46 }
47
48 static void lar_md5( char *md5, const char *data, int len )
49 {
50         md5_state_t state;
51
52         md5_init(&state);
53         md5_append(&state, (const md5_byte_t *)data, len);
54         md5_finish(&state, (md5_byte_t *)md5);
55 }
56
57 static int lar_read_filenames( lar_archive *ar )
58 {
59         int i;
60         int j;
61         char *filelist;
62         size_t pgof;
63         size_t pgsz = getpagesize();
64         lar_index *idx_ptr;
65         lar_index *idx_filelist = ar->index;
66
67         while(idx_filelist)
68         {
69                 if( idx_filelist->type == LAR_TYPE_FILELIST )
70                         break;
71
72                 idx_filelist = idx_filelist->next;
73         }
74
75         if( idx_filelist != NULL )
76         {
77                 pgof = ( idx_filelist->offset % pgsz );
78
79                 filelist = mmap(
80                         0, idx_filelist->length + pgof, PROT_READ, MAP_PRIVATE,
81                         ar->fd, idx_filelist->offset - pgof
82                 );
83
84                 if( filelist == MAP_FAILED )
85                         LAR_DIE("Failed to mmap() file list");
86
87
88                 idx_ptr = ar->index;
89                 i = pgof;
90
91                 while(idx_ptr)
92                 {
93                         if( idx_ptr->type == LAR_TYPE_REGULAR )
94                         {
95                                 j = strlen(&filelist[i]) + 1;
96
97                                 if( (j >= LAR_FNAME_BUFFER) ||
98                                     ((i+j) > (idx_filelist->length+pgof)) )
99                                                 LAR_DIE("Filename exceeds maximum allowed length");
100
101                                 idx_ptr->filename = (char *)malloc(j);
102                                 memcpy(idx_ptr->filename, &filelist[i], j);
103
104                                 i += j;
105                         }
106
107                         idx_ptr = idx_ptr->next;
108                 }
109
110                 munmap(filelist, idx_filelist->length + pgof);
111
112                 return 1;
113         }
114
115         return 0;
116 }
117
118 lar_index * lar_get_index( lar_archive *ar )
119 {
120         uint32_t i;
121         uint32_t idx_offset;
122         uint32_t idx_length;
123         lar_index *idx_map;
124         lar_index *idx_ptr;
125
126         if( lseek(ar->fd, -(sizeof(idx_offset)), SEEK_END) == -1 )
127                 LAR_DIE("Unable to seek to end of archive");
128
129         lar_read32(ar->fd, &idx_offset);
130         idx_length = ( ar->length - idx_offset - sizeof(idx_offset) );
131
132         if( lseek(ar->fd, idx_offset, SEEK_SET) == -1 )
133                 LAR_DIE("Unable to seek to archive index");
134
135
136         idx_map = NULL;
137
138         for( i = 0; i < idx_length; i += (sizeof(lar_index) - 2 * sizeof(char *)) )
139         {
140                 idx_ptr = (lar_index *)malloc(sizeof(lar_index));
141                 idx_ptr->filename = NULL;
142
143                 lar_read32(ar->fd, &idx_ptr->offset);
144                 lar_read32(ar->fd, &idx_ptr->length);
145                 lar_read16(ar->fd, &idx_ptr->type);
146                 lar_read16(ar->fd, &idx_ptr->flags);
147
148                 if(read(ar->fd,&idx_ptr->id,sizeof(idx_ptr->id)) < sizeof(idx_ptr->id))
149                         LAR_DIE("Unexpected EOF while reading member id");
150
151                 idx_ptr->next = idx_map;
152                 idx_map = idx_ptr;
153         }
154
155         return idx_map;
156 }
157
158 lar_member * lar_mmap_member( lar_archive *ar, lar_index *idx_ptr )
159 {
160         lar_member *member;
161         size_t pgsz = getpagesize();
162         size_t pgof = ( idx_ptr->offset % pgsz );
163
164         char *memberdata = mmap(
165                 0, idx_ptr->length + pgof, PROT_READ, MAP_PRIVATE,
166                 ar->fd, idx_ptr->offset - pgof
167         );
168
169         if( memberdata == MAP_FAILED )
170                 LAR_DIE("Failed to mmap() member data");
171
172         member = (lar_member *)malloc(sizeof(lar_member));
173         member->type   = idx_ptr->type;
174         member->flags  = idx_ptr->flags;
175         member->length = idx_ptr->length;
176         member->data   = &memberdata[pgof];
177
178         member->mmap   = memberdata;
179         member->mlen   = idx_ptr->length + pgof;
180
181         return member;
182 }
183
184 lar_member * lar_open_member( lar_archive *ar, const char *name )
185 {
186         lar_index *idx_ptr = ar->index;
187         char mbid[sizeof(idx_ptr->id)];
188
189         lar_md5(mbid, name, strlen(name));
190
191         while(idx_ptr)
192         {
193                 if( !strncmp(mbid, idx_ptr->id, sizeof(mbid)) )
194                         return lar_mmap_member(ar, idx_ptr);
195
196                 idx_ptr = idx_ptr->next;
197         }
198
199         return NULL;
200 }
201
202 int lar_close_member( lar_member *member )
203 {
204         int stat = munmap(member->mmap, member->mlen);
205         free(member);
206         member = NULL;
207
208         return stat;
209 }
210
211 lar_archive * lar_open( const char *filename )
212 {
213         int fd;
214         struct stat as;
215         lar_archive *ar;
216
217         if( stat(filename, &as) == -1 )
218                 return NULL;
219
220         if( !(as.st_mode & S_IFREG) )
221                 return NULL;
222
223         if( (fd = open(filename, O_RDONLY)) != -1 )
224         {
225                 ar = (lar_archive *)malloc(sizeof(lar_archive));
226                 ar->fd       = fd;
227                 ar->length   = as.st_size;
228                 ar->index    = lar_get_index(ar);
229                 strncpy(ar->filename, filename, sizeof(ar->filename));
230
231                 ar->has_filenames = lar_read_filenames(ar);
232
233                 return ar;
234         }
235
236         return NULL;
237 }
238
239 int lar_close( lar_archive *ar )
240 {
241         lar_index *idx_head;
242         lar_index *idx_next;
243
244         close(ar->fd);
245
246         idx_head = ar->index;
247         do {
248                 idx_next = idx_head->next;
249                 free(idx_head->filename);
250                 free(idx_head);
251         } while( (idx_head = idx_next) != NULL );
252
253         free(ar);
254         ar = NULL;
255
256         return 0;
257 }
258
259 lar_archive * lar_find_archive( const char *package, const char *path, int pkg )
260 {
261         uint32_t i;
262         uint32_t j;
263         uint32_t seg = 1;
264         uint32_t len = 0;
265         uint32_t pln = 0;
266         char sep = ( pkg ? '.' : '/' );
267         struct stat s;
268         LAR_FNAME(buffer);
269
270         if( path )
271         {
272                 for( pln = 0; path[pln] != '\0'; pln++ )
273                         if( pln >= (sizeof(buffer) - 5) )
274                                 LAR_DIE("Library path exceeds maximum allowed length");
275
276                 memcpy(buffer, path, pln);
277         }
278
279         if( buffer[pln-1] != '/' )
280                 buffer[pln++] = '/';
281
282         for( len = 0; package[len] != '\0'; len++ )
283         {
284                 if( len >= (sizeof(buffer) - 5 - pln) )
285                         LAR_DIE("Package name exceeds maximum allowed length");
286
287                 if( package[len] == sep ) seg++;
288         }
289
290         while( seg > 0 )
291         {
292                 for( i = 0, j = 1; (i < len) && (j <= seg); i++ )
293                 {
294                         if( package[i] == sep ) {
295                                 if( j < seg ) j++; else break;
296                         }
297
298                         buffer[pln+i] = ( package[i] == sep ) ? LAR_DIRSEP : package[i];
299                 }
300
301                 strcpy(&buffer[pln+i], ".lar");
302
303                 if( (stat(buffer, &s) > -1) && (s.st_mode & S_IFREG) )
304                         return lar_open(buffer);
305
306                 seg--;
307         }
308
309         return NULL;
310 }
311
312 lar_member * lar_find_member( lar_archive *ar, const char *package )
313 {
314         int len;
315         LAR_FNAME(buffer);
316
317         for( len = 0; package[len] != '\0'; len++ )
318         {
319                 if( len >= (sizeof(buffer) - 5) )
320                         LAR_DIE("Package name exceeds maximum allowed length");
321
322                 buffer[len] = ( package[len] == '.' ) ? '/' : package[len];
323         }
324
325         strcpy(&buffer[len], ".lua");
326
327         return lar_open_member(ar, buffer);
328 }