商品编号：
京 东 价：
[定价：￥]
支　　持：
合约套餐：
请选择套餐内容
　您选择的地区暂不支持合约机销售！
综合评分：
细则评分：
公司名称：郑州市千秋期刊杂志销售有限公司
所 在 地：河南 郑州市
在线客服：
服务支持：
收藏杂志/7/8/9/10/11月7本打包中国收藏拍卖全新无封面
加载中，请稍候...
商品介绍加载中...
扫一扫，精彩好书免费看
服务承诺：
京东平台卖家销售并发货的商品，由平台卖家提供发票和相应的售后服务。请您放心购买！
注：因厂家会在没有任何提前通知的情况下更改产品包装、产地或者一些附件，本司不能确保客户收到的货物与商城图片、产地、附件说明完全一致。只能确保为原厂正货！并且保证与当时市场上同样主流新品一致。若本商城没有及时更新，请大家谅解！
权利声明：京东上的所有商品信息、客户评价、商品咨询、网友讨论等内容，是京东重要的经营资源，未经许可，禁止非法转载使用。
注：本站商品信息均来自于合作方，其真实性、准确性和合法性由信息拥有者（合作方）负责。本站不提供任何保证，并不承担任何法律责任。
印刷版次不同，印刷时间和版次以实物为准。
加载中，请稍候...
小小兔啊(福建)
加载中，请稍候...
加载中，请稍候...
加载中，请稍候...
加载中，请稍候...
加载中，请稍候...
加载中，请稍候...
浏览了该商品的用户还浏览了
加载中，请稍候...
iframe(src='///ns.html?id=GTM-T947SH', height='0', width='0', style='display: visibility:')>> ethereal-0.10.9-_-epan-_-tvbuff.c - ethereal是一款非常优秀的网络
点击查看更多 ▼
点击收缩隐藏 ▲
ethereal-0.10.9-_-epan-_-tvbuff.c - ethereal是一款非常优秀的网络
/* tvbuff.c
* Testy, Virtual(-izable) Buffer of guint8*'s
* &Testy& -- the buffer gets mad when an attempt to access data
beyond the bounds of the buffer. An exception is thrown.
* &Virtual& -- the buffer can have its own data, can use a subset of
the data of a backing tvbuff, or can be a composite of
other tvbuffs.
* $Id: tvbuff.c -01-05 10:19:36Z guy $
* Copyright (c) 2000 by Gilbert Ramirez &gram@alumni.rice.edu&
* Code to convert IEEE floating point formats to native floating point
* derived from code Copyright (c) Ashok Narayanan, 2000
* Ethereal - Network traffic analyzer
* By Gerald Combs &&
* Copyright 1998 Gerald Combs
* This prog you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software F 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.
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* alo if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
#ifdef HAVE_CONFIG_H
# include &config.h&
#include &string.h&
#ifdef HAVE_LIBZ
#include &zlib.h&
#include &pint.h&
#include &tvbuff.h&
#include &strutil.h&
static const guint8*
ensure_contiguous_no_exception(tvbuff_t *tvb, gint offset, gint length,
int *exception);
static const guint8*
ensure_contiguous(tvbuff_t *tvb, gint offset, gint length);
/* We dole out tvbuff's from this memchunk. */
GMemChunk *tvbuff_mem_chunk = NULL;
tvbuff_init(void)
if (!tvbuff_mem_chunk)
tvbuff_mem_chunk = g_mem_chunk_create(tvbuff_t, 20, G_ALLOC_AND_FREE);
tvbuff_cleanup(void)
if (tvbuff_mem_chunk)
g_mem_chunk_destroy(tvbuff_mem_chunk);
tvbuff_mem_chunk = NULL;
static void
tvb_init(tvbuff_t *tvb, tvbuff_type type)
tvb_backing_t *
tvb_comp_t *
tvb-&initialized = FALSE;
tvb-&usage_count = 1;
tvb-&length
tvb-&reported_length = 0;
tvb-&free_cb
tvb-&real_data
tvb-&raw_offset
tvb-&used_in
tvb-&ds_tvb
switch(type) {
case TVBUFF_REAL_DATA:
/* Nothing */
case TVBUFF_SUBSET:
backing = &tvb-&tvbuffs.
backing-&tvb = NULL;
backing-&offset = 0;
backing-&length = 0;
case TVBUFF_COMPOSITE:
composite = &tvb-&
composite-&tvbs
composite-&start_offsets = NULL;
composite-&end_offsets
tvb_new(tvbuff_type type)
tvbuff_t *
tvb = g_chunk_new(tvbuff_t, tvbuff_mem_chunk);
g_assert(tvb);
tvb_init(tvb, type);
tvb_free(tvbuff_t* tvb)
tvbuff_t *member_
tvb_comp_t *
tvb-&usage_count--;
if (tvb-&usage_count == 0) {
switch (tvb-&type) {
case TVBUFF_REAL_DATA:
if (tvb-&free_cb) {
* XXX - do this with a union?
tvb-&free_cb((gpointer)tvb-&real_data);
case TVBUFF_SUBSET:
/* This will be NULL if tvb_new_subset() fails because
* reported_length & -1 */
if (tvb-&tvbuffs.subset.tvb) {
tvb_decrement_usage_count(tvb-&tvbuffs.subset.tvb, 1);
case TVBUFF_COMPOSITE:
composite = &tvb-&
for (slist = composite-& slist != NULL ; slist = slist-&next) {
member_tvb = slist-&
tvb_decrement_usage_count(member_tvb, 1);
g_slist_free(composite-&tvbs);
if (composite-&start_offsets)
g_free(composite-&start_offsets);
if (composite-&end_offsets)
g_free(composite-&end_offsets);
if (tvb-&real_data) {
* XXX - do this with a union?
g_free((gpointer)tvb-&real_data);
if (tvb-&used_in) {
g_slist_free(tvb-&used_in);
g_chunk_free(tvb, tvbuff_mem_chunk);
tvb_increment_usage_count(tvbuff_t* tvb, guint count)
tvb-&usage_count +=
return tvb-&usage_
tvb_decrement_usage_count(tvbuff_t* tvb, guint count)
if (tvb-&usage_count &= count) {
tvb-&usage_count = 1;
tvb_free(tvb);
tvb-&usage_count -=
return tvb-&usage_
tvb_free_chain(tvbuff_t* tvb)
/* Recursively call tvb_free_chain() */
for (slist = tvb-&used_ slist != NULL ; slist = slist-&next) {
tvb_free_chain( (tvbuff_t*)slist-&data );
/* Stop the recursion */
tvb_free(tvb);
tvb_set_free_cb(tvbuff_t* tvb, tvbuff_free_cb_t func)
g_assert(tvb-&type == TVBUFF_REAL_DATA);
tvb-&free_cb =
static void
add_to_used_in_list(tvbuff_t *tvb, tvbuff_t *used_in)
tvb-&used_in = g_slist_prepend(tvb-&used_in, used_in);
tvb_increment_usage_count(tvb, 1);
tvb_set_child_real_data_tvbuff(tvbuff_t* parent, tvbuff_t* child)
g_assert(parent-&initialized);
g_assert(child-&initialized);
g_assert(child-&type == TVBUFF_REAL_DATA);
add_to_used_in_list(parent, child);
tvb_set_real_data(tvbuff_t* tvb, const guint8* data, guint length, gint reported_length)
g_assert(tvb-&type == TVBUFF_REAL_DATA);
g_assert(!tvb-&initialized);
if (reported_length & -1) {
THROW(ReportedBoundsError);
tvb-&real_data
tvb-&length
tvb-&reported_length = reported_
tvb-&initialized = TRUE;
tvb_new_real_data(const guint8* data, guint length, gint reported_length)
static tvbuff_t *last_tvb=NULL;
tvbuff_t *
tvb = tvb_new(TVBUFF_REAL_DATA);
if(last_tvb){
tvb_free(last_tvb);
/* remember this tvb in case we throw an exception and
* lose the pointer to it.
tvb_set_real_data(tvb, data, length, reported_length);
* This is the top-level real tvbuff for this data source,
* so its data source tvbuff is itself.
tvb-&ds_tvb =
/* ok no exception so we dont need to remember it any longer */
last_tvb=NULL;
/* Computes the absolute offset and length based on a possibly-negative offset
* and a length that is possible -1 (which means &to the end of the data&).
* Returns TRUE/FALSE indicating whether the offset is in bounds or
* not. The integer ptrs are modified with the new offset and length.
* No exception is thrown.
* XXX - we return TRUE, not FALSE, if the offset is positive and right
* after the end of the tvbuff (i.e., equal to the length).
We do this
* so that a dissector constructing a subset tvbuff for the next protocol
* will get a zero-length tvbuff, not an exception, if there's no data
* left for the next protocol - we want the next protocol to be the one
* that gets an exception, so the error is reported as an error in that
* protocol rather than the containing protocol.
static gboolean
compute_offset_length(tvbuff_t *tvb, gint offset, gint length,
guint *offset_ptr, guint *length_ptr, int *exception)
g_assert(offset_ptr);
g_assert(length_ptr);
/* Compute the offset */
if (offset &= 0) {
/* Positive offset - relative to the beginning of the packet. */
if ((guint) offset & tvb-&reported_length) {
if (exception) {
*exception = ReportedBoundsE
return FALSE;
else if ((guint) offset & tvb-&length) {
if (exception) {
*exception = BoundsE
return FALSE;
*offset_ptr =
/* Negative offset - relative to the end of the packet. */
if ((guint) -offset & tvb-&reported_length) {
if (exception) {
*exception = ReportedBoundsE
return FALSE;
else if ((guint) -offset & tvb-&length) {
if (exception) {
*exception = BoundsE
return FALSE;
*offset_ptr = tvb-&length +
/* Compute the length */
if (length & -1) {
if (exception) {
/* XXX - ReportedBoundsError? */
*exception = BoundsE
return FALSE;
else if (length == -1) {
*length_ptr = tvb-&length - *offset_
*length_ptr =
return TRUE;
static gboolean
check_offset_length_no_exception(tvbuff_t *tvb, gint offset, gint length,
guint *offset_ptr, guint *length_ptr, int *exception)
guint end_
g_assert(tvb-&initialized);
if (!compute_offset_length(tvb, offset, length, offset_ptr, length_ptr, exception)) {
return FALSE;
* Compute the offset of the first byte past the length.
end_offset = *offset_ptr + *length_
* Check for an overflow, and clamp &end_offset& at the maximum
* if we got an overflow - that should force us to indicate that
* we're past the end of the tvbuff.
if (end_offset & *offset_ptr)
end_offset = UINT_MAX;
* Check whether that offset goes more than one byte past the
* end of the buffer.
* If not, return TRUE; otherwise, return FALSE and, if &exception&
* is non-null, return the appropriate exception through it.
if (end_offset &= tvb-&length) {
return TRUE;
else if (end_offset &= tvb-&reported_length) {
if (exception) {
*exception = BoundsE
return FALSE;
if (exception) {
*exception = ReportedBoundsE
return FALSE;
g_assert_not_reached();
/* Checks (+/-) offset and length and throws an exception if
* either is out of bounds. Sets integer ptrs to the new offset
* and length. */
static void
check_offset_length(tvbuff_t *tvb, gint offset, gint length,
guint *offset_ptr, guint *length_ptr)
int exception = 0;
if (!check_offset_length_no_exception(tvb, offset, length, offset_ptr, length_ptr, &exception)) {
g_assert(exception & 0);
THROW(exception);
tvb_set_subset(tvbuff_t *tvb, tvbuff_t *backing,
gint backing_offset, gint backing_length, gint reported_length)
g_assert(tvb-&type == TVBUFF_SUBSET);
g_assert(!tvb-&initialized);
if (reported_length & -1) {
THROW(ReportedBoundsError);
check_offset_length(backing, backing_offset, backing_length,
&tvb-&tvbuffs.subset.offset,
&tvb-&tvbuffs.subset.length);
tvb-&tvbuffs.subset.tvb
tvb-&length
= tvb-&tvbuffs.subset.
if (reported_length == -1) {
tvb-&reported_length = backing-&reported_length - tvb-&tvbuffs.subset.
tvb-&reported_length = reported_
tvb-&initialized
add_to_used_in_list(backing, tvb);
/* Optimization. If the backing buffer has a pointer to contiguous, real data,
* then we can point directly to our starting offset in that buffer */
if (backing-&real_data != NULL) {
tvb-&real_data = backing-&real_data + tvb-&tvbuffs.subset.
tvb_new_subset(tvbuff_t *backing, gint backing_offset, gint backing_length, gint reported_length)
static tvbuff_t *last_tvb=NULL;
tvbuff_t *
tvb = tvb_new(TVBUFF_SUBSET);
if(last_tvb){
tvb_free(last_tvb);
/* remember this tvb in case we throw an exception and
* lose the pointer to it.
tvb_set_subset(tvb, backing, backing_offset, backing_length, reported_length);
* The top-level data source of this tvbuff is the top-level
* data source of its parent.
tvb-&ds_tvb = backing-&ds_
/* ok no exception so we dont need to remember it any longer */
last_tvb=NULL;
tvb_composite_append(tvbuff_t* tvb, tvbuff_t* member)
tvb_comp_t *
g_assert(!tvb-&initialized);
composite = &tvb-&
composite-&tvbs = g_slist_append( composite-&tvbs, member );
add_to_used_in_list(member, tvb);
tvb_composite_prepend(tvbuff_t* tvb, tvbuff_t* member)
tvb_comp_t *
g_assert(!tvb-&initialized);
composite = &tvb-&
composite-&tvbs = g_slist_prepend( composite-&tvbs, member );
add_to_used_in_list(member, tvb);
tvb_new_composite(void)
return tvb_new(TVBUFF_COMPOSITE);
tvb_composite_finalize(tvbuff_t* tvb)
tvbuff_t *member_
tvb_comp_t *
g_assert(!tvb-&initialized);
g_assert(tvb-&length == 0);
composite = &tvb-&
num_members = g_slist_length(composite-&tvbs);
composite-&start_offsets = g_new(guint, num_members);
composite-&end_offsets = g_new(guint, num_members);
for (slist = composite-& slist != NULL; slist = slist-&next) {
g_assert((guint) i & num_members);
member_tvb = slist-&
composite-&start_offsets[i] = tvb-&
tvb-&length += member_tvb-&
composite-&end_offsets[i] = tvb-&length - 1;
tvb-&initialized = TRUE;
tvb_length(tvbuff_t* tvb)
g_assert(tvb-&initialized);
return tvb-&
tvb_length_remaining(tvbuff_t *tvb, gint offset)
guint abs_offset, abs_
g_assert(tvb-&initialized);
if (compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL)) {
return abs_
return -1;
tvb_ensure_length_remaining(tvbuff_t *tvb, gint offset)
guint abs_offset, abs_
g_assert(tvb-&initialized);
if (!compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, &exception)) {
THROW(exception);
if (abs_length == 0) {
* This routine ensures there's at least one byte available.
* There aren't any bytes available, so throw the appropriate
* exception.
if (abs_offset &= tvb-&reported_length)
THROW(ReportedBoundsError);
THROW(BoundsError);
return abs_
/* Validates that 'length' bytes are available starting from
* offset (pos/neg). Does not throw an exception. */
tvb_bytes_exist(tvbuff_t *tvb, gint offset, gint length)
abs_offset, abs_
g_assert(tvb-&initialized);
if (!compute_offset_length(tvb, offset, length, &abs_offset, &abs_length, NULL))
return FALSE;
if (abs_offset + abs_length &= tvb-&length) {
return TRUE;
return FALSE;
/* Validates that 'length' bytes are available starting from
* offset (pos/neg). Throws an exception if they aren't. */
tvb_ensure_bytes_exist(tvbuff_t *tvb, gint offset, gint length)
abs_offset, abs_
g_assert(tvb-&initialized);
* -1 doesn't mean &until end of buffer&, as that's pointless
* for this routine.
We must treat it as a Really Large Positive
* Number, so that w we throw
* ReportedBoundsError, as if it were past even the end of a
* reassembled packet, and past the end of even the data we
* didn't capture.
* We do the same with other negative lengths.
if (length & 0) {
THROW(ReportedBoundsError);
check_offset_length(tvb, offset, length, &abs_offset, &abs_length);
tvb_offset_exists(tvbuff_t *tvb, gint offset)
abs_offset, abs_
g_assert(tvb-&initialized);
if (!compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL))
return FALSE;
if (abs_offset & tvb-&length) {
return TRUE;
return FALSE;
tvb_reported_length(tvbuff_t* tvb)
g_assert(tvb-&initialized);
return tvb-&reported_
tvb_reported_length_remaining(tvbuff_t *tvb, gint offset)
guint abs_offset, abs_
g_assert(tvb-&initialized);
if (compute_offset_length(tvb, offset, -1, &abs_offset, &abs_length, NULL)) {
if (tvb-&reported_length &= abs_offset)
return tvb-&reported_length - abs_
return -1;
return -1;
/* Set the reported length of a tvb used for protocols
whose headers contain an explicit length and where the calling
dissector's payload may include padding as well as the packet for
this protocol.
Also adjusts the data length. */
tvb_set_reported_length(tvbuff_t* tvb, guint reported_length)
g_assert(tvb-&initialized);
if (reported_length & tvb-&reported_length)
THROW(ReportedBoundsError);
tvb-&reported_length = reported_
if (reported_length & tvb-&length)
tvb-&length = reported_
static const guint8*
first_real_data_ptr(tvbuff_t *tvb)
tvbuff_t *
switch(tvb-&type) {
case TVBUFF_REAL_DATA:
return tvb-&real_
case TVBUFF_SUBSET:
member = tvb-&tvbuffs.subset.
return first_real_data_ptr(member);
case TVBUFF_COMPOSITE:
member = tvb-&posite.tvbs-&
return first_real_data_ptr(member);
g_assert_not_reached();
return NULL;
offset_from_real_beginning(tvbuff_t *tvb, int counter)
tvbuff_t *
switch(tvb-&type) {
case TVBUFF_REAL_DATA:
case TVBUFF_SUBSET:
member = tvb-&tvbuffs.subset.
return offset_from_real_beginning(member, counter + tvb-&tvbuffs.subset.offset);
case TVBUFF_COMPOSITE:
member = tvb-&posite.tvbs-&
return offset_from_real_beginning(member, counter);
g_assert_not_reached();
static const guint8*
composite_ensure_contiguous_no_exception(tvbuff_t *tvb, guint abs_offset,
guint abs_length)
tvb_comp_t *
tvbuff_t *member_tvb = NULL;
member_offset, member_
g_assert(tvb-&type == TVBUFF_COMPOSITE);
/* Maybe the range specified by offset/length
* is contiguous inside one of the member tvbuffs */
composite = &tvb-&
num_members = g_slist_length(composite-&tvbs);
for (i = 0; i & num_ i++) {
if (abs_offset &= composite-&end_offsets[i]) {
slist = g_slist_nth(composite-&tvbs, i);
member_tvb = slist-&
g_assert(member_tvb);
if (check_offset_length_no_exception(member_tvb, abs_offset - composite-&start_offsets[i],
abs_length, &member_offset, &member_length, NULL)) {
* The range is, in fact, contiguous within member_tvb.
g_assert(!tvb-&real_data);
return ensure_contiguous_no_exception(member_tvb, member_offset, member_length, NULL);
tvb-&real_data = tvb_memdup(tvb, 0, -1);
return tvb-&real_data + abs_
g_assert_not_reached();
return NULL;
static const guint8*
ensure_contiguous_no_exception(tvbuff_t *tvb, gint offset, gint length,
int *exception)
guint abs_offset, abs_
if (!check_offset_length_no_exception(tvb, offset, length,
&abs_offset, &abs_length, exception)) {
return NULL;
* We know that all the data is present in the tvbuff, so
* no exceptions should be thrown.
if (tvb-&real_data) {
return tvb-&real_data + abs_
switch(tvb-&type) {
case TVBUFF_REAL_DATA:
g_assert_not_reached();
case TVBUFF_SUBSET:
return ensure_contiguous_no_exception(tvb-&tvbuffs.subset.tvb,
abs_offset - tvb-&tvbuffs.subset.offset,
abs_length, NULL);
case TVBUFF_COMPOSITE:
return composite_ensure_contiguous_no_exception(tvb, abs_offset, abs_length);
g_assert_not_reached();
return NULL;
static const guint8*
ensure_contiguous(tvbuff_t *tvb, gint offset, gint length)
const guint8 *p;
p = ensure_contiguous_no_exception(tvb, offset, length, &exception);
if (p == NULL) {
g_assert(exception & 0);
THROW(exception);
static const guint8*
guint8_find(const guint8* haystack, size_t haystacklen, guint8 needle)
const guint8 *b;
for (b = haystack, i = 0; (guint) i & i++, b++) {
if (*b == needle) {
return NULL;
static const guint8*
guint8_pbrk(const guint8* haystack, size_t haystacklen, guint8 *needles)
const guint8 *b;
item, *needlep,
for (b = haystack, i = 0; (guint) i & i++, b++) {
item = *b;
while ((needle = *needlep) != '\0') {
if (item == needle)
needlep++;
return NULL;
/************** ACCESSORS **************/
static guint8*
composite_memcpy(tvbuff_t *tvb, guint8* target, guint abs_offset, guint abs_length)
tvb_comp_t *
tvbuff_t *member_tvb = NULL;
member_offset, member_
g_assert(tvb-&type == TVBUFF_COMPOSITE);
/* Maybe the range specified by offset/length
* is contiguous inside one of the member tvbuffs */
composite = &tvb-&
num_members = g_slist_length(composite-&tvbs);
for (i = 0; i & num_ i++) {
if (abs_offset &= composite-&end_offsets[i]) {
slist = g_slist_nth(composite-&tvbs, i);
member_tvb = slist-&
g_assert(member_tvb);
if (check_offset_length_no_exception(member_tvb, abs_offset - composite-&start_offsets[i],
abs_length, &member_offset, &member_length, NULL)) {
g_assert(!tvb-&real_data);
return tvb_memcpy(member_tvb, target, member_offset, member_length);
/* The requested data is non-contiguous inside
* the member tvb. We have to memcpy() the part that's in the member tvb,
* then iterate across the other member tvb's, copying their portions
* until we have copied all data.
retval = compute_offset_length(member_tvb, abs_offset - composite-&start_offsets[i], -1,
&member_offset, &member_length, NULL);
g_assert(retval);
tvb_memcpy(member_tvb, target, member_offset, member_length);
abs_offset += member_
abs_length -= member_
/* Recurse */
if (abs_length & 0) {
composite_memcpy(tvb, target + member_length, abs_offset, abs_length);
g_assert_not_reached();
return NULL;
tvb_memcpy(tvbuff_t *tvb, guint8* target, gint offset, gint length)
guint abs_offset, abs_
g_assert(length &= -1);
check_offset_length(tvb, offset, length, &abs_offset, &abs_length);
if (tvb-&real_data) {
return (guint8*) memcpy(target, tvb-&real_data + abs_offset, abs_length);
switch(tvb-&type) {
case TVBUFF_REAL_DATA:
g_assert_not_reached();
case TVBUFF_SUBSET:
return tvb_memcpy(tvb-&tvbuffs.subset.tvb, target,
abs_offset - tvb-&tvbuffs.subset.offset,
abs_length);
case TVBUFF_COMPOSITE:
return composite_memcpy(tvb, target, offset, length);
g_assert_not_reached();
return NULL;
* XXX - this doesn't treat a length of -1 as an error.
* If it did, this could replace some code that calls
* &tvb_ensure_bytes_exist()& and then allocates a buffer and copies
* data to it.
* &composite_ensure_contiguous_no_exception()& depends on -1 not being
* does anything else depend on this routine treating -1 as
* meaning &to the end of the buffer&?
tvb_memdup(tvbuff_t *tvb, gint offset, gint length)
guint abs_offset, abs_
check_offset_length(tvb, offset, length, &abs_offset, &abs_length);
duped = g_malloc(abs_length);
return tvb_memcpy(tvb, duped, abs_offset, abs_length);
const guint8*
tvb_get_ptr(tvbuff_t *tvb, gint offset, gint length)
return ensure_contiguous(tvb, offset, length);
tvb_get_guint8(tvbuff_t *tvb, gint offset)
const guint8*
ptr = ensure_contiguous(tvb, offset, sizeof(guint8));
tvb_get_ntohs(tvbuff_t *tvb, gint offset)
const guint8*
ptr = ensure_contiguous(tvb, offset, sizeof(guint16));
return pntohs(ptr);
tvb_get_ntoh24(tvbuff_t *tvb, gint offset)
const guint8*
ptr = ensure_contiguous(tvb, offset, 3);
return pntoh24(ptr);
tvb_get_ntohl(tvbuff_t *tvb, gint offset)
const guint8*
ptr = ensure_contiguous(tvb, offset, sizeof(guint32));
return pntohl(ptr);
tvb_get_ntoh64(tvbuff_t *tvb, gint offset)
const guint8*
ptr = ensure_contiguous(tvb, offset, sizeof(guint64));
return pntoh64(ptr);
* Stuff for IEEE float handling on platforms that don't have IEEE
* format as the native floating-point format.
* For now, we treat only the VAX as such a platform.
* XXX - other non-IEEE boxes that can run UNIX include some Crays,
* and possibly other machines.
* It appears that the official Linux port to System/390 and
* zArchitecture uses IEEE format floating point (not a
* huge surprise).
* I don't know whether there are any other machines that
* could run Ethereal and that don't use IEEE format.
* As far as I know, all of the main commercial microprocessor
* families on which OSes that support Ethereal can run
* use IEEE format (x86, 68k, SPARC, MIPS, PA-RISC, Alpha,
* IA-64, and so on).
#if defined(vax)
#include &math.h&
* Single-precision.
#define IEEE_SP_NUMBER_WIDTH 32 /* bits in number */
#define IEEE_SP_EXP_WIDTH 8 /* bits in exponent */
#define IEEE_SP_MANTISSA_WIDTH 23 /* IEEE_SP_NUMBER_WIDTH - 1 - IEEE_SP_EXP_WIDTH */
#define IEEE_SP_SIGN_MASK 0x
#define IEEE_SP_EXPONENT_MASK 0x7F800000
#define IEEE_SP_MANTISSA_MASK 0x007FFFFF
#define IEEE_SP_INFINITY IEEE_SP_EXPONENT_MASK
#define IEEE_SP_IMPLIED_BIT (1 && IEEE_SP_MANTISSA_WIDTH)
#define IEEE_SP_INFINITE ((1 && IEEE_SP_EXP_WIDTH) - 1)
#define IEEE_SP_BIAS ((1 && (IEEE_SP_EXP_WIDTH - 1)) - 1)
static int
ieee_float_is_zero(guint32 w)
return ((w & ~IEEE_SP_SIGN_MASK) == 0);
static gfloat
get_ieee_float(guint32 w)
sign = w & IEEE_SP_SIGN_MASK;
exponent = w & IEEE_SP_EXPONENT_MASK;
mantissa = w & IEEE_SP_MANTISSA_MASK;
if (ieee_float_is_zero(w)) {
/* number is zero, unnormalized, or not-a-number */
return 0.0;
* XXX - how to handle this?
if (IEEE_SP_INFINITY == exponent) {
* number is positive or negative infinity, or a special value
return (sign? MINUS_INFINITY: PLUS_INFINITY);
exponent = ((exponent && IEEE_SP_MANTISSA_WIDTH) - IEEE_SP_BIAS) -
IEEE_SP_MANTISSA_WIDTH;
mantissa |= IEEE_SP_IMPLIED_BIT;
return -mantissa * pow(2, exponent);
return mantissa * pow(2, exponent);
* Double-precision.
* We assume that if you don't have IEEE floating-point, you have a
* compiler that understands 64-bit integral quantities.
#define IEEE_DP_NUMBER_WIDTH 64 /* bits in number */
#define IEEE_DP_EXP_WIDTH 11 /* bits in exponent */
#define IEEE_DP_MANTISSA_WIDTH 52 /* IEEE_DP_NUMBER_WIDTH - 1 - IEEE_DP_EXP_WIDTH */
#define IEEE_DP_SIGN_MASK 0x0000LL
#define IEEE_DP_EXPONENT_MASK 0x7FF0LL
#define IEEE_DP_MANTISSA_MASK 0x000FFFFFFFFFFFFFLL
#define IEEE_DP_INFINITY IEEE_DP_EXPONENT_MASK
#define IEEE_DP_IMPLIED_BIT (1LL && IEEE_DP_MANTISSA_WIDTH)
#define IEEE_DP_INFINITE ((1 && IEEE_DP_EXP_WIDTH) - 1)
#define IEEE_DP_BIAS ((1 && (IEEE_DP_EXP_WIDTH - 1)) - 1)
static int
ieee_double_is_zero(guint64 w)
return ((w & ~IEEE_SP_SIGN_MASK) == 0);
static gdouble
get_ieee_double(guint64 w)
sign = w & IEEE_DP_SIGN_MASK;
exponent = w & IEEE_DP_EXPONENT_MASK;
mantissa = w & IEEE_DP_MANTISSA_MASK;
if (ieee_double_is_zero(w)) {
/* number is zero, unnormalized, or not-a-number */
return 0.0;
* XXX - how to handle this?
if (IEEE_DP_INFINITY == exponent) {
* number is positive or negative infinity, or a special value
return (sign? MINUS_INFINITY: PLUS_INFINITY);
exponent = ((exponent && IEEE_DP_MANTISSA_WIDTH) - IEEE_DP_BIAS) -
IEEE_DP_MANTISSA_WIDTH;
mantissa |= IEEE_DP_IMPLIED_BIT;
return -mantissa * pow(2, exponent);
return mantissa * pow(2, exponent);
* Fetches an IEEE single-precision floating-point number, in
* big-endian form, and returns a &float&.
* XXX - should this be &double&, in case there are IEEE single-
* precision numbers that won't fit in some platform's native
* &float& format?
tvb_get_ntohieee_float(tvbuff_t *tvb, int offset)
#if defined(vax)
return get_ieee_float(tvb_get_ntohl(tvb, offset));
} ieee_fp_
ieee_fp_union.w = tvb_get_ntohl(tvb, offset);
return ieee_fp_union.f;
* Fetches an IEEE double-precision floating-point number, in
* big-endian form, and returns a &double&.
tvb_get_ntohieee_double(tvbuff_t *tvb, int offset)
#if defined(vax)
guint32 w[2];
} ieee_fp_
guint32 w[2];
} ieee_fp_
#ifdef WORDS_BIGENDIAN
ieee_fp_union.w[0] = tvb_get_ntohl(tvb, offset);
ieee_fp_union.w[1] = tvb_get_ntohl(tvb, offset+4);
ieee_fp_union.w[0] = tvb_get_ntohl(tvb, offset+4);
ieee_fp_union.w[1] = tvb_get_ntohl(tvb, offset);
#if defined(vax)
return get_ieee_double(ieee_fp_union.dw);
return ieee_fp_union.d;
tvb_get_letohs(tvbuff_t *tvb, gint offset)
const guint8*
ptr = ensure_contiguous(tvb, offset, sizeof(guint16));
return pletohs(ptr);
tvb_get_letoh24(tvbuff_t *tvb, gint offset)
const guint8*
ptr = ensure_contiguous(tvb, offset, 3);
return pletoh24(ptr);
tvb_get_letohl(tvbuff_t *tvb, gint offset)
const guint8*
ptr = ensure_contiguous(tvb, offset, sizeof(guint32));
return pletohl(ptr);
tvb_get_letoh64(tvbuff_t *tvb, gint offset)
const guint8*
ptr = ensure_contiguous(tvb, offset, sizeof(guint64));
return pletoh64(ptr);
* Fetches an IEEE single-precision floating-point number, in
* little-endian form, and returns a &float&.
* XXX - should this be &double&, in case there are IEEE single-
* precision numbers that won't fit in some platform's native
* &float& format?
tvb_get_letohieee_float(tvbuff_t *tvb, int offset)
#if defined(vax)
return get_ieee_float(tvb_get_letohl(tvb, offset));
} ieee_fp_
ieee_fp_union.w = tvb_get_letohl(tvb, offset);
return ieee_fp_union.f;
* Fetches an IEEE double-precision floating-point number, in
* little-endian form, and returns a &double&.
tvb_get_letohieee_double(tvbuff_t *tvb, int offset)
#if defined(vax)
guint32 w[2];
} ieee_fp_
guint32 w[2];
} ieee_fp_
#ifdef WORDS_BIGENDIAN
ieee_fp_union.w[0] = tvb_get_letohl(tvb, offset+4);
ieee_fp_union.w[1] = tvb_get_letohl(tvb, offset);
ieee_fp_union.w[0] = tvb_get_letohl(tvb, offset);
ieee_fp_union.w[1] = tvb_get_letohl(tvb, offset+4);
#if defined(vax)
return get_ieee_double(ieee_fp_union.dw);
return ieee_fp_union.d;
/* Find first occurence of needle in tvbuff, starting at offset. Searches
* at most maxle if maxlength is -1, searches to
* end of tvbuff.
* Returns the offset of the found needle, or -1 if not found.
* Will not throw an exception, even if maxlength exceed
* in that case, -1 will be returned if the boundary is reached before
* finding needle. */
tvb_find_guint8(tvbuff_t *tvb, gint offset, gint maxlength, guint8 needle)
const guint8 *
abs_offset, junk_
check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
/* Only search to end of tvbuff, w/o throwing exception. */
tvbufflen = tvb_length_remaining(tvb, abs_offset);
if (maxlength == -1) {
/* No maxi search to end of tvbuff. */
else if (tvbufflen & (guint) maxlength) {
/* Maximum length goe search to end
of tvbuff. */
/* Maximum length doesn't g search
to that value. */
/* If we have real data, perform our search now. */
if (tvb-&real_data) {
result = guint8_find(tvb-&real_data + abs_offset, limit, needle);
if (result == NULL) {
return -1;
return result - tvb-&real_
switch(tvb-&type) {
case TVBUFF_REAL_DATA:
g_assert_not_reached();
case TVBUFF_SUBSET:
return tvb_find_guint8(tvb-&tvbuffs.subset.tvb,
abs_offset - tvb-&tvbuffs.subset.offset,
limit, needle);
case TVBUFF_COMPOSITE:
g_assert_not_reached();
/* XXX - return composite_find_guint8(tvb, offset, limit, needle); */
g_assert_not_reached();
return -1;
/* Find first occurence of any of the needles in tvbuff, starting at offset.
* Searches at most maxle if maxlength is -1, searches
* to end of tvbuff.
* Returns the offset of the found needle, or -1 if not found.
* Will not throw an exception, even if maxlength exceed
* in that case, -1 will be returned if the boundary is reached before
* finding needle. */
tvb_pbrk_guint8(tvbuff_t *tvb, gint offset, gint maxlength, guint8 *needles)
const guint8 *
abs_offset, junk_
check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
/* Only search to end of tvbuff, w/o throwing exception. */
tvbufflen = tvb_length_remaining(tvb, abs_offset);
if (maxlength == -1) {
/* No maxi search to end of tvbuff. */
else if (tvbufflen & (guint) maxlength) {
/* Maximum length goe search to end
of tvbuff. */
/* Maximum length doesn't g search
to that value. */
/* If we have real data, perform our search now. */
if (tvb-&real_data) {
result = guint8_pbrk(tvb-&real_data + abs_offset, limit, needles);
if (result == NULL) {
return -1;
return result - tvb-&real_
switch(tvb-&type) {
case TVBUFF_REAL_DATA:
g_assert_not_reached();
case TVBUFF_SUBSET:
return tvb_pbrk_guint8(tvb-&tvbuffs.subset.tvb,
abs_offset - tvb-&tvbuffs.subset.offset,
limit, needles);
case TVBUFF_COMPOSITE:
g_assert_not_reached();
/* XXX - return composite_pbrk_guint8(tvb, offset, limit, needle); */
g_assert_not_reached();
return -1;
/* Find size of stringz (NUL-terminated string) by looking for terminating
The size of the string includes the terminating NUL.
* If the NUL isn't found, it throws the appropriate exception.
tvb_strsize(tvbuff_t *tvb, gint offset)
guint abs_offset, junk_
check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
nul_offset = tvb_find_guint8(tvb, abs_offset, -1, 0);
if (nul_offset == -1) {
* OK, we hit the end of the tvbuff, so we should throw
* an exception.
* Did we hit the end of the captured data, or the end
* of the actual data?
If there's less captured data
* than actual data, we presumably hit the end of the
* captured data, otherwise we hit the end of the actual
if (tvb_length(tvb) & tvb_reported_length(tvb)) {
THROW(BoundsError);
THROW(ReportedBoundsError);
return (nul_offset - abs_offset) + 1;
/* Find length of string by looking for end of string ('\0'), up to
* 'maxlength' characters'; if 'maxlength' is -1, searches to end
* of tvbuff.
* Returns -1 if 'maxlength' reached before finding EOS. */
tvb_strnlen(tvbuff_t *tvb, gint offset, guint maxlength)
gint result_
guint abs_offset, junk_
check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
result_offset = tvb_find_guint8(tvb, abs_offset, maxlength, 0);
if (result_offset == -1) {
return -1;
return result_offset - abs_
* Implement strneql etc
* Call strncmp after checking if enough chars left, returning 0 if
* it returns 0 (meaning &equal&) and -1 otherwise, otherwise return -1.
tvb_strneql(tvbuff_t *tvb, gint offset, const gchar *str, gint size)
const guint8 *
ptr = ensure_contiguous_no_exception(tvb, offset, size, NULL);
if (ptr) {
int cmp = strncmp((const char *)ptr, str, size);
* Return 0 if equal, -1 otherwise.
return (cmp == 0 ? 0 : -1);
* Not enough characters in the tvbuff to match the
return -1;
* Call strncasecmp after checking if enough chars left, returning 0 if
* it returns 0 (meaning &equal&) and -1 otherwise, otherwise return -1.
tvb_strncaseeql(tvbuff_t *tvb, gint offset, const gchar *str, gint size)
const guint8 *
ptr = ensure_contiguous_no_exception(tvb, offset, size, NULL);
if (ptr) {
int cmp = strncasecmp((const char *)ptr, str, size);
* Return 0 if equal, -1 otherwise.
return (cmp == 0 ? 0 : -1);
* Not enough characters in the tvbuff to match the
return -1;
* Call memcmp after checking if enough chars left, returning 0 if
* it returns 0 (meaning &equal&) and -1 otherwise, otherwise return -1.
tvb_memeql(tvbuff_t *tvb, gint offset, const guint8 *str, gint size)
const guint8 *
ptr = ensure_contiguous_no_exception(tvb, offset, size, NULL);
if (ptr) {
int cmp = memcmp(ptr, str, size);
* Return 0 if equal, -1 otherwise.
return (cmp == 0 ? 0 : -1);
* Not enough characters in the tvbuff to match the
return -1;
/* Convert a string from Unicode to ASCII.
At the moment we fake it by
* replacing all non-ASCII characters with a '.' )-:
The caller must
* free the result returned.
The len parameter is the number of guint16's
* to convert from Unicode. */
tvb_fake_unicode(tvbuff_t *tvb, int offset, int len, gboolean little_endian)
/* Make sure we have enough data before allocating the buffer,
so we don't blow up if the length is huge. */
tvb_ensure_bytes_exist(tvb, offset, 2*len);
/* We know we won't throw an exception, so we don't have to worry
about leaking this buffer. */
buffer = g_malloc(len + 1);
for (i = 0; i & i++) {
character = little_endian ? tvb_get_letohs(tvb, offset)
: tvb_get_ntohs(tvb, offset);
buffer[i] = character & 256 ? character : '.';
offset += 2;
buffer[len] = 0;
* Format the data in the tvb from offset for length ...
tvb_format_text(tvbuff_t *tvb, gint offset, gint size)
const guint8 *
gint len =
if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
len = tvb_length_remaining(tvb, offset);
ptr = ensure_contiguous(tvb, offset, len);
return format_text(ptr, len);
* Like &tvb_format_text()&, but for null- don't show
* the null padding characters as &\000&.
tvb_format_stringzpad(tvbuff_t *tvb, gint offset, gint size)
const guint8 *ptr, *p;
gint len =
if ((ptr = ensure_contiguous(tvb, offset, size)) == NULL) {
len = tvb_length_remaining(tvb, offset);
ptr = ensure_contiguous(tvb, offset, len);
for (p = ptr, stringlen = 0; stringlen & len && *p != '\0'; p++, stringlen++)
return format_text(ptr, stringlen);
* Given a tvbuff, an offset, and a length, allocate a buffer big enough
* to hold a non-null-terminated string of that length at that offset,
* plus a trailing '\0', copy the string into it, and return a pointer
* to the string.
* Throws an exception if the tvbuff ends before the string does.
tvb_get_string(tvbuff_t *tvb, gint offset, gint length)
const guint8 *
ptr = ensure_contiguous(tvb, offset, length);
strbuf = g_malloc(length + 1);
if (length != 0)
memcpy(strbuf, ptr, length);
strbuf[length] = '\0';
* Given a tvbuff and an offset, with the offset assumed to refer to
* a null-terminated string, find the length of that string (and throw
* an exception if the tvbuff ends before we find the null), allocate
* a buffer big enough to hold the string, copy the string into it,
* and return a pointer to the string.
Also return the length of the
* string (including the terminating null) through a pointer.
tvb_get_stringz(tvbuff_t *tvb, gint offset, gint *lengthp)
size = tvb_strsize(tvb, offset);
strptr = g_malloc(size);
tvb_memcpy(tvb, strptr, offset, size);
*lengthp =
/* Looks for a stringz (NUL-terminated string) in tvbuff and copies
* no more than bufsize number of bytes, including terminating NUL, to buffer.
* Returns length of string (not including terminating NUL), or -1 if the string was
* truncated in the buffer due to not having reached the terminating NUL.
* In this way, it acts like snprintf().
* bufsize MUST be greater than 0.
* When processing a packet where the remaining number of bytes is less
* than bufsize, an exception is not thrown if the end of the packet
* is reached before the NUL is found. If no NUL is found before reaching
* the end of the short packet, -1 is still returned, and the string
* is truncated with a NUL, albeit not at buffer[bufsize - 1], but
* at the correct spot, terminating the string.
* *bytes_copied will contain the number of bytes actually copied,
* including the terminating-NUL.
static gint
_tvb_get_nstringz(tvbuff_t *tvb, gint offset, guint bufsize, guint8* buffer,
gint *bytes_copied)
guint abs_offset, junk_
gint limit,
gboolean decreased_max = FALSE;
check_offset_length(tvb, offset, 0, &abs_offset, &junk_length);
/* There must at least be room for the terminating NUL. */
g_assert(bufsize != 0);
/* If there's no room for anything else, just return the NUL. */
if (bufsize == 1) {
buffer[0] = 0;
*bytes_copied = 1;
/* Only read to end of tvbuff, w/o throwing exception. */
len = tvb_length_remaining(tvb, abs_offset);
/* check_offset_length() won't throw an exception if we're
* looking at the byte immediately after the end of the tvbuff. */
if (len == 0) {
THROW(ReportedBoundsError);
/* This should not happen because check_offset_length() would
* have already thrown an exception if 'offset' were out-of-bounds.
g_assert(len != -1);
* If we've been passed a negative number, bufsize will
* be huge.
g_assert(bufsize &= G_MAXINT);
if ((guint)len & bufsize) {
decreased_max = TRUE;
stringlen = tvb_strnlen(tvb, abs_offset, limit - 1);
/* If NUL wasn't found, copy the data and return -1 */
if (stringlen == -1) {
tvb_memcpy(tvb, buffer, abs_offset, limit);
if (decreased_max) {
buffer[limit] = 0;
/* Add 1 for the extra NUL that we set at buffer[limit],
* pretending that it was copied as part of the string. */
*bytes_copied = limit + 1;
*bytes_copied =
return -1;
/* Copy the string to buffer */
tvb_memcpy(tvb, buffer, abs_offset, stringlen + 1);
*bytes_copied = stringlen + 1;
/* Looks for a stringz (NUL-terminated string) in tvbuff and copies
* no more than bufsize number of bytes, including terminating NUL, to buffer.
* Returns length of string (not including terminating NUL), or -1 if the string was
* truncated in the buffer due to not having reached the terminating NUL.
* In this way, it acts like snprintf().
* When processing a packet where the remaining number of bytes is less
* than bufsize, an exception is not thrown if the end of the packet
* is reached before the NUL is found. If no NUL is found before reaching
* the end of the short packet, -1 is still returned, and the string
* is truncated with a NUL, albeit not at buffer[bufsize - 1], but
* at the correct spot, terminating the string.
tvb_get_nstringz(tvbuff_t *tvb, gint offset, guint bufsize, guint8* buffer)
gint bytes_
return _tvb_get_nstringz(tvb, offset, bufsize, buffer, &bytes_copied);
/* Like tvb_get_nstringz(), but never returns -1. The string is guaranteed to
* have a terminating NUL. If the string was truncated when copied into buffer,
* a NUL is placed at the end of buffer to terminate it.
tvb_get_nstringz0(tvbuff_t *tvb, gint offset, guint bufsize, guint8* buffer)
gint len, bytes_
len = _tvb_get_nstringz(tvb, offset, bufsize, buffer, &bytes_copied);
if (len == -1) {
buffer[bufsize - 1] = 0;
return bytes_copied - 1;
* Given a tvbuff, an offset into the tvbuff, and a length that starts
* at that offset (which may be -1 for &all the way to the end of the
* tvbuff&), find the end of the (putative) line that starts at the
* specified offset in the tvbuff, going no further than the specified
* Return the length of the line (not counting the line terminator at
* the end), or, if we don't find a line terminator:
* if &deseg& is true, return -1;
* if &deseg& is false, return the amount of data remaining in
* the buffer.
* Set &*next_offset& to the offset of the character past the line
* terminator, or past the end of the buffer if we don't find a line
* terminator.
(It's not set if we return -1.)
tvb_find_line_end(tvbuff_t *tvb, gint offset, int len, gint *next_offset,
gboolean desegment)
if (len == -1)
len = tvb_length_remaining(tvb, offset);
* XXX - what if &len& is still -1, meaning &offset is past the
* end of the tvbuff&?
eob_offset = offset +
* Look either for a CR or an LF.
eol_offset = tvb_pbrk_guint8(tvb, offset, len, (guint8 *)&\r\n&);
if (eol_offset == -1) {
* No CR or LF - line is presumably continued in next packet.
if (desegment) {
* Tell our caller we saw no EOL, so they can
* try to desegment and get the entire line
* into one tvbuff.
return -1;
* Pretend the line runs to the end of the tvbuff.
linelen = eob_offset -
*next_offset = eob_
* Find the number of bytes between the starting offset
* and the CR or LF.
linelen = eol_offset -
* Is it a CR?
if (tvb_get_guint8(tvb, eol_offset) == '\r') {
* Yes - is it followed by an LF?
if (eol_offset + 1 &= eob_offset) {
* Dunno - the next byte isn't in this
if (desegment) {
* We'll return -1, although that
* runs the risk that if the line
* really *is* terminated with a CR,
* we won't properly dissect this
* It's probably more likely that
* the line ends with CR-LF than
* that it ends with CR by itself.
return -1;
* Well, we can at least look at the next
if (tvb_get_guint8(tvb, eol_offset + 1) == '\n') {
* It's an LF; skip over the CR.
eol_offset++;
* Return the offset of the character after the last
* character in the line, skipping over the last character
* in the line terminator.
*next_offset = eol_offset + 1;
* Given a tvbuff, an offset into the tvbuff, and a length that starts
* at that offset (which may be -1 for &all the way to the end of the
* tvbuff&), find the end of the (putative) line that starts at the
* specified offset in the tvbuff, going no further than the specified
* However, treat quoted strings inside the buffer specially - don't
* treat newlines in quoted strings as line terminators.
* Return the length of the line (not counting the line terminator at
* the end), or the amount of data remaining in the buffer if we don't
* find a line terminator.
* Set &*next_offset& to the offset of the character past the line
* terminator, or past the end of the buffer if we don't find a line
* terminator.
tvb_find_line_end_unquoted(tvbuff_t *tvb, gint offset, int len,
gint *next_offset)
gint cur_offset, char_
gboolean is_
if (len == -1)
len = tvb_length_remaining(tvb, offset);
* XXX - what if &len& is still -1, meaning &offset is past the
* end of the tvbuff&?
eob_offset = offset +
cur_offset =
is_quoted = FALSE;
for (;;) {
* Is this part of the string quoted?
if (is_quoted) {
* Yes - look only for the terminating quote.
char_offset = tvb_find_guint8(tvb, cur_offset, len,
* Look either for a CR, an LF, or a '&'.
char_offset = tvb_pbrk_guint8(tvb, cur_offset, len,
(guint8 *)&\r\n\&&);
if (char_offset == -1) {
* Not found - line is presumably continued in
* next packet.
* We pretend the line runs to the end of the tvbuff.
linelen = eob_offset -
*next_offset = eob_
if (is_quoted) {
* We're processing a quoted string.
* We only looked for &, so we know it's a &;
* as we're processing a quoted string, it's a
* closing quote.
is_quoted = FALSE;
* OK, what is it?
c = tvb_get_guint8(tvb, char_offset);
if (c == '&') {
* Un-quoted &; it begins a quoted
is_quoted = TRUE;
* It's a CR or LF; we've found a line
* terminator.
* Find the number of bytes between the
* starting offset and the CR or LF.
linelen = char_offset -
* Is it a CR?
if (c == '\r') {
* Y is it followed by an LF?
if (char_offset + 1 & eob_offset &&
tvb_get_guint8(tvb, char_offset + 1)
== '\n') {
* Y skip over the CR.
char_offset++;
* Return the offset of the character after
* the last character in the line, skipping
* over the last character in the line
* terminator, and quit.
*next_offset = char_offset + 1;
* Step past the character we found.
cur_offset = char_offset + 1;
if (cur_offset &= eob_offset) {
* The character we found was the last character
* in the tvbuff - line is presumably continued in
* next packet.
* We pretend the line runs to the end of the tvbuff.
linelen = eob_offset -
*next_offset = eob_
* Format a bunch of data from a tvbuff as bytes, returning a pointer
* to the string with the formatted data, with &punct& as a byte
* separator.
tvb_bytes_to_str_punct(tvbuff_t *tvb, gint offset, gint len, gchar punct)
return bytes_to_str_punct(tvb_get_ptr(tvb, offset, len), len, punct);
* Format a bunch of data from a tvbuff as bytes, returning a pointer
* to the string with the formatted data.
tvb_bytes_to_str(tvbuff_t *tvb, gint offset, gint len)
return bytes_to_str(tvb_get_ptr(tvb, offset, len), len);
/* Find a needle tvbuff within a haystack tvbuff. */
tvb_find_tvb(tvbuff_t *haystack_tvb, tvbuff_t *needle_tvb, gint haystack_offset)
haystack_abs_offset, haystack_abs_
const guint8 *haystack_
const guint8 *needle_
const guint
needle_len = needle_tvb-&
const guint8 *
if (haystack_tvb-&length & 1 || needle_tvb-&length & 1) {
return -1;
/* Get pointers to the tvbuffs' data. */
haystack_data = tvb_get_ptr(haystack_tvb, 0, -1);
needle_data = tvb_get_ptr(needle_tvb, 0, -1);
check_offset_length(haystack_tvb, haystack_offset, -1,
&haystack_abs_offset, &haystack_abs_length);
location = epan_memmem(haystack_data + haystack_abs_offset, haystack_abs_length,
needle_data, needle_len);
if (location) {
return location - haystack_
return -1;
return -1;
#ifdef HAVE_LIBZ
* Uncompresses a zlib compressed packet inside a message of tvb at offset with
* length comprlen.
Returns an uncompressed tvbuffer if uncompression
* succeeded or NULL if uncompression failed.
#define TVB_Z_MIN_BUFSIZ 32768
#define TVB_Z_MAX_BUFSIZ 1048576 * 10
/* #define TVB_Z_DEBUG 1 */
#undef TVB_Z_DEBUG
tvbuff_t *
tvb_uncompress(tvbuff_t *tvb, int offset, int comprlen)
gint err = Z_OK;
guint bytes_out = 0;
guint8 *compr = NULL;
guint8 *uncompr = NULL;
tvbuff_t *uncompr_tvb = NULL;
z_streamp strm = NULL;
Bytef *strmbuf = NULL;
guint inits_done = 0;
gint wbits = MAX_WBITS;
guint8 *next = NULL;
guint bufsiz = TVB_Z_MIN_BUFSIZ;
#ifdef TVB_Z_DEBUG
guint inflate_passes = 0;
guint bytes_in = tvb_length_remaining(tvb, offset);
if (tvb == NULL) {
return NULL;
strm = g_malloc0(sizeof(z_stream));
if (strm == NULL) {
return NULL;
compr = tvb_memdup(tvb, offset, comprlen);
if (!compr) {
g_free(strm);
return NULL;
* Assume that the uncompressed data is at least twice as big as
* the compressed size.
bufsiz = tvb_length_remaining(tvb, offset) * 2;
if (bufsiz & TVB_Z_MIN_BUFSIZ) {
bufsiz = TVB_Z_MIN_BUFSIZ;
} else if (bufsiz & TVB_Z_MAX_BUFSIZ) {
bufsiz = TVB_Z_MIN_BUFSIZ;
#ifdef TVB_Z_DEBUG
printf(&bufsiz: %u bytes\n&, bufsiz);
strm-&next_in =
strm-&avail_in =
strmbuf = g_malloc0(bufsiz);
if(strmbuf == NULL) {
g_free(compr);
g_free(strm);
return NULL;
strm-&next_out =
strm-&avail_out =
err = inflateInit2(strm, wbits);
inits_done = 1;
if (err != Z_OK) {
g_free(strm);
g_free(compr);
g_free(strmbuf);
return NULL;
while (1) {
memset(strmbuf, '\0', bufsiz);
strm-&next_out =
strm-&avail_out =
err = inflate(strm, Z_SYNC_FLUSH);
if (err == Z_OK || err == Z_STREAM_END) {
guint bytes_pass = bufsiz - strm-&avail_
#ifdef TVB_Z_DEBUG
++inflate_
if (uncompr == NULL) {
uncompr = g_memdup(strmbuf, bytes_pass);
guint8 *new_data = g_malloc0(bytes_out +
bytes_pass);
if (new_data == NULL) {
g_free(strm);
g_free(strmbuf);
g_free(compr);
if (uncompr != NULL) {
g_free(uncompr);
return NULL;
g_memmove(new_data, uncompr, bytes_out);
g_memmove((new_data + bytes_out), strmbuf,
bytes_pass);
g_free(uncompr);
uncompr = new_
bytes_out += bytes_
if ( err == Z_STREAM_END) {
inflateEnd(strm);
g_free(strm);
g_free(strmbuf);
} else if (err == Z_BUF_ERROR) {
* It's possible that not enough frames were captured
* to decompress this fully, so return what we've done
* so far, if any.
g_free(strm);
g_free(strmbuf);
if (uncompr != NULL) {
g_free(compr);
return NULL;
} else if (err == Z_DATA_ERROR && inits_done == 1
&& uncompr == NULL && (*compr
== 0x1f) &&
(*(compr + 1) == 0x8b)) {
* inflate() is supposed to handle both gzip and deflate
* streams automatically, but in reality it doesn't
* seem to handle either (at least not within the
* context of an HTTP response.)
We have to try
* several tweaks, depending on the type of data and
* version of the library installed.
* Gzip file format.
Skip past the header, since the
* fix to make it work (setting windowBits to 31)
* doesn't work with all versions of the library.
Bytef *c = compr + 2;
Bytef flags = 0;
if (*c == Z_DEFLATED) {
g_free(strm);
g_free(compr);
g_free(strmbuf);
return NULL;
flags = *c;
/* Skip past the MTIME, XFL, and OS fields. */
if (flags & (1 && 2)) {
/* An Extra field is present. */
gint xsize = (gint)(*c |
(*(c + 1) && 8));
if (flags & (1 && 3)) {
/* A null terminated filename */
while (*c != '\0') {
if (flags & (1 && 4)) {
/* A null terminated comment */
while (*c != '\0') {
inflateReset(strm);
strm-&next_in =
comprlen -= (c - compr);
err = inflateInit2(strm, wbits);
inits_done++;
} else if (err == Z_DATA_ERROR && uncompr == NULL &&
inits_done &= 3) {
* Re-init the stream with a negative
* MAX_WBITS. This is necessary due to
* some servers (Apache) not sending
* the deflate header with the
* content-encoded response.
wbits = -MAX_WBITS;
inflateReset(strm);
strm-&next_in =
strm-&avail_in =
memset(strmbuf, '\0', bufsiz);
strm-&next_out =
strm-&avail_out =
err = inflateInit2(strm, wbits);
inits_done++;
if (err != Z_OK) {
g_free(strm);
g_free(strmbuf);
g_free(compr);
g_free(uncompr);
return NULL;
g_free(strm);
g_free(strmbuf);
g_free(compr);
if (uncompr == NULL) {
return NULL;
#ifdef TVB_Z_DEBUG
printf(&inflate() total passes: %u\n&, inflate_passes);
printf(&bytes
in: %u\nbytes out: %u\n\n&, bytes_in, bytes_out);
if (uncompr != NULL) {
uncompr_tvb =
tvb_new_real_data((guint8*) uncompr, bytes_out,
bytes_out);
tvb_set_free_cb(uncompr_tvb, g_free);
g_free(compr);
return uncompr_
tvbuff_t *
tvb_uncompress(tvbuff_t *tvb _U_, int offset _U_, int comprlen _U_)
return NULL;
展开＞ ＜收缩
Sponsored links
源码文件列表
温馨提示： 点击源码文件名可预览文件内容哦 ^_^
<img src='/images/file_icons/folder.png' alt='源码文件 '>&&0.00 B 15:06
<img src='/images/file_icons/folder.png' alt='源码文件 '>&&0.00 B 15:05
glib-2.0.m47.99 kB 21:38
glib.m48.25 kB 21:38
gtk-2.0.m47.35 kB 21:38
gtk.m48.09 kB 21:38
<img src='/images/file_icons/folder.png' alt='源码文件 '>&&0.00 B 15:06
365.00 B 21:39
changelog4.55 kB 21:39
control2.11 kB 21:39
copyright410.00 B 21:39
dirs8.00 B 21:39
docs28.00 B 21:39
menu94.00 B 21:39
postinst85.00 B 21:39
prerm25.00 B 21:39
rules2.09 kB 21:39
<img src='/images/file_icons/folder.png' alt='源码文件 '>&&0.00 B 15:06
5.08 kB 21:39
5.30 kB 21:39
3.93 kB 21:39
2.17 kB 21:39
100.61 kB 21:39
3.67 kB 21:39
8.41 kB 21:39
2.38 kB 21:39
8.51 kB 21:39
9.60 kB 21:39
7.08 kB 21:39
capinfos.pod4.47 kB 21:39
dfilter2pod.pl2.83 kB 21:39
editcap.pod6.20 kB 21:39
ethereal-filter.pod.template12.78 kB 21:39
ethereal.pod70.95 kB 21:39
idl2eth.pod2.44 kB 21:39
mergecap.pod6.32 kB 10:35
2.88 kB 21:39
tethereal.pod33.24 kB 21:39
text2pcap.pod7.73 kB 21:39
16.20 kB 14:45
<img src='/images/file_icons/folder.png' alt='源码文件 '>&&0.00 B 15:06
libethereal.def11.52 kB 21:40
71.00 B 21:40
3.88 kB 21:40
2.77 kB 21:40
52.44 kB 14:45
doxygen.cfg.in2.26 kB 21:40
AUTHORS220.00 B 21:39
<img src='/images/file_icons/folder.png' alt='源码文件 '>&ChangeLog&0.00 B 21:39
NEWS60.00 B 21:39
2.05 kB 21:39
49.71 kB 21:39
1.94 kB 21:40
1.62 kB 21:40
1.38 kB 21:40
1.78 kB 21:40
2.64 kB 21:40
4.99 kB 21:39
8.06 kB 21:40
10.89 kB 21:39
28.23 kB 21:40
33.78 kB 21:39
6.98 kB 21:40
6.39 kB 21:39
9.02 kB 21:39
4.39 kB 21:40
12.20 kB 21:39
2.62 kB 21:40
4.41 kB 21:40
9.81 kB 21:39
17.47 kB 21:40
3.27 kB 21:39
6.33 kB 21:39
6.78 kB 21:40
3.65 kB 21:39
5.86 kB 21:40
42.03 kB 21:40
11.46 kB 21:40
87.54 kB 21:39
101.56 kB 21:39
9.17 kB 21:40
9.15 kB 10:35
9.78 kB 21:39
45.44 kB 21:40
100.08 kB 21:39
2.69 kB 21:39
1.85 kB 21:40
13.31 kB 21:40
17.67 kB 21:39
11.00 kB 21:40
1.30 kB 21:40
21.26 kB 21:39
56.25 kB 21:40
2.99 kB 21:40
11.71 kB 21:39
1.57 kB 21:39
5.46 kB 21:39
3.91 kB 21:40
1.26 kB 21:39
1.42 kB 21:40
2.44 kB 21:39
1.54 kB 21:40
1.15 kB 21:40
1,020.00 B 21:40
1.27 kB 21:39
2.55 kB 21:40
1.47 kB 21:39
4.24 kB 21:40
2.85 kB 21:40
3.75 kB 21:39
3.61 kB 21:40
3.65 kB 21:39
1.01 kB 21:39
989.00 B 21:40
3.32 kB 21:39
1.21 kB 21:40
2.33 kB 21:40
1.40 kB 21:40
4.25 kB 21:39
5.99 kB 21:40
3.80 kB 21:40
3.30 kB 21:39
1.71 kB 21:39
298.00 B 21:39
11.03 kB 21:40
2.26 kB 21:39
1.53 kB 21:39
1.10 kB 21:39
1.91 kB 21:40
13.65 kB 21:40
6.05 kB 21:39
3.82 kB 21:40
1.81 kB 21:40
10.68 kB 21:39
3.52 kB 21:39
41.35 kB 21:39
2.01 kB 21:40
1.54 kB 21:40
1.31 kB 10:35
1.37 kB 21:39
2.04 kB 21:40
1.72 kB 21:39
2.33 kB 21:39
2.38 kB 21:39
1.28 kB 21:40
5.24 kB 21:40
1.16 kB 21:39
1.93 kB 21:40
1.39 kB 21:40
2.84 kB 21:39
21.29 kB 21:40
2.25 kB 21:40
4.95 kB 21:39
5.11 kB 21:39
377.00 B 21:39
4.20 kB 21:39
5.89 kB 21:39
5.70 kB 21:39
1.10 kB 21:39
1.68 kB 21:40
3.36 kB 21:39
10.17 kB 21:39
<img src='/images/file_icons/folder.png' alt='源码文件 '>&&0.00 B 15:06
1.28 kB 21:40
18.22 kB 14:45
10.58 kB 21:40
8.42 kB 21:40
1.22 kB 21:40
11.27 kB 21:40
5.17 kB 21:40
18.45 kB 21:40
5.14 kB 21:40
1.83 kB 21:40
6.10 kB 21:40
8.95 kB 21:40
8.83 kB 21:40
5.79 kB 21:40
810.00 B 21:40
<img src='/images/file_icons/folder.png' alt='源码文件 '>&&0.00 B 15:06
1.78 kB 21:40
19.14 kB 14:45
6.60 kB 21:40
2.48 kB 21:40
1.90 kB 21:40
9.42 kB 21:40
1.90 kB 21:40
4.72 kB 21:40
3.17 kB 21:40
8.76 kB 21:40
147.00 B 21:40
660.00 B 21:40
111.00 B 21:40
41.99 kB 21:49
1.08 kB 21:49
52.36 kB 21:49
22.80 kB 21:40
977.00 B 21:40
1.13 kB 21:40
1.23 kB 21:40
2.58 kB 21:40
1.37 kB 21:40
1.35 kB 21:40
3.03 kB 21:40
1.48 kB 21:40
3.63 kB 21:40
2.73 kB 21:40
grammar.lemon5.55 kB 21:40
scanner.l8.46 kB 21:40
1.38 kB 21:40
<img src='/images/file_icons/folder.png' alt='源码文件 '>&&0.00 B 15:06
4.27 kB 21:39
5.51 kB 21:39
22.43 kB 21:39
16.46 kB 21:39
29.29 kB 21:39
3.43 kB 21:39
3.71 kB 21:39
1.81 kB 21:39
1.37 kB 21:39
1.02 kB 21:39
1.04 kB 21:39
1.25 kB 21:39
1.49 kB 21:39
1.04 kB 21:39
7.20 kB 21:39
8.43 kB 21:39
287.00 B 21:39
1.30 kB 21:39
1.37 kB 21:40
38.74 kB 21:39
1.02 kB 21:39
1.01 kB 21:39
2.06 kB 21:39
6.35 kB 21:39
3.45 kB 21:39
5.32 kB 21:39
1.10 kB 21:39
14.29 kB 21:39
1.28 kB 21:39
1.63 kB 21:39
1.19 kB 21:39
2.39 kB 21:39
1.87 kB 21:39
1.61 kB 21:39
2.09 kB 21:39
1.71 kB 21:39
2.04 kB 21:40
1.57 kB 21:39
1.61 kB 21:39
1.42 kB 21:39
5.59 kB 21:39
1.42 kB 21:39
3.49 kB 21:39
6.26 kB 21:39
2.91 kB 21:39
5.98 kB 21:39
20.63 kB 21:39
3.20 kB 21:39
2.87 kB 21:39
1.15 kB 21:39
2.45 kB 21:39
13.10 kB 21:39
5.74 kB 21:39
1.59 kB 21:39
38.81 kB 21:39
1.78 kB 21:39
1.21 kB 21:39
1.14 kB 21:39
1.59 kB 21:39
8.85 kB 21:39
2.10 kB 21:39
1.48 kB 21:39
1.20 kB 21:39
5.00 kB 21:39
2.43 kB 21:39
2.92 kB 21:39
7.67 kB 21:39
11.82 kB 21:39
8.02 kB 21:39
4.60 kB 21:39
3.61 kB 21:39
2.24 kB 21:39
2.65 kB 21:39
2.00 kB 21:39
5.27 kB 21:39
1.09 kB 21:39
1.78 kB 21:39
11.92 kB 21:39
16.82 kB 21:39
2.66 kB 21:39
2.21 kB 21:39
1.39 kB 10:35
1.25 kB 21:39
1.45 kB 21:39
1.65 kB 21:39
1.22 kB 21:39
4.47 kB 10:35
2.36 kB 21:39
2.38 kB 21:39
1.44 kB 21:39
1.46 kB 21:39
1.61 kB 21:39
1.07 kB 21:39
1.14 kB 21:39
5.78 kB 21:39
1.50 kB 21:39
1.25 kB 21:39
1.08 kB 21:39
1.22 kB 21:39
1.17 kB 21:39
1.42 kB 21:39
24.54 kB 21:39
1.01 kB 21:39
1.09 kB 21:39
16.58 kB 21:39
5.52 kB 21:40
5.33 kB 21:39
1.87 kB 21:39
3.15 kB 21:39
1.57 kB 21:39
1.75 kB 21:39
1.09 kB 21:39
5.29 kB 21:39
1.89 kB 21:39
1.11 kB 21:39
2.77 kB 21:39
1.15 kB 21:39
1.26 kB 21:39
1.62 kB 21:39
1.52 kB 21:39
5.99 kB 21:39
480.00 B 21:39
1.19 kB 21:39
1.15 kB 21:39
1.14 kB 21:39
2.37 kB 21:39
3.73 kB 21:39
1.37 kB 21:39
99.84 kB 21:39
1.62 kB 21:39
3.36 kB 21:39
1.75 kB 21:39
826.00 B 21:39
1.18 kB 21:39
1.24 kB 21:39
1.01 kB 21:39
1.48 kB 21:39
1.26 kB 21:39
2.89 kB 21:39
1,004.00 B 21:39
5.38 kB 21:39
2.17 kB 21:39
1.10 kB 21:39
1.92 kB 21:39
3.93 kB 21:39
2.19 kB 21:39
1.51 kB 21:39
1.55 kB 21:39
1.50 kB 21:39
1.66 kB 21:39
1.08 kB 21:39
1.72 kB 21:39
1.41 kB 21:39
4.26 kB 21:39
1.31 kB 21:39
1.66 kB 21:39
1.13 kB 21:39
1.00 kB 21:39
3.70 kB 21:39
2.20 kB 21:39
1.82 kB 21:39
1.87 kB 21:39
4.46 kB 21:39
6.09 kB 21:40
1.79 kB 21:39
5.70 kB 21:39
1.07 kB 21:39
1.21 kB 21:39
2.09 kB 21:39
2.50 kB 21:40
8.06 kB 21:39
7.61 kB 21:39
1.03 kB 21:39
2.06 kB 21:39
2.89 kB 21:39
1.36 kB 21:39
5.93 kB 21:39
1.22 kB 21:39
1.00 kB 21:39
1.24 kB 21:39
1.49 kB 21:39
1.25 kB 21:39
1.38 kB 21:40
1.30 kB 21:39
1.48 kB 21:39
1.14 kB 21:39
1.23 kB 21:39
1.12 kB 21:39
1.18 kB 21:39
1.15 kB 21:39
1.43 kB 21:39
12.31 kB 21:39
1.86 kB 21:39
3.13 kB 21:39
1.29 kB 21:39
1.60 kB 21:39
1.09 kB 21:39
1.22 kB 21:39
3.86 kB 21:39
1.01 kB 21:39
2.99 kB 21:39
1.04 kB 21:39
6.84 kB 21:39
1.21 kB 21:39
2.00 kB 21:39
1.25 kB 21:39
1.69 kB 21:39
34.66 kB 21:39
81.82 kB 21:39
4.64 kB 21:39
8.95 kB 21:39
7.13 kB 21:39
5.93 kB 21:40
1.06 kB 21:39
1.05 kB 21:39
1.26 kB 21:39
1.03 kB 21:39
18.01 kB 14:47
51.89 kB 14:47
3.81 kB 21:39
15.92 kB 21:39
109.79 kB 14:45
36.17 kB 21:39
10.53 kB 21:39
5.21 kB 21:39
48.49 kB 21:39
139.90 kB 21:39
44.04 kB 21:39
54.60 kB 21:39
2.57 kB 21:39
4.73 kB 21:39
4.44 kB 21:39
5.58 kB 21:39
5.35 kB 21:39
2.56 kB 21:39
2.72 kB 21:39
2.32 kB 21:39
23.82 kB 21:39
8.73 kB 21:40
2.44 kB 21:39
7.73 kB 21:39
13.22 kB 21:39
2.73 kB 21:39
3.02 kB 21:39
5.41 kB 21:39
8.67 kB 21:39
5.57 kB 21:39
2.38 kB 21:39
2.36 kB 21:39
3.06 kB 21:39
24.74 kB 21:39
42.85 kB 21:39
6.86 kB 21:39
4.84 kB 21:39
49.29 kB 21:39
49.45 kB 21:39
23.36 kB 21:40
195.20 kB 21:39
364.95 kB 21:39
30.02 kB 21:39
16.60 kB 21:39
3.73 kB 21:39
3.35 kB 21:39
11.92 kB 21:39
31.22 kB 21:39
32.67 kB 21:39
5.23 kB 21:39
3.79 kB 21:39
71.66 kB 21:39
53.43 kB 21:39
11.45 kB 21:39
5.17 kB 21:39
3.24 kB 21:39
18.67 kB 21:39
29.68 kB 21:39
47.53 kB 21:39
10.49 kB 21:39
116.30 kB 21:39
9.92 kB 21:39
3.87 kB 21:39
100.95 kB 21:39
5.66 kB 21:39
29.60 kB 21:39
12.36 kB 21:39
12.96 kB 21:39
180.32 kB 21:39
12.44 kB 21:39
58.04 kB 21:39
7.53 kB 21:39
28.53 kB 21:39
3.70 kB 21:39
11.05 kB 21:40
72.39 kB 21:39
2.22 kB 21:39
2.31 kB 21:39
3.88 kB 21:39
72.25 kB 21:39
128.41 kB 21:39
75.66 kB 21:39
72.76 kB 21:39
160.58 kB 21:39
5.99 kB 21:39
16.71 kB 21:39
19.11 kB 21:39
51.75 kB 21:39
10.67 kB 21:39
10.93 kB 21:39
1.86 kB 21:39
16.70 kB 21:39
144.05 kB 21:39
18.69 kB 21:39
3.56 kB 21:39
31.55 kB 21:39
3.18 kB 21:39
3.93 kB 21:39
3.62 kB 21:39
2.53 kB 21:39
7.83 kB 21:39
2.51 kB 21:39
269.76 kB 21:39
3.55 kB 21:39
3.29 kB 21:39
3.91 kB 21:39
2.77 kB 21:39
2.54 kB 21:39
17.02 kB 21:39
26.75 kB 21:39
22.03 kB 21:40
67.37 kB 21:39
3.04 kB 21:39
3.22 kB 21:39
3.06 kB 21:39
2.57 kB 21:39
6.06 kB 21:39
6.59 kB 21:39
2.39 kB 21:39
11.38 kB 21:40
132.16 kB 21:39
13.40 kB 21:39
4.29 kB 21:39
2.26 kB 21:39
6.75 kB 21:39
234.94 kB 21:39
3.48 kB 21:39
49.90 kB 21:39
2.69 kB 21:39
22.44 kB 21:39
2.79 kB 21:39
2.74 kB 21:39
5.71 kB 21:39
5.33 kB 21:39
2.78 kB 21:39
2.88 kB 21:39
2.42 kB 21:39
4.04 kB 21:39
50.73 kB 21:39
2.97 kB 21:39
2.67 kB 21:40
2.52 kB 21:39
2.53 kB 21:39
2.68 kB 21:39
2.72 kB 21:39
2.79 kB 21:39
2.83 kB 21:39
2.86 kB 21:39
2.73 kB 21:39
2.35 kB 21:39
2.48 kB 21:39
168.35 kB 21:39
2.60 kB 21:39
219.94 kB 21:39
222.77 kB 21:39
19.86 kB 21:39
6.85 kB 21:39
2.65 kB 21:39
2.84 kB 21:39
2.77 kB 21:39
2.62 kB 21:39
2.60 kB 21:39
59.21 kB 21:39
172.49 kB 21:39
37.49 kB 21:39
63.01 kB 21:39
49.41 kB 21:39
91.35 kB 21:39
13.91 kB 21:39
10.09 kB 10:35
8.59 kB 21:39
10.23 kB 21:39
2.57 kB 21:39
6.79 kB 21:39
9.34 kB 21:39
34.10 kB 21:39
28.01 kB 21:39
62.85 kB 21:39
3.60 kB 21:39
11.58 kB 21:39
21.81 kB 21:39
27.43 kB 14:42
76.66 kB 21:39
26.46 kB 21:39
21.01 kB 21:39
11.39 kB 21:39
38.48 kB 21:39
15.53 kB 21:39
3.33 kB 21:39
64.46 kB 21:39
20.26 kB 21:39
5.94 kB 21:39
31.05 kB 21:39
46.32 kB 21:39
14.42 kB 21:39
38.84 kB 21:39
16.26 kB 21:39
52.90 kB 21:39
3.81 kB 21:39
9.72 kB 21:39
50.67 kB 21:39
10.24 kB 21:39
66.75 kB 21:39
73.71 kB 21:39
39.58 kB 21:39
32.78 kB 21:39
24.30 kB 21:39
6.06 kB 21:39
22.42 kB 21:39
33.13 kB 21:39
20.35 kB 21:39
73.99 kB 21:39
14.72 kB 21:39
287.01 kB 21:39
25.04 kB 21:39
10.85 kB 21:39
104.87 kB 21:39
18.08 kB 21:39
9.29 kB 21:39
4.51 kB 21:39
157.06 kB 21:39
10.89 kB 21:39
18.99 kB 21:39
14.30 kB 21:39
9.45 kB 21:39
12.56 kB 21:39
437.62 kB 21:39
76.04 kB 10:35
60.63 kB 21:39
20.97 kB 21:39
60.21 kB 21:39
12.25 kB 21:39
160.38 kB 21:39
9.09 kB 21:39
9.83 kB 21:39
603.10 kB 10:35
50.44 kB 21:39
1.04 MB 21:39
234.72 kB 21:39
5.83 kB 21:39
14.43 kB 21:39
122.21 kB 21:39
23.86 kB 21:39
3.60 kB 21:39
8.89 kB 21:39
52.63 kB 10:35
6.35 kB 21:39
14.61 kB 21:39
55.27 kB 21:39
5.61 kB 21:39
7.87 kB 21:39
33.72 kB 21:39
54.51 kB 21:39
7.26 kB 21:39
56.67 kB 21:39
113.94 kB 21:39
3.99 kB 21:39
5.10 kB 21:39
10.36 kB 21:39
32.06 kB 21:39
7.81 kB 21:39
19.80 kB 21:39
35.04 kB 21:39
5.12 kB 21:39
59.88 kB 21:39
11.45 kB 21:39
4.30 kB 21:39
195.46 kB 21:39
19.01 kB 21:39
3.42 kB 21:39
13.23 kB 21:39
28.41 kB 21:39
9.98 kB 21:39
50.15 kB 21:40
13.64 kB 21:39
4.09 kB 21:39
61.50 kB 21:39
96.56 kB 21:39
5.71 kB 21:39
14.84 kB 21:39
25.57 kB 21:39
60.84 kB 21:39
16.60 kB 21:39
9.03 kB 21:39
12.86 kB 21:39
30.34 kB 21:39
69.43 kB 21:39
282.89 kB 21:39
50.99 kB 21:40
3.97 kB 21:39
19.10 kB 21:39
5.41 kB 21:39
153.49 kB 21:39
13.25 kB 21:39
6.78 kB 21:39
4.87 kB 21:39
62.20 kB 21:39
6.83 kB 21:39
3.02 kB 21:39
8.77 kB 21:39
7.82 kB 21:39
98.10 kB 21:39
113.31 kB 21:39
37.61 kB 21:39
20.98 kB 21:39
7.57 kB 21:39
84.00 kB 21:39
4.35 kB 21:39
5.21 kB 21:39
18.95 kB 21:39
24.37 kB 21:39
24.30 kB 21:39
26.90 kB 21:39
59.39 kB 21:39
106.33 kB 21:39
2.96 kB 21:39
9.53 kB 21:39
24.55 kB 21:39
14.39 kB 21:39
2.60 kB 21:40
16.01 kB 21:39
24.87 kB 21:39
48.95 kB 21:39
32.91 kB 21:39
7.83 kB 21:39
8.92 kB 21:39
30.34 kB 21:39
134.82 kB 21:39
13.06 kB 21:39
7.31 kB 21:39
22.10 kB 21:39
4.22 kB 21:39
8.16 kB 21:39
30.67 kB 21:39
12.07 kB 21:39
22.55 kB 21:39
38.31 kB 21:39
24.83 kB 21:39
23.37 kB 21:39
23.41 kB 21:39
54.54 kB 21:39
33.49 kB 21:39
1.07 MB 21:49
28.18 kB 21:39
99.59 kB 21:39
376.63 kB 21:39
40.07 kB 21:39
51.77 kB 21:39
240.51 kB 21:39
16.56 kB 21:39
2.34 kB 21:39
58.53 kB 21:39
34.16 kB 21:39
41.12 kB 21:39
4.08 kB 21:39
11.35 kB 21:39
36.06 kB 21:39
1.63 kB 21:39
9.10 kB 21:39
7.78 kB 21:39
67.30 kB 21:39
30.21 kB 21:39
16.36 kB 21:39
43.34 kB 21:39
25.92 kB 21:39
16.85 kB 21:39
8.45 kB 21:39
81.12 kB 21:39
17.61 kB 21:39
12.07 kB 21:39
39.52 kB 21:39
14.20 kB 21:39
55.80 kB 21:39
33.64 kB 21:39
34.17 kB 21:39
16.37 kB 21:39
11.81 kB 21:39
22.87 kB 21:39
18.73 kB 21:39
8.02 kB 21:39
21.67 kB 21:39
24.40 kB 21:39
19.33 kB 21:39
27.48 kB 21:39
6.02 kB 21:39
17.65 kB 21:39
27.06 kB 21:39
120.17 kB 21:39
8.88 kB 21:39
24.35 kB 21:39
48.11 kB 21:39
9.51 kB 21:39
84.06 kB 21:39
64.57 kB 21:39
94.89 kB 21:39
62.34 kB 21:39
5.62 kB 21:39
18.25 kB 21:39
26.57 kB 21:39
18.30 kB 21:39
24.65 kB 21:39
180.57 kB 21:39
14.05 kB 21:39
161.27 kB 21:39
6.04 kB 21:39
11.95 kB 21:39
4.68 kB 21:39
12.73 kB 21:39
5.08 kB 21:39
10.95 kB 21:39
8.23 kB 21:39
7.75 kB 21:39
3.43 kB 21:39
8.00 kB 21:39
12.89 kB 21:40
7.99 kB 21:39
99.62 kB 21:39
11.39 kB 21:39
6.84 kB 21:39
3.58 kB 21:39
4.26 kB 21:39
161.87 kB 21:39
10.31 kB 21:39
53.90 kB 21:39
5.76 kB 21:39
24.01 kB 21:40
70.09 kB 21:39
32.19 kB 10:35
2.33 kB 21:39
20.52 kB 21:39
3.21 kB 21:39
13.39 kB 21:39
78.92 kB 21:39
12.07 kB 21:39
208.51 kB 21:39
119.84 kB 21:39
6.24 kB 21:39
33.73 kB 21:39
6.09 kB 21:39
41.63 kB 21:39
31.98 kB 21:39
72.81 kB 21:39
82.94 kB 21:39
4.07 kB 21:39
154.90 kB 21:39
21.27 kB 21:39
7.96 kB 21:39
25.75 kB 21:39
115.68 kB 21:39
36.72 kB 21:39
7.39 kB 21:39
30.91 kB 21:39
7.20 kB 21:39
114.08 kB 21:40
9.92 kB 21:39
500.99 kB 21:39
84.10 kB 21:39
29.68 kB 21:39
16.42 kB 21:39
110.82 kB 21:39
2.98 kB 21:39
17.30 kB 21:39
69.84 kB 21:39
32.66 kB 21:39
45.02 kB 21:39
3.85 kB 21:39
4.17 kB 21:39
65.96 kB 21:39
11.44 kB 21:39
28.16 kB 21:39
122.83 kB 21:39
3.31 kB 21:39
9.39 kB 21:39
11.00 kB 21:39
113.17 kB 21:39
3.21 kB 21:39
7.75 kB 21:39
36.26 kB 21:39
33.46 kB 21:39
7.71 kB 21:39
71.54 kB 21:39
106.05 kB 21:39
69.03 kB 21:39
4.44 kB 21:39
41.26 kB 21:39
10.54 kB 21:39
5.48 kB 21:39
9.67 kB 21:39
2.79 kB 21:39
37.89 kB 21:39
10.23 kB 21:39
21.82 kB 21:39
13.42 kB 21:39
6.75 kB 21:39
6.38 kB 21:39
15.41 kB 21:39
68.12 kB 21:39
11.95 kB 21:39
9.76 kB 21:39
48.58 kB 21:39
29.18 kB 21:39
4.84 kB 21:39
11.12 kB 21:39
19.12 kB 21:39
9.03 kB 21:39
189.57 kB 21:40
37.88 kB 21:39
21.39 kB 21:39
3.62 kB 21:39
8.31 kB 21:39
85.27 kB 21:39
9.49 kB 21:39
233.11 kB 21:39
53.37 kB 21:39
32.39 kB 21:39
151.00 kB 21:39
76.79 kB 21:39
7.26 kB 21:40
62.85 kB 21:39
106.16 kB 21:39
116.11 kB 21:39
87.95 kB 21:40
14.09 kB 21:39
4.78 kB 21:39
<img src='/images/file_icons/folder.png' alt='源码文件 '>&packe&0.00 B
Sponsored links
23 篇源代码 21 篇源代码 18 篇源代码 13 篇源代码 9 篇源代码
285 篇源代码 173 篇源代码 48 篇源代码 42 篇源代码 36 篇源代码
评价成功，多谢！
您的CF币不足
支付宝优惠套餐快速获取 10 CF币
支付宝订单完成后，CF币将自动加入到您的账号。以下是优惠期的人民币价格，优惠期过后将恢复美元价格。
您本次下载所消耗的CF币将转交上传作者。
同一源码，30天内重复下载，只扣除一次CF币。
登录 CodeForge
还没有CodeForge账号？
Switch to the English version?
^_^"呃 ...
Sorry!这位大神很神秘，未开通博客呢，请浏览一下其他的吧
请按 Ctrl+D 键添加到收藏夹。}