1 /* exif-mnote-data-canon.c
3 * Copyright (c) 2002, 2003 Lutz Mueller <lutz@users.sourceforge.net>
4 * Copyright (c) 2003 Matthieu Castet <mat-c@users.sourceforge.net>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 * Boston, MA 02110-1301 USA.
23 #include "exif-mnote-data-canon.h"
29 #include <libexif/exif-byte-order.h>
30 #include <libexif/exif-utils.h>
31 #include <libexif/exif-data.h>
33 #define CHECKOVERFLOW(offset,datasize,structsize) (( offset >= datasize) || (structsize > datasize) || (offset > datasize - structsize ))
36 exif_mnote_data_canon_clear (ExifMnoteDataCanon *n)
38 ExifMnoteData *d = (ExifMnoteData *) n;
44 for (i = 0; i < n->count; i++)
45 if (n->entries[i].data) {
46 exif_mem_free (d->mem, n->entries[i].data);
47 n->entries[i].data = NULL;
49 exif_mem_free (d->mem, n->entries);
56 exif_mnote_data_canon_free (ExifMnoteData *n)
60 exif_mnote_data_canon_clear ((ExifMnoteDataCanon *) n);
64 exif_mnote_data_canon_get_tags (ExifMnoteDataCanon *dc, unsigned int n,
65 unsigned int *m, unsigned int *s)
67 unsigned int from = 0, to;
69 if (!dc || !m) return;
70 for (*m = 0; *m < dc->count; (*m)++) {
71 to = from + mnote_canon_entry_count_values (&dc->entries[*m]);
81 exif_mnote_data_canon_get_value (ExifMnoteData *note, unsigned int n, char *val, unsigned int maxlen)
83 ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) note;
87 exif_mnote_data_canon_get_tags (dc, n, &m, &s);
88 if (m >= dc->count) return NULL;
89 return mnote_canon_entry_get_value (&dc->entries[m], s, val, maxlen);
93 exif_mnote_data_canon_set_byte_order (ExifMnoteData *d, ExifByteOrder o)
96 ExifMnoteDataCanon *n = (ExifMnoteDataCanon *) d;
103 for (i = 0; i < n->count; i++) {
104 if (n->entries[i].components && (n->entries[i].size/n->entries[i].components < exif_format_get_size (n->entries[i].format)))
106 n->entries[i].order = o;
107 exif_array_set_byte_order (n->entries[i].format, n->entries[i].data,
108 n->entries[i].components, o_orig, o);
113 exif_mnote_data_canon_set_offset (ExifMnoteData *n, unsigned int o)
115 if (n) ((ExifMnoteDataCanon *) n)->offset = o;
119 exif_mnote_data_canon_save (ExifMnoteData *ne,
120 unsigned char **buf, unsigned int *buf_size)
122 ExifMnoteDataCanon *n = (ExifMnoteDataCanon *) ne;
123 size_t i, o, s, doff;
127 if (!n || !buf || !buf_size) return;
130 * Allocate enough memory for all entries and the number
133 *buf_size = 2 + n->count * 12 + 4;
134 *buf = exif_mem_alloc (ne->mem, sizeof (char) * *buf_size);
136 EXIF_LOG_NO_MEMORY(ne->log, "ExifMnoteCanon", *buf_size);
140 /* Save the number of entries */
141 exif_set_short (*buf, n->order, (ExifShort) n->count);
143 /* Save each entry */
144 for (i = 0; i < n->count; i++) {
146 exif_set_short (*buf + o + 0, n->order, (ExifShort) n->entries[i].tag);
147 exif_set_short (*buf + o + 2, n->order, (ExifShort) n->entries[i].format);
148 exif_set_long (*buf + o + 4, n->order,
149 n->entries[i].components);
151 s = exif_format_get_size (n->entries[i].format) *
152 n->entries[i].components;
154 /* Corrupt data: EXIF data size is limited to the
155 * maximum size of a JPEG segment (64 kb).
162 /* Ensure even offsets. Set padding bytes to 0. */
164 t = exif_mem_realloc (ne->mem, *buf,
167 EXIF_LOG_NO_MEMORY(ne->log, "ExifMnoteCanon", ts);
172 doff = *buf_size - s;
173 if (s & 1) { doff--; *(*buf + *buf_size - 1) = '\0'; }
174 exif_set_long (*buf + o, n->order, n->offset + doff);
179 * Write the data. Fill unneeded bytes with 0. Do not
180 * crash if data is NULL.
182 if (!n->entries[i].data) memset (*buf + doff, 0, s);
183 else memcpy (*buf + doff, n->entries[i].data, s);
184 if (s < 4) memset (*buf + doff + s, 0, (4 - s));
189 * FIXME: exif_mnote_data_canon_load() may fail and there is no
190 * semantics to express that.
191 * See bug #1054323 for details, especially the comment by liblit
192 * after it has supposedly been fixed:
194 * https://sourceforge.net/tracker/?func=detail&aid=1054323&group_id=12272&atid=112272
195 * Unfortunately, the "return" statements aren't commented at
196 * all, so it isn't trivial to find out what is a normal
197 * return, and what is a reaction to an error condition.
201 exif_mnote_data_canon_load (ExifMnoteData *ne,
202 const unsigned char *buf, unsigned int buf_size)
204 ExifMnoteDataCanon *n = (ExifMnoteDataCanon *) ne;
206 size_t i, tcount, o, datao;
208 if (!n || !buf || !buf_size) {
209 exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
210 "ExifMnoteCanon", "Short MakerNote");
213 datao = 6 + n->offset;
214 if (CHECKOVERFLOW(datao, buf_size, 2)) {
215 exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
216 "ExifMnoteCanon", "Short MakerNote");
220 /* Read the number of tags */
221 c = exif_get_short (buf + datao, n->order);
224 /* Remove any old entries */
225 exif_mnote_data_canon_clear (n);
227 /* Reserve enough space for all the possible MakerNote tags */
228 n->entries = exif_mem_alloc (ne->mem, sizeof (MnoteCanonEntry) * c);
230 EXIF_LOG_NO_MEMORY(ne->log, "ExifMnoteCanon", sizeof (MnoteCanonEntry) * c);
234 /* Parse the entries */
236 for (i = c, o = datao; i; --i, o += 12) {
239 memset(&n->entries[tcount], 0, sizeof(MnoteCanonEntry));
240 if (CHECKOVERFLOW(o,buf_size,12)) {
241 exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
242 "ExifMnoteCanon", "Short MakerNote");
246 n->entries[tcount].tag = exif_get_short (buf + o, n->order);
247 n->entries[tcount].format = exif_get_short (buf + o + 2, n->order);
248 n->entries[tcount].components = exif_get_long (buf + o + 4, n->order);
249 n->entries[tcount].order = n->order;
251 exif_log (ne->log, EXIF_LOG_CODE_DEBUG, "ExifMnoteCanon",
252 "Loading entry 0x%x ('%s')...", n->entries[tcount].tag,
253 mnote_canon_tag_get_name (n->entries[tcount].tag));
255 /* Check if we overflow the multiplication. Use buf_size as the max size for integer overflow detection,
256 * we will check the buffer sizes closer later. */
257 if ( exif_format_get_size (n->entries[tcount].format) &&
258 buf_size / exif_format_get_size (n->entries[tcount].format) < n->entries[tcount].components
260 exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
261 "ExifMnoteCanon", "Tag size overflow detected (%u * %lu)", exif_format_get_size (n->entries[tcount].format), n->entries[tcount].components);
266 * Size? If bigger than 4 bytes, the actual data is not
267 * in the entry but somewhere else (offset).
269 s = exif_format_get_size (n->entries[tcount].format) *
270 n->entries[tcount].components;
271 n->entries[tcount].size = s;
273 exif_log (ne->log, EXIF_LOG_CODE_CORRUPT_DATA,
275 "Invalid zero-length tag size");
279 size_t dataofs = o + 8;
280 if (s > 4) dataofs = exif_get_long (buf + dataofs, n->order) + 6;
282 if (CHECKOVERFLOW(dataofs, buf_size, s)) {
283 exif_log (ne->log, EXIF_LOG_CODE_DEBUG,
285 "Tag data past end of buffer (%u > %u)",
286 (unsigned)(dataofs + s), buf_size);
290 n->entries[tcount].data = exif_mem_alloc (ne->mem, s);
291 if (!n->entries[tcount].data) {
292 EXIF_LOG_NO_MEMORY(ne->log, "ExifMnoteCanon", s);
295 memcpy (n->entries[tcount].data, buf + dataofs, s);
298 /* Tag was successfully parsed */
301 /* Store the count of successfully parsed tags */
306 exif_mnote_data_canon_count (ExifMnoteData *n)
308 ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) n;
311 for (i = c = 0; dc && (i < dc->count); i++)
312 c += mnote_canon_entry_count_values (&dc->entries[i]);
317 exif_mnote_data_canon_get_id (ExifMnoteData *d, unsigned int i)
319 ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) d;
323 exif_mnote_data_canon_get_tags (dc, i, &m, NULL);
324 if (m >= dc->count) return 0;
325 return dc->entries[m].tag;
329 exif_mnote_data_canon_get_name (ExifMnoteData *note, unsigned int i)
331 ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) note;
334 if (!dc) return NULL;
335 exif_mnote_data_canon_get_tags (dc, i, &m, &s);
336 if (m >= dc->count) return NULL;
337 return mnote_canon_tag_get_name_sub (dc->entries[m].tag, s, dc->options);
341 exif_mnote_data_canon_get_title (ExifMnoteData *note, unsigned int i)
343 ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) note;
346 if (!dc) return NULL;
347 exif_mnote_data_canon_get_tags (dc, i, &m, &s);
348 if (m >= dc->count) return NULL;
349 return mnote_canon_tag_get_title_sub (dc->entries[m].tag, s, dc->options);
353 exif_mnote_data_canon_get_description (ExifMnoteData *note, unsigned int i)
355 ExifMnoteDataCanon *dc = (ExifMnoteDataCanon *) note;
358 if (!dc) return NULL;
359 exif_mnote_data_canon_get_tags (dc, i, &m, NULL);
360 if (m >= dc->count) return NULL;
361 return mnote_canon_tag_get_description (dc->entries[m].tag);
365 exif_mnote_data_canon_identify (const ExifData *ed, const ExifEntry *e)
369 (void) e; /* unused */
370 ExifEntry *em = exif_data_get_entry (ed, EXIF_TAG_MAKE);
373 return !strcmp (exif_entry_get_value (em, value, sizeof (value)), "Canon");
377 exif_mnote_data_canon_new (ExifMem *mem, ExifDataOption o)
380 ExifMnoteDataCanon *dc;
382 if (!mem) return NULL;
384 d = exif_mem_alloc (mem, sizeof (ExifMnoteDataCanon));
388 exif_mnote_data_construct (d, mem);
390 /* Set up function pointers */
391 d->methods.free = exif_mnote_data_canon_free;
392 d->methods.set_byte_order = exif_mnote_data_canon_set_byte_order;
393 d->methods.set_offset = exif_mnote_data_canon_set_offset;
394 d->methods.load = exif_mnote_data_canon_load;
395 d->methods.save = exif_mnote_data_canon_save;
396 d->methods.count = exif_mnote_data_canon_count;
397 d->methods.get_id = exif_mnote_data_canon_get_id;
398 d->methods.get_name = exif_mnote_data_canon_get_name;
399 d->methods.get_title = exif_mnote_data_canon_get_title;
400 d->methods.get_description = exif_mnote_data_canon_get_description;
401 d->methods.get_value = exif_mnote_data_canon_get_value;
403 dc = (ExifMnoteDataCanon*)d;