![Guy Harris](/assets/img/avatar_default.png)
Otherwise, if you link with both libwiretap and libfiletap, it's anybody's guess which one you get. That means you're wasting memory with two copies of its routines if they're identical, and means surprising behavior if they're not (which showed up when I was debugging a double-free crash - fixing libwiretap's buffer_free() didn't fix the problem, because Wireshark happened to be calling libfiletap' unfixed buffer_free()). There's nothing *tap-specific about Buffers, anyway, so it really belongs in wsutil. Change-Id: I91537e46917e91277981f8f3365a2c0873152870 Reviewed-on: https://code.wireshark.org/review/3066 Reviewed-by: Guy Harris <guy@alum.mit.edu>
306 lines
7.2 KiB
C
306 lines
7.2 KiB
C
/* mpeg.c
|
|
*
|
|
* MPEG file format decoder for the Wiretap library.
|
|
* Written by Shaun Jackman <sjackman@gmail.com>
|
|
* Copyright 2007 Shaun Jackman
|
|
*
|
|
* Wiretap Library
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#ifdef HAVE_SYS_TYPES_H
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include "mpeg.h"
|
|
#include "wsutil/mpeg-audio.h"
|
|
|
|
#include "wtap-int.h"
|
|
#include <wsutil/buffer.h>
|
|
#include "file_wrappers.h"
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#define PES_PREFIX 1
|
|
#define PES_VALID(n) (((n) >> 8 & 0xffffff) == PES_PREFIX)
|
|
|
|
typedef struct {
|
|
nstime_t now;
|
|
time_t t0;
|
|
} mpeg_t;
|
|
|
|
static int
|
|
mpeg_resync(FILE_T fh, int *err)
|
|
{
|
|
gint64 offset = file_tell(fh);
|
|
int count = 0;
|
|
int byte = file_getc(fh);
|
|
|
|
while (byte != EOF) {
|
|
if (byte == 0xff && count > 0) {
|
|
byte = file_getc(fh);
|
|
if (byte != EOF && (byte & 0xe0) == 0xe0)
|
|
break;
|
|
} else
|
|
byte = file_getc(fh);
|
|
count++;
|
|
}
|
|
if (file_seek(fh, offset, SEEK_SET, err) == -1)
|
|
return 0;
|
|
return count;
|
|
}
|
|
|
|
static int
|
|
mpeg_read_header(FILE_T fh, int *err, gchar **err_info, guint32 *n)
|
|
{
|
|
int bytes_read;
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
bytes_read = file_read(n, sizeof *n, fh);
|
|
if (bytes_read != sizeof *n) {
|
|
*err = file_error(fh, err_info);
|
|
if (*err == 0 && bytes_read != 0)
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
return -1;
|
|
}
|
|
*n = g_ntohl(*n);
|
|
if (file_seek(fh, -(gint64)(sizeof *n), SEEK_CUR, err) == -1)
|
|
return -1;
|
|
return bytes_read;
|
|
}
|
|
|
|
#define SCRHZ 27000000
|
|
|
|
static gboolean
|
|
mpeg_read_packet(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
|
|
gboolean is_random, int *err, gchar **err_info)
|
|
{
|
|
mpeg_t *mpeg = (mpeg_t *)wth->priv;
|
|
guint32 n;
|
|
int bytes_read;
|
|
unsigned int packet_size;
|
|
nstime_t ts = mpeg->now;
|
|
|
|
bytes_read = mpeg_read_header(fh, err, err_info, &n);
|
|
if (bytes_read == -1)
|
|
return FALSE;
|
|
if (PES_VALID(n)) {
|
|
gint64 offset = file_tell(fh);
|
|
guint8 stream;
|
|
|
|
if (file_seek(fh, 3, SEEK_CUR, err) == -1)
|
|
return FALSE;
|
|
|
|
bytes_read = file_read(&stream, sizeof stream, fh);
|
|
if (bytes_read != sizeof stream) {
|
|
*err = file_error(fh, err_info);
|
|
return FALSE;
|
|
}
|
|
|
|
if (stream == 0xba) {
|
|
guint32 pack1;
|
|
guint32 pack0;
|
|
guint64 pack;
|
|
guint8 stuffing;
|
|
|
|
bytes_read = file_read(&pack1, sizeof pack1, fh);
|
|
if (bytes_read != sizeof pack1) {
|
|
*err = file_error(fh, err_info);
|
|
if (*err == 0 && bytes_read != 0)
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
return FALSE;
|
|
}
|
|
bytes_read = file_read(&pack0, sizeof pack0, fh);
|
|
if (bytes_read != sizeof pack0) {
|
|
*err = file_error(fh, err_info);
|
|
if (*err == 0 && bytes_read != 0)
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
return FALSE;
|
|
}
|
|
pack = (guint64)g_ntohl(pack1) << 32 | g_ntohl(pack0);
|
|
|
|
switch (pack >> 62) {
|
|
case 1:
|
|
if (file_seek(fh, 1, SEEK_CUR, err) == -1)
|
|
return FALSE;
|
|
bytes_read = file_read(&stuffing,
|
|
sizeof stuffing, fh);
|
|
if (bytes_read != sizeof stuffing) {
|
|
*err = file_error(fh, err_info);
|
|
return FALSE;
|
|
}
|
|
stuffing &= 0x07;
|
|
packet_size = 14 + stuffing;
|
|
|
|
if (!is_random) {
|
|
guint64 bytes = pack >> 16;
|
|
guint64 ts_val =
|
|
(bytes >> 43 & 0x0007) << 30 |
|
|
(bytes >> 27 & 0x7fff) << 15 |
|
|
(bytes >> 11 & 0x7fff) << 0;
|
|
guint ext = (guint)((bytes >> 1) & 0x1ff);
|
|
guint64 cr = 300 * ts_val + ext;
|
|
guint rem = (guint)(cr % SCRHZ);
|
|
mpeg->now.secs
|
|
= mpeg->t0 + (time_t)(cr / SCRHZ);
|
|
mpeg->now.nsecs
|
|
= (int)(G_GINT64_CONSTANT(1000000000) * rem / SCRHZ);
|
|
}
|
|
ts = mpeg->now;
|
|
break;
|
|
default:
|
|
packet_size = 12;
|
|
}
|
|
} else {
|
|
guint16 length;
|
|
bytes_read = file_read(&length, sizeof length, fh);
|
|
if (bytes_read != sizeof length) {
|
|
*err = file_error(fh, err_info);
|
|
if (*err == 0 && bytes_read != 0)
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
return FALSE;
|
|
}
|
|
length = g_ntohs(length);
|
|
packet_size = 6 + length;
|
|
}
|
|
|
|
if (file_seek(fh, offset, SEEK_SET, err) == -1)
|
|
return FALSE;
|
|
} else {
|
|
struct mpa mpa;
|
|
|
|
MPA_UNMARSHAL(&mpa, n);
|
|
if (MPA_VALID(&mpa)) {
|
|
packet_size = MPA_BYTES(&mpa);
|
|
if (!is_random) {
|
|
mpeg->now.nsecs += MPA_DURATION_NS(&mpa);
|
|
if (mpeg->now.nsecs >= 1000000000) {
|
|
mpeg->now.secs++;
|
|
mpeg->now.nsecs -= 1000000000;
|
|
}
|
|
}
|
|
} else {
|
|
packet_size = mpeg_resync(fh, err);
|
|
if (packet_size == 0)
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!wtap_read_packet_bytes(fh, buf, packet_size, err, err_info))
|
|
return FALSE;
|
|
|
|
phdr->rec_type = REC_TYPE_PACKET;
|
|
|
|
/* XXX - relative, not absolute, time stamps */
|
|
if (!is_random) {
|
|
phdr->presence_flags = WTAP_HAS_TS;
|
|
phdr->ts = ts;
|
|
}
|
|
phdr->caplen = packet_size;
|
|
phdr->len = packet_size;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
mpeg_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)
|
|
{
|
|
*data_offset = file_tell(wth->fh);
|
|
|
|
return mpeg_read_packet(wth, wth->fh, &wth->phdr, wth->frame_buffer,
|
|
FALSE, err, err_info);
|
|
}
|
|
|
|
static gboolean
|
|
mpeg_seek_read(wtap *wth, gint64 seek_off,
|
|
struct wtap_pkthdr *phdr, Buffer *buf,
|
|
int *err, gchar **err_info)
|
|
{
|
|
if (file_seek(wth->random_fh, seek_off, SEEK_SET, err) == -1)
|
|
return FALSE;
|
|
|
|
if (!mpeg_read_packet(wth, wth->random_fh, phdr, buf, TRUE, err,
|
|
err_info)) {
|
|
if (*err == 0)
|
|
*err = WTAP_ERR_SHORT_READ;
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
struct _mpeg_magic {
|
|
size_t len;
|
|
const gchar* match;
|
|
} magic[] = {
|
|
{ 3, "TAG" }, /* ID3v1 */
|
|
{ 3, "ID3" }, /* ID3v2 */
|
|
{ 3, "\0\0\1" }, /* MPEG PES */
|
|
{ 2, "\xff\xfb" }, /* MP3, taken from http://en.wikipedia.org/wiki/MP3#File_structure */
|
|
{ 0, NULL }
|
|
};
|
|
|
|
int
|
|
mpeg_open(wtap *wth, int *err, gchar **err_info)
|
|
{
|
|
int bytes_read;
|
|
char magic_buf[16];
|
|
struct _mpeg_magic* m;
|
|
mpeg_t *mpeg;
|
|
|
|
errno = WTAP_ERR_CANT_READ;
|
|
bytes_read = file_read(magic_buf, sizeof magic_buf, wth->fh);
|
|
if (bytes_read != (int) sizeof magic_buf) {
|
|
*err = file_error(wth->fh, err_info);
|
|
if (*err != 0 && *err != WTAP_ERR_SHORT_READ)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
for (m=magic; m->match; m++) {
|
|
if (memcmp(magic_buf, m->match, m->len) == 0)
|
|
goto good_magic;
|
|
}
|
|
|
|
return 0;
|
|
|
|
good_magic:
|
|
/* This appears to be a file with MPEG data. */
|
|
if (file_seek(wth->fh, 0, SEEK_SET, err) == -1)
|
|
return -1;
|
|
|
|
wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_MPEG;
|
|
wth->file_encap = WTAP_ENCAP_MPEG;
|
|
wth->tsprecision = WTAP_FILE_TSPREC_NSEC;
|
|
wth->subtype_read = mpeg_read;
|
|
wth->subtype_seek_read = mpeg_seek_read;
|
|
wth->snapshot_length = 0;
|
|
|
|
mpeg = (mpeg_t *)g_malloc(sizeof(mpeg_t));
|
|
wth->priv = (void *)mpeg;
|
|
mpeg->now.secs = 0;
|
|
mpeg->now.nsecs = 0;
|
|
mpeg->t0 = mpeg->now.secs;
|
|
|
|
return 1;
|
|
}
|