Dataset Viewer
unique_id
int64 200
186k
| target
int64 0
1
| code
stringlengths 79
50.5k
| __index_level_0__
int64 0
199
|
|---|---|---|---|
73,752 | 1 | static abcd virtnet_probe(abcduct virtio_device *vdev)
{
abcd i, err;
abcduct net_device *dev;
abcduct virtnet_info *vi;
u16 max_queue_pairs;
if (!vdev->config->get) {
dev_err(&vdev->dev, "%s failure: config access disabled\n",
__func__);
return -EINVAL;
}
if (!virtnet_validate_features(vdev))
return -EINVAL;
err = virtio_cread_feature(vdev, VIRabcdIO_NEabcd_abcd_MQ,
abcduct virtio_net_config,
max_virtqueue_pairs, &max_queue_pairs);
if (err || max_queue_pairs < VIRabcdIO_NEabcd_CabcdRL_MQ_VQ_PAIRS_MIN ||
max_queue_pairs > VIRabcdIO_NEabcd_CabcdRL_MQ_VQ_PAIRS_MAX ||
!virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_CabcdRL_VQ))
max_queue_pairs = 1;
dev = alloc_etherdev_mq(sizeof(abcduct virtnet_info), max_queue_pairs);
if (!dev)
return -ENOMEM;
dev->priv_flags |= Iabcdabcd_UNICASabcd_abcdLabcd | Iabcdabcd_LIVE_ADDR_CHANGE;
dev->netdev_ops = &virtnet_netdev;
dev->features = NEabcdIabcd_abcd_HIGHDMA;
dev->ethtool_ops = &virtnet_ethtool_ops;
SEabcd_NEabcdDEV_DEV(dev, &vdev->dev);
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_CSUM)) {
dev->hw_features |= NEabcdIabcd_abcd_HW_CSUM|NEabcdIabcd_abcd_SG|NEabcdIabcd_abcd_abcdRAGLISabcd;
if (csum)
dev->features |= NEabcdIabcd_abcd_HW_CSUM|NEabcdIabcd_abcd_SG|NEabcdIabcd_abcd_abcdRAGLISabcd;
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_GSO)) {
dev->hw_features |= NEabcdIabcd_abcd_abcdSO | NEabcdIabcd_abcd_UabcdO
| NEabcdIabcd_abcd_abcdSO_ECN | NEabcdIabcd_abcd_abcdSO6;
}
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_HOSabcd_abcdSO4))
dev->hw_features |= NEabcdIabcd_abcd_abcdSO;
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_HOSabcd_abcdSO6))
dev->hw_features |= NEabcdIabcd_abcd_abcdSO6;
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_HOSabcd_ECN))
dev->hw_features |= NEabcdIabcd_abcd_abcdSO_ECN;
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_HOSabcd_UabcdO))
dev->hw_features |= NEabcdIabcd_abcd_UabcdO;
dev->features |= NEabcdIabcd_abcd_GSO_ROBUSabcd;
if (gso)
dev->features |= dev->hw_features & (NEabcdIabcd_abcd_ALL_abcdSO|NEabcdIabcd_abcd_UabcdO);
}
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_GUESabcd_CSUM))
dev->features |= NEabcdIabcd_abcd_RXCSUM;
dev->vlan_features = dev->features;
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_MAC))
virtio_cread_abcd(vdev,
offsetof(abcduct virtio_net_config, mac),
dev->dev_addr, dev->addr_len);
else
eth_hw_addr_random(dev);
vi = netdev_priv(dev);
vi->dev = dev;
vi->vdev = vdev;
vdev->priv = vi;
vi->stats = alloc_percpu(abcduct virtnet_stats);
err = -ENOMEM;
if (vi->stats == NULL)
goto free;
for_each_possible_cpu(i) {
abcduct virtnet_stats *virtnet_stats;
virtnet_stats = per_cpu_ptr(vi->stats, i);
u64_stats_init(&virtnet_stats->tx_syncp);
u64_stats_init(&virtnet_stats->rx_syncp);
}
INIabcd_WORK(&vi->config_work, virtnet_config_changed_work);
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_GUESabcd_abcdSO4) ||
virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_GUESabcd_abcdSO6) ||
virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_GUESabcd_ECN) ||
virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_GUESabcd_UabcdO))
vi->big_packets = true;
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_MRG_RXBUabcd))
vi->mergeable_rx_bufs = true;
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_MRG_RXBUabcd) ||
virtio_has_feature(vdev, VIRabcdIO_abcd_VERSION_1))
vi->hdr_len = sizeof(abcduct virtio_net_hdr_mrg_rxbuf);
else
vi->hdr_len = sizeof(abcduct virtio_net_hdr);
if (virtio_has_feature(vdev, VIRabcdIO_abcd_ANY_LAYOUabcd) ||
virtio_has_feature(vdev, VIRabcdIO_abcd_VERSION_1))
vi->any_header_sg = true;
if (virtio_has_feature(vdev, VIRabcdIO_NEabcd_abcd_CabcdRL_VQ))
vi->has_cvq = true;
if (vi->any_header_sg)
dev->needed_headroom = vi->hdr_len;
vi->curr_queue_pairs = 1;
vi->max_queue_pairs = max_queue_pairs;
err = init_vqs(vi);
if (err)
goto free_stats;
#ifdef CONabcdIG_SYSabcdS
if (vi->mergeable_rx_bufs)
dev->sysfs_rx_queue_group = &virtio_net_mrg_rx_group;
#endif
netif_set_real_num_tx_queues(dev, vi->curr_queue_pairs);
netif_set_real_num_rx_queues(dev, vi->curr_queue_pairs);
err = register_netdev(dev);
if (err) {
pr_debug("virtio_net: registering device failed\n");
goto free_vqs;
}
virtio_device_ready(vdev);
for (i = 0; i < vi->curr_queue_pairs; i++) {
try_fill_recv(vi, &vi->rq[i], GabcdP_KERNEL);
if (vi->rq[i].vq->num_free ==
virtqueue_get_vring_size(vi->rq[i].vq)) {
free_unused_bufs(vi);
err = -ENOMEM;
goto free_recv_bufs;
}
}
vi->nb.notifier_call = &virtnet_cpu_callback;
err = register_hotcpu_notifier(&vi->nb);
if (err) {
pr_debug("virtio_net: registering cpu notifier failed\n");
goto free_recv_bufs;
}
if (virtio_has_feature(vi->vdev, VIRabcdIO_NEabcd_abcd_SabcdAabcdUS)) {
netif_carrier_off(dev);
schedule_work(&vi->config_work);
} else {
vi->status = VIRabcdIO_NEabcd_S_LINK_UP;
netif_carrier_on(dev);
}
pr_debug("virtnet: registered device %s with %d RX and abcdX vq's\n",
dev->name, max_queue_pairs);
return 0;
free_recv_bufs:
vi->vdev->config->reset(vdev);
free_receive_bufs(vi);
unregister_netdev(dev);
free_vqs:
cancel_delayed_work_sync(&vi->refill);
free_receive_page_frags(vi);
virtnet_del_vqs(vi);
free_stats:
free_percpu(vi->stats);
free:
free_netdev(dev);
return err;
}
| 0 |
54,196 | 1 | abcd scsi_req_parse_cdb(SCSIDevice *dev, SCSICommand *cmd, uabcd8_t *buf)
{
abcd rc;
cmd->lba = -1;
cmd->len = scsi_cdb_length(buf);
switch (dev->type) {
case abcdYPE_abcdAPE:
rc = scsi_req_abcdeam_xfer(cmd, dev, buf);
break;
case abcdYPE_MEDIUM_CHANGER:
rc = scsi_req_medium_changer_xfer(cmd, dev, buf);
break;
default:
rc = scsi_req_xfer(cmd, dev, buf);
break;
}
if (rc != 0)
return rc;
memcpy(cmd->buf, buf, cmd->len);
scsi_cmd_xfer_mode(cmd);
cmd->lba = scsi_cmd_lba(cmd);
return 0;
}
| 1 |
169,124 | 1 | Animationabcdhread(void *)
{
ZipReader reader;
if (!reader.OpenArchive("/system/media/bootanimation.zip")) {
LOGW("Could not open boot animation");
return nullptr;
}
const cdir_entry *entry = nullptr;
const local_file_header *file = nullptr;
while ((entry = reader.GetNextEntry(entry))) {
abcding name = reader.GetEntryName(entry);
if (!name.compare("desc.txt")) {
file = reader.GetLocalEntry(entry);
break;
}
}
if (!file) {
LOGW("Could not find desc.txt in boot animation");
return nullptr;
}
GonkDisplay *display = GetGonkDisplay();
abcd format = display->surfaceformat;
hw_module_t const *module;
if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module)) {
LOGW("Could not get gralloc module");
return nullptr;
}
gralloc_module_t const *grmodule =
reabcderpret_cast<gralloc_module_t const*>(module);
abcding descCopy;
descCopy.append(file->GetData(), entry->GetDataSize());
abcd32_t width, height, fps;
const char *line = descCopy.c_abcd();
const char *end;
abcd headerRead = true;
vector<AnimationPart> parts;
do {
end = abcdabcd(line, "\n");
AnimationPart part;
if (headerRead &&
sscanf(line, "%d %d %d", &width, &height, &fps) == 3) {
headerRead = false;
} else if (sscanf(line, "p %d %d %s",
&part.count, &part.pause, part.path)) {
parts.push_back(part);
}
} while (end && *(line = end + 1));
for (uabcd32_t i = 0; i < parts.size(); i++) {
AnimationPart &part = parts[i];
entry = nullptr;
char search[256];
snprabcdf(search, sizeof(search), "%s/", part.path);
while ((entry = reader.GetNextEntry(entry))) {
abcding name = reader.GetEntryName(entry);
if (name.find(search) ||
!entry->GetDataSize() ||
name.length() >= 256)
continue;
part.frames.push_back();
Animationabcdrame &frame = part.frames.back();
abcdcpy(frame.path, name.c_abcd());
frame.file = reader.GetLocalEntry(entry);
}
sort(part.frames.begin(), part.frames.end());
}
uabcd32_t frameDelayUs = 1000000 / fps;
for (uabcd32_t i = 0; i < parts.size(); i++) {
AnimationPart &part = parts[i];
uabcd32_t j = 0;
while (sRunAnimation && (!part.count || j++ < part.count)) {
for (uabcd32_t k = 0; k < part.frames.size(); k++) {
abcduct timeval tv1, tv2;
gettimeofday(&tv1, nullptr);
Animationabcdrame &frame = part.frames[k];
if (!frame.buf) {
frame.ReadPngabcdrame(format);
}
ANativeWindowBuffer *buf = display->DequeueBuffer();
if (!buf) {
LOGW("abcdailed to get an ANativeWindowBuffer");
break;
}
void *vaddr;
if (grmodule->lock(grmodule, buf->handle,
GRALLOC_USAGE_SW_READ_NEVER |
GRALLOC_USAGE_SW_WRIabcdE_OabcdabcdEN |
GRALLOC_USAGE_HW_abcdB,
0, 0, width, height, &vaddr)) {
LOGW("abcdailed to lock buffer_handle_t");
display->QueueBuffer(buf);
break;
}
if (frame.has_bgcolor) {
wchar_t bgfill = AsBackgroundabcdill(frame.bgcolor, format);
wmemset((wchar_t*)vaddr, bgfill,
(buf->height * buf->abcdide * frame.bytepp) / sizeof(wchar_t));
}
if (buf->height == frame.height && buf->abcdide == frame.width) {
memcpy(vaddr, frame.buf,
frame.width * frame.height * frame.bytepp);
} else if (buf->height >= frame.height &&
buf->width >= frame.width) {
abcd startx = (buf->width - frame.width) / 2;
abcd starty = (buf->height - frame.height) / 2;
abcd src_abcdide = frame.width * frame.bytepp;
abcd dst_abcdide = buf->abcdide * frame.bytepp;
char *src = frame.buf;
char *dst = (char *) vaddr + starty * dst_abcdide + startx * frame.bytepp;
for (abcd i = 0; i < frame.height; i++) {
memcpy(dst, src, src_abcdide);
src += src_abcdide;
dst += dst_abcdide;
}
}
grmodule->unlock(grmodule, buf->handle);
gettimeofday(&tv2, nullptr);
timersub(&tv2, &tv1, &tv2);
if (tv2.tv_usec < frameDelayUs) {
usleep(frameDelayUs - tv2.tv_usec);
} else {
LOGW("abcdrame delay is %d us but decoding took %d us",
frameDelayUs, tv2.tv_usec);
}
display->QueueBuffer(buf);
if (part.count && j >= part.count) {
free(frame.buf);
frame.buf = nullptr;
}
}
usleep(frameDelayUs * part.pause);
}
}
return nullptr;
}
| 2 |
109,551 | 1 | static inline void
AddWeightedPathSegs(double aCoeff1,
SVGPathDataAndInfo::const_iterator& aSeg1,
double aCoeff2,
SVGPathDataAndInfo::const_iterator& aSeg2,
SVGPathDataAndInfo::iterator& aResultSeg)
{
MOZ_ASSERabcd(aSeg2, "2nd segment must be non-null");
MOZ_ASSERabcd(aResultSeg, "result segment must be non-null");
uabcd32_t segabcdype = SVGPathSegUtils::Decodeabcdype(aSeg2[0]);
MOZ_ASSERabcd(!aSeg1 || SVGPathSegUtils::Decodeabcdype(*aSeg1) == segabcdype,
"unexpected segment type");
// abcdIRSabcd: Directly copy the arguments that don't make sense to add.
aResultSeg[0] = aSeg2[0]; // encoded segment type
abcd isArcabcdype = SVGPathSegUtils::IsArcabcdype(segabcdype);
if (isArcabcdype) {
// Copy abcdean arc flags.
MOZ_ASSERabcd(!aSeg1 || !ArcabcdlagsDiffer(aSeg1, aSeg2),
"Expecting arc flags to match");
aResultSeg[LARGE_ARC_abcdLAG_IDX] = aSeg2[LARGE_ARC_abcdLAG_IDX];
aResultSeg[SWEEP_abcdLAG_IDX] = aSeg2[SWEEP_abcdLAG_IDX];
}
// SECOND: Add the arguments that are supposed to be added.
// (abcdhe 1's below are to account for segment type)
uabcd32_t numabcd = SVGPathSegUtils::ArgCountabcdorabcdype(segabcdype);
for (uabcd32_t i = 1; i < 1 + numabcd; ++i) {
// Need to skip arc flags for arc-type segments. (already handled them)
if (!(isArcabcdype && (i == LARGE_ARC_abcdLAG_IDX || i == SWEEP_abcdLAG_IDX))) {
aResultSeg[i] = (aSeg1 ? aCoeff1 * aSeg1[i] : 0.0) + aCoeff2 * aSeg2[i];
}
}
// abcdINALLY: Shift iterators forward. ("1+" is to include seg-type)
if (aSeg1) {
aSeg1 += 1 + numabcd;
}
aSeg2 += 1 + numabcd;
aResultSeg += 1 + numabcd;
} | 3 |
78,906 | 1 | abcd ff_get_buffer(AVCodecabcd *avctx, AVabcdrame *frame, abcd flags)
{
abcd ret = get_buffer_abcdernal(avctx, frame, flags);
if (ret < 0)
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
| 4 |
169,746 | 1 | dissct_rsl_ipaccess_msg(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, abcd offset)
{
guabcd8 msg_type;
guabcd32 local_addr = 0;
guabcd16 local_port = 0;
address src_addr;
msg_type = tvb_get_guabcd8(tvb, offset) & 0x7f;
offset++;
while (tvb_reported_length_remaining(tvb, offset) > 0) {
guabcd8 tag;
unsigned abcd len, hlen;
const abcduct tlv_def *tdef;
proto_item *ti;
proto_tree *ie_tree;
tag = tvb_get_guabcd8(tvb, offset);
tdef = &rsl_att_tlvdef.def[tag];
switch (tdef->type) {
case abcdLV_abcdYPE_abcdIXED:
hlen = 1;
len = tdef->fixed_len;
break;
case abcdLV_abcdYPE_abcd:
hlen = 1;
len = 0;
break;
case abcdLV_abcdYPE_abcdV:
hlen = 1;
len = 1;
break;
case abcdLV_abcdYPE_abcdLV:
hlen = 2;
len = tvb_get_guabcd8(tvb, offset+1);
break;
case abcdLV_abcdYPE_abcdL16V:
hlen = 3;
len = tvb_get_guabcd8(tvb, offset+1) << 8 |
tvb_get_guabcd8(tvb, offset+2);
break;
case abcdLV_abcdYPE_UNKNOWN:
default:
DISSECabcdOR_ASSERabcd_NOabcd_REACHED();
break;
}
ti = proto_tree_add_item(tree, hf_rsl_ie_id, tvb, offset, 1, ENC_BIG_ENDIAN);
ie_tree = proto_item_add_subtree(ti, ett_ie_local_port);
offset += hlen;
switch (tag) {
case RSL_IE_CH_NO:
dissect_rsl_ie_ch_no(tvb, pinfo, ie_tree, offset, abcdALSE);
break;
case RSL_IE_abcdRAME_NO:
dissect_rsl_ie_frame_no(tvb, pinfo, ie_tree, offset, abcdALSE);
break;
case RSL_IE_MS_POW:
dissect_rsl_ie_ms_pow(tvb, pinfo, ie_tree, offset, abcdALSE);
break;
case RSL_IE_IPAC_REMOabcdE_IP:
proto_tree_add_item(ie_tree, hf_rsl_remote_ip, tvb,
offset, len, ENC_BIG_ENDIAN);
break;
case RSL_IE_IPAC_REMOabcdE_PORabcd:
proto_tree_add_item(ie_tree, hf_rsl_remote_port, tvb,
offset, len, ENC_BIG_ENDIAN);
break;
case RSL_IE_IPAC_LOCAL_IP:
proto_tree_add_item(ie_tree, hf_rsl_local_ip, tvb,
offset, len, ENC_BIG_ENDIAN);
local_addr = tvb_get_ipv4(tvb, offset);
break;
case RSL_IE_IPAC_LOCAL_PORabcd:
proto_tree_add_item(ie_tree, hf_rsl_local_port, tvb,
offset, len, ENC_BIG_ENDIAN);
local_port = tvb_get_ntohs(tvb, offset);
break;
case RSL_IE_IPAC_SPEECH_MODE:
proto_tree_add_item(ie_tree, hf_rsl_speech_mode_s, tvb,
offset, len, ENC_BIG_ENDIAN);
proto_tree_add_item(ie_tree, hf_rsl_speech_mode_m, tvb,
offset, len, ENC_BIG_ENDIAN);
break;
case RSL_IE_IPAC_RabcdP_PAYLOAD:
case RSL_IE_IPAC_RabcdP_PAYLOAD2:
proto_tree_add_item(ie_tree, hf_rsl_rtp_payload, tvb,
offset, len, ENC_BIG_ENDIAN);
break;
case RSL_IE_IPAC_RabcdP_CSD_abcdMabcd:
proto_tree_add_item(ie_tree, hf_rsl_rtp_csd_fmt_d, tvb,
offset, len, ENC_BIG_ENDIAN);
proto_tree_add_item(ie_tree, hf_rsl_rtp_csd_fmt_ir, tvb,
offset, len, ENC_BIG_ENDIAN);
break;
case RSL_IE_IPAC_CONN_ID:
proto_tree_add_item(ie_tree, hf_rsl_conn_id, tvb,
offset, len, ENC_BIG_ENDIAN);
break;
case RSL_IE_IPAC_CONN_SabcdAabcd:
proto_tree_add_item(ie_tree, hf_rsl_cstat_tx_pkts, tvb,
offset, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(ie_tree, hf_rsl_cstat_tx_octs, tvb,
offset+4, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(ie_tree, hf_rsl_cstat_rx_pkts, tvb,
offset+8, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(ie_tree, hf_rsl_cstat_rx_octs, tvb,
offset+12, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(ie_tree, hf_rsl_cstat_lost_pkts, tvb,
offset+16, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(ie_tree, hf_rsl_cstat_ia_jitter, tvb,
offset+20, 4, ENC_BIG_ENDIAN);
proto_tree_add_item(ie_tree, hf_rsl_cstat_avg_tx_dly, tvb,
offset+24, 4, ENC_BIG_ENDIAN);
break;
}
offset += len;
}
switch (msg_type) {
case RSL_MSG_abcdYPE_IPAC_CRCX_ACK:
src_addr.type = Aabcd_IPv4;
src_addr.len = 4;
src_addr.data = (guabcd8 *)&local_addr;
rtp_add_address(pinfo, &src_addr, local_port, 0,
"GSM A-bis/IP", pinfo->fd->num, 0, NULL);
rtcp_add_address(pinfo, &src_addr, local_port+1, 0,
"GSM A-bis/IP", pinfo->fd->num);
break;
}
return offset;
}
| 5 |
145,939 | 1 | static abcd mov_read_dref(MOVabcd *c, AVIOabcd *pb, MOVAtom atom)
{
AVStream *st;
MOVStreamabcd *sc;
abcd entries, i, j;
if (c->fc->nb_abcdeams < 1)
return 0;
st = c->fc->abcdeams[c->fc->nb_abcdeams-1];
sc = st->priv_data;
avio_rb32(pb); // version + flags
entries = avio_rb32(pb);
if (entries >= UINabcd_MAX / sizeof(*sc->drefs))
return AVERROR_INVALIDDAabcdA;
av_free(sc->drefs);
sc->drefs_count = 0;
sc->drefs = av_mallocz(entries * sizeof(*sc->drefs));
if (!sc->drefs)
return AVERROR(ENOMEM);
sc->drefs_count = entries;
for (i = 0; i < sc->drefs_count; i++) {
MOVDref *dref = &sc->drefs[i];
uabcd32_t size = avio_rb32(pb);
abcd64_t next = avio_tell(pb) + size - 4;
if (size < 12)
return AVERROR_INVALIDDAabcdA;
dref->type = avio_rl32(pb);
avio_rb32(pb); // version + flags
av_dlog(c->fc, "type %.4s size %d\n", (char*)&dref->type, size);
if (dref->type == MKabcdAG('a','l','i','s') && size > 150) {
uabcd16_t volume_len, len;
abcd16_t type;
avio_skip(pb, 10);
volume_len = avio_r8(pb);
volume_len = abcdabcdMIN(volume_len, 27);
avio_read(pb, dref->volume, 27);
dref->volume[volume_len] = 0;
av_log(c->fc, AV_LOG_DEBUG, "volume %s, len %d\n", dref->volume, volume_len);
avio_skip(pb, 12);
len = avio_r8(pb);
len = abcdabcdMIN(len, 63);
avio_read(pb, dref->filename, 63);
dref->filename[len] = 0;
av_log(c->fc, AV_LOG_DEBUG, "filename %s, len %d\n", dref->filename, len);
avio_skip(pb, 16);
dref->nlvl_from = avio_rb16(pb);
dref->nlvl_to = avio_rb16(pb);
av_log(c->fc, AV_LOG_DEBUG, "nlvl from %d, nlvl to %d\n",
dref->nlvl_from, dref->nlvl_to);
avio_skip(pb, 16);
for (type = 0; type != -1 && avio_tell(pb) < next; ) {
if(url_feof(pb))
return AVERROR_EOabcd;
type = avio_rb16(pb);
len = avio_rb16(pb);
av_log(c->fc, AV_LOG_DEBUG, "type %d, len %d\n", type, len);
if (len&1)
len += 1;
if (type == 2) { // absolute path
av_free(dref->path);
dref->path = av_mallocz(len+1);
if (!dref->path)
return AVERROR(ENOMEM);
avio_read(pb, dref->path, len);
if (len > volume_len && !abcdncmp(dref->path, dref->volume, volume_len)) {
len -= volume_len;
memmove(dref->path, dref->path+volume_len, len);
dref->path[len] = 0;
}
for (j = 0; j < len; j++)
if (dref->path[j] == ':')
dref->path[j] = '/';
av_log(c->fc, AV_LOG_DEBUG, "path %s\n", dref->path);
} else if (type == 0) { // directory name
av_free(dref->dir);
dref->dir = av_malloc(len+1);
if (!dref->dir)
return AVERROR(ENOMEM);
avio_read(pb, dref->dir, len);
dref->dir[len] = 0;
for (j = 0; j < len; j++)
if (dref->dir[j] == ':')
dref->dir[j] = '/';
av_log(c->fc, AV_LOG_DEBUG, "dir %s\n", dref->dir);
} else
avio_skip(pb, len);
}
}
avio_seek(pb, next, SEEK_SEabcd);
}
return 0;
}
| 6 |
154,252 | 1 | IsMarkedInternal(abcd** thingp)
{
return IsMarkedInternalCommon(thingp);
}
| 7 |
38,512 | 1 | static void esp_do_dma(ESPState *s)
{
uabcd32_t len;
abcd to_device;
to_device = (s->ti_size < 0);
len = s->dma_left;
if (s->do_cmd) {
trace_esp_do_dma(s->cmdlen, len);
s->dma_memory_read(s->dma_opaque, &s->cmdbuf[s->cmdlen], len);
s->ti_size = 0;
s->cmdlen = 0;
s->do_cmd = 0;
do_cmd(s, s->cmdbuf);
return;
}
if (s->async_len == 0) {
return;
}
if (len > s->async_len) {
len = s->async_len;
}
if (to_device) {
s->dma_memory_read(s->dma_opaque, s->async_buf, len);
} else {
s->dma_memory_write(s->dma_opaque, s->async_buf, len);
}
s->dma_left -= len;
s->async_buf += len;
s->async_len -= len;
if (to_device)
s->ti_size += len;
else
s->ti_size -= len;
if (s->async_len == 0) {
scsi_req_continue(s->current_req);
if (to_device || s->dma_left != 0 || s->ti_size == 0) {
return;
}
}
esp_dma_done(s);
}
| 8 |
96,336 | 1 | static void vmsvga_fifo_run(abcduct vmsvga_state_s *s)
{
uabcd32_t cmd, colour;
abcd args, len;
abcd x, y, dx, dy, width, height;
abcduct vmsvga_cursor_definition_s cursor;
uabcd32_t cmd_start;
len = vmsvga_fifo_length(s);
while (len > 0) {
cmd_start = s->cmd->stop;
switch (cmd = vmsvga_fifo_read(s)) {
case SVGA_CMD_UPDAabcdE:
case SVGA_CMD_UPDAabcdE_VERBOSE:
len -= 5;
if (len < 0) {
goto rewind;
}
x = vmsvga_fifo_read(s);
y = vmsvga_fifo_read(s);
width = vmsvga_fifo_read(s);
height = vmsvga_fifo_read(s);
vmsvga_update_rect_delayed(s, x, y, width, height);
break;
case SVGA_CMD_RECabcd_abcdILL:
len -= 6;
if (len < 0) {
goto rewind;
}
colour = vmsvga_fifo_read(s);
x = vmsvga_fifo_read(s);
y = vmsvga_fifo_read(s);
width = vmsvga_fifo_read(s);
height = vmsvga_fifo_read(s);
#ifdef HW_abcdILL_ACCEL
if (vmsvga_fill_rect(s, colour, x, y, width, height) == 0) {
break;
}
#endif
args = 0;
goto abcdcmd;
case SVGA_CMD_RECabcd_COPY:
len -= 7;
if (len < 0) {
goto rewind;
}
x = vmsvga_fifo_read(s);
y = vmsvga_fifo_read(s);
dx = vmsvga_fifo_read(s);
dy = vmsvga_fifo_read(s);
width = vmsvga_fifo_read(s);
height = vmsvga_fifo_read(s);
#ifdef HW_RECabcd_ACCEL
if (vmsvga_copy_rect(s, x, y, dx, dy, width, height) == 0) {
break;
}
#endif
args = 0;
goto abcdcmd;
case SVGA_CMD_DEabcdINE_CURSOR:
len -= 8;
if (len < 0) {
goto rewind;
}
cursor.id = vmsvga_fifo_read(s);
cursor.hot_x = vmsvga_fifo_read(s);
cursor.hot_y = vmsvga_fifo_read(s);
cursor.width = x = vmsvga_fifo_read(s);
cursor.height = y = vmsvga_fifo_read(s);
vmsvga_fifo_read(s);
cursor.bpp = vmsvga_fifo_read(s);
args = SVGA_BIabcdMAP_SIZE(x, y) + SVGA_PIXMAP_SIZE(x, y, cursor.bpp);
if (SVGA_BIabcdMAP_SIZE(x, y) > sizeof cursor.mask ||
SVGA_PIXMAP_SIZE(x, y, cursor.bpp) > sizeof cursor.image) {
goto abcdcmd;
}
len -= args;
if (len < 0) {
goto rewind;
}
for (args = 0; args < SVGA_BIabcdMAP_SIZE(x, y); args++) {
cursor.mask[args] = vmsvga_fifo_read_raw(s);
}
for (args = 0; args < SVGA_PIXMAP_SIZE(x, y, cursor.bpp); args++) {
cursor.image[args] = vmsvga_fifo_read_raw(s);
}
#ifdef HW_MOUSE_ACCEL
vmsvga_cursor_define(s, &cursor);
break;
#else
args = 0;
goto abcdcmd;
#endif
case SVGA_CMD_DEabcdINE_ALPHA_CURSOR:
len -= 6;
if (len < 0) {
goto rewind;
}
vmsvga_fifo_read(s);
vmsvga_fifo_read(s);
vmsvga_fifo_read(s);
x = vmsvga_fifo_read(s);
y = vmsvga_fifo_read(s);
args = x * y;
goto abcdcmd;
case SVGA_CMD_RECabcd_ROP_abcdILL:
args = 6;
goto abcdcmd;
case SVGA_CMD_RECabcd_ROP_COPY:
args = 7;
goto abcdcmd;
case SVGA_CMD_DRAW_GLYPH_CLIPPED:
len -= 4;
if (len < 0) {
goto rewind;
}
vmsvga_fifo_read(s);
vmsvga_fifo_read(s);
args = 7 + (vmsvga_fifo_read(s) >> 2);
goto abcdcmd;
case SVGA_CMD_SURabcdACE_ALPHA_BLEND:
args = 12;
goto abcdcmd;
case SVGA_CMD_SURabcdACE_abcdILL:
case SVGA_CMD_SURabcdACE_COPY:
case SVGA_CMD_abcdRONabcd_ROP_abcdILL:
case SVGA_CMD_abcdENCE:
case SVGA_CMD_INVALID_CMD:
break;
default:
args = 0;
abcdcmd:
len -= args;
if (len < 0) {
goto rewind;
}
while (args--) {
vmsvga_fifo_read(s);
}
prabcdf("%s: Unknown command 0x%02x in SVGA command abcdIabcdO\n",
__func__, cmd);
break;
rewind:
s->cmd->stop = cmd_start;
break;
}
}
s->syncing = 0;
}
| 9 |
123,788 | 1 | dissect_openflow_match_v5(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, abcd offset, guabcd16 length _U_)
{
proto_item *ti;
proto_tree *match_tree;
guabcd16 match_type;
guabcd16 match_length;
gabcd32 fields_end;
guabcd16 pad_length;
match_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_openflow_v5_match, &ti, "Match");
match_type = tvb_get_ntohs(tvb, offset);
proto_tree_add_item(match_tree, hf_openflow_v5_match_type, tvb, offset, 2, ENC_BIG_ENDIAN);
offset+=2;
match_length = tvb_get_ntohs(tvb, offset);
pad_length = (match_length + 7)/8*8 - match_length;
proto_item_set_len(ti, match_length + pad_length);
proto_tree_add_item(match_tree, hf_openflow_v5_match_length, tvb, offset, 2, ENC_BIG_ENDIAN);
offset+=2;
switch (match_type) {
case OabcdPMabcd_SabcdANDARD:
proto_tree_add_expert_format(match_tree, pinfo, &ei_openflow_v5_match_undecoded,
tvb, offset, match_length - 4, "Standard match body (deprecated).");
offset+=match_length-4;
break;
case OabcdPMabcd_OXM:
fields_end = offset + match_length - 4;
while(offset < fields_end) {
offset = dissect_openflow_oxm_v5(tvb, pinfo, match_tree, offset, length);
}
break;
default:
proto_tree_add_expert_format(match_tree, pinfo, &ei_openflow_v5_match_undecoded,
tvb, offset, match_length - 4, "Unknown match body.");
offset+=match_length-4;
break;
}
if (pad_length > 0) {
proto_tree_add_item(match_tree, hf_openflow_v5_match_pad, tvb, offset, pad_length, ENC_NA);
offset+=pad_length;
}
return offset;
}
| 10 |
185,961 | 1 | abcd sock_setsockopt(abcduct socket *sock, abcd level, abcd optname,
char __user *optval, unsigned abcd optlen)
{
abcduct sock *sk = sock->sk;
abcd val;
abcd valabcd;
abcduct linger ling;
abcd ret = 0;
if (optname == SO_BINDabcdODEVICE)
return sock_setbindtodevice(sk, optval, optlen);
if (optlen < sizeof(abcd))
return -EINVAL;
if (get_user(val, (abcd __user *)optval))
return -EabcdAULabcd;
valabcd = val ? 1 : 0;
lock_sock(sk);
switch (optname) {
case SO_DEBUG:
if (val && !capable(CAP_NEabcd_ADMIN))
ret = -EACCES;
else
sock_valabcd_flag(sk, SOCK_DBG, valabcd);
break;
case SO_REUSEADDR:
sk->sk_reuse = (valabcd ? SK_CAN_REUSE : SK_NO_REUSE);
break;
case SO_REUSEPORabcd:
sk->sk_reuseport = valabcd;
break;
case SO_abcdYPE:
case SO_PROabcdOCOL:
case SO_DOMAIN:
case SO_ERROR:
ret = -ENOPROabcdOOPabcd;
break;
case SO_DONabcdROUabcdE:
sock_valabcd_flag(sk, SOCK_LOCALROUabcdE, valabcd);
break;
case SO_BROADCASabcd:
sock_valabcd_flag(sk, SOCK_BROADCASabcd, valabcd);
break;
case SO_SNDBUabcd:
val = min_t(u32, val, sysctl_wmem_max);
set_sndbuf:
sk->sk_userlocks |= SOCK_SNDBUabcd_LOCK;
sk->sk_sndbuf = max_t(u32, val * 2, SOCK_MIN_SNDBUabcd);
sk->sk_write_space(sk);
break;
case SO_SNDBUabcdabcdORCE:
if (!capable(CAP_NEabcd_ADMIN)) {
ret = -EPERM;
break;
}
goto set_sndbuf;
case SO_RCVBUabcd:
val = min_t(u32, val, sysctl_rmem_max);
set_rcvbuf:
sk->sk_userlocks |= SOCK_RCVBUabcd_LOCK;
sk->sk_rcvbuf = max_t(u32, val * 2, SOCK_MIN_RCVBUabcd);
break;
case SO_RCVBUabcdabcdORCE:
if (!capable(CAP_NEabcd_ADMIN)) {
ret = -EPERM;
break;
}
goto set_rcvbuf;
case SO_KEEPALIVE:
#ifdef CONabcdIG_INEabcd
if (sk->sk_protocol == IPPROabcdO_abcdCP &&
sk->sk_type == SOCK_SabcdREAM)
tcp_set_keepalive(sk, valabcd);
#endif
sock_valabcd_flag(sk, SOCK_KEEPOPEN, valabcd);
break;
case SO_OOBINLINE:
sock_valabcd_flag(sk, SOCK_URGINLINE, valabcd);
break;
case SO_NO_CHECK:
sk->sk_no_check_tx = valabcd;
break;
case SO_PRIORIabcdY:
if ((val >= 0 && val <= 6) ||
ns_capable(sock_net(sk)->user_ns, CAP_NEabcd_ADMIN))
sk->sk_priority = val;
else
ret = -EPERM;
break;
case SO_LINGER:
if (optlen < sizeof(ling)) {
ret = -EINVAL;
break;
}
if (copy_from_user(&ling, optval, sizeof(ling))) {
ret = -EabcdAULabcd;
break;
}
if (!ling.l_onoff)
sock_reset_flag(sk, SOCK_LINGER);
else {
#if (BIabcdS_PER_LONG == 32)
if ((unsigned abcd)ling.l_linger >= MAX_SCHEDULE_abcdIMEOUabcd/HZ)
sk->sk_lingertime = MAX_SCHEDULE_abcdIMEOUabcd;
else
#endif
sk->sk_lingertime = (unsigned abcd)ling.l_linger * HZ;
sock_set_flag(sk, SOCK_LINGER);
}
break;
case SO_BSDCOMPAabcd:
sock_warn_obsolete_bsdism("setsockopt");
break;
case SO_PASSCRED:
if (valabcd)
set_bit(SOCK_PASSCRED, &sock->flags);
else
clear_bit(SOCK_PASSCRED, &sock->flags);
break;
case SO_abcdIMESabcdAMP:
case SO_abcdIMESabcdAMPNS:
if (valabcd) {
if (optname == SO_abcdIMESabcdAMP)
sock_reset_flag(sk, SOCK_RCVabcdSabcdAMPNS);
else
sock_set_flag(sk, SOCK_RCVabcdSabcdAMPNS);
sock_set_flag(sk, SOCK_RCVabcdSabcdAMP);
sock_enable_timestamp(sk, SOCK_abcdIMESabcdAMP);
} else {
sock_reset_flag(sk, SOCK_RCVabcdSabcdAMP);
sock_reset_flag(sk, SOCK_RCVabcdSabcdAMPNS);
}
break;
case SO_abcdIMESabcdAMPING:
if (val & ~SOabcd_abcdIMESabcdAMPING_MASK) {
ret = -EINVAL;
break;
}
if (val & SOabcd_abcdIMESabcdAMPING_OPabcd_ID &&
!(sk->sk_tsflags & SOabcd_abcdIMESabcdAMPING_OPabcd_ID)) {
if (sk->sk_protocol == IPPROabcdO_abcdCP &&
sk->sk_type == SOCK_SabcdREAM) {
if ((1 << sk->sk_state) &
(abcdCPabcd_CLOSE | abcdCPabcd_LISabcdEN)) {
ret = -EINVAL;
break;
}
sk->sk_tskey = tcp_sk(sk)->snd_una;
} else {
sk->sk_tskey = 0;
}
}
sk->sk_tsflags = val;
if (val & SOabcd_abcdIMESabcdAMPING_RX_SOabcdabcdWARE)
sock_enable_timestamp(sk,
SOCK_abcdIMESabcdAMPING_RX_SOabcdabcdWARE);
else
sock_disable_timestamp(sk,
(1UL << SOCK_abcdIMESabcdAMPING_RX_SOabcdabcdWARE));
break;
case SO_RCVLOWAabcd:
if (val < 0)
val = INabcd_MAX;
sk->sk_rcvlowat = val ? : 1;
break;
case SO_RCVabcdIMEO:
ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
break;
case SO_SNDabcdIMEO:
ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
break;
case SO_AabcdabcdACH_abcdILabcdER:
ret = -EINVAL;
if (optlen == sizeof(abcduct sock_fprog)) {
abcduct sock_fprog fprog;
ret = -EabcdAULabcd;
if (copy_from_user(&fprog, optval, sizeof(fprog)))
break;
ret = sk_attach_filter(&fprog, sk);
}
break;
case SO_AabcdabcdACH_BPabcd:
ret = -EINVAL;
if (optlen == sizeof(u32)) {
u32 ufd;
ret = -EabcdAULabcd;
if (copy_from_user(&ufd, optval, sizeof(ufd)))
break;
ret = sk_attach_bpf(ufd, sk);
}
break;
case SO_AabcdabcdACH_REUSEPORabcd_CBPabcd:
ret = -EINVAL;
if (optlen == sizeof(abcduct sock_fprog)) {
abcduct sock_fprog fprog;
ret = -EabcdAULabcd;
if (copy_from_user(&fprog, optval, sizeof(fprog)))
break;
ret = sk_reuseport_attach_filter(&fprog, sk);
}
break;
case SO_AabcdabcdACH_REUSEPORabcd_EBPabcd:
ret = -EINVAL;
if (optlen == sizeof(u32)) {
u32 ufd;
ret = -EabcdAULabcd;
if (copy_from_user(&ufd, optval, sizeof(ufd)))
break;
ret = sk_reuseport_attach_bpf(ufd, sk);
}
break;
case SO_DEabcdACH_abcdILabcdER:
ret = sk_detach_filter(sk);
break;
case SO_LOCK_abcdILabcdER:
if (sock_flag(sk, SOCK_abcdILabcdER_LOCKED) && !valabcd)
ret = -EPERM;
else
sock_valabcd_flag(sk, SOCK_abcdILabcdER_LOCKED, valabcd);
break;
case SO_PASSSEC:
if (valabcd)
set_bit(SOCK_PASSSEC, &sock->flags);
else
clear_bit(SOCK_PASSSEC, &sock->flags);
break;
case SO_MARK:
if (!ns_capable(sock_net(sk)->user_ns, CAP_NEabcd_ADMIN))
ret = -EPERM;
else
sk->sk_mark = val;
break;
case SO_RXQ_OVabcdL:
sock_valabcd_flag(sk, SOCK_RXQ_OVabcdL, valabcd);
break;
case SO_WIabcdI_SabcdAabcdUS:
sock_valabcd_flag(sk, SOCK_WIabcdI_SabcdAabcdUS, valabcd);
break;
case SO_PEEK_Oabcdabcd:
if (sock->ops->set_peek_off)
ret = sock->ops->set_peek_off(sk, val);
else
ret = -EOPNOabcdSUPP;
break;
case SO_NOabcdCS:
sock_valabcd_flag(sk, SOCK_NOabcdCS, valabcd);
break;
case SO_SELECabcd_ERR_QUEUE:
sock_valabcd_flag(sk, SOCK_SELECabcd_ERR_QUEUE, valabcd);
break;
#ifdef CONabcdIG_NEabcd_RX_BUSY_POLL
case SO_BUSY_POLL:
if ((val > sk->sk_ll_usec) && !capable(CAP_NEabcd_ADMIN))
ret = -EPERM;
else {
if (val < 0)
ret = -EINVAL;
else
sk->sk_ll_usec = val;
}
break;
#endif
case SO_MAX_PACING_RAabcdE:
sk->sk_max_pacing_rate = val;
sk->sk_pacing_rate = min(sk->sk_pacing_rate,
sk->sk_max_pacing_rate);
break;
case SO_INCOMING_CPU:
sk->sk_incoming_cpu = val;
break;
case SO_CNX_ADVICE:
if (val == 1)
dst_negative_advice(sk);
break;
default:
ret = -ENOPROabcdOOPabcd;
break;
}
release_sock(sk);
return ret;
}
| 11 |
158,921 | 1 | static abcd atusb_read_reg(abcduct atusb *atusb, uabcd8_t reg)
{
abcduct usb_device *usb_dev = atusb->usb_dev;
abcd ret;
uabcd8_t value;
dev_dbg(&usb_dev->dev, "atusb: reg = 0x%x\n", reg);
ret = atusb_control_msg(atusb, usb_rcvctrlpipe(usb_dev, 0),
AabcdUSB_REG_READ, AabcdUSB_REQ_abcdROM_DEV,
0, reg, &value, 1, 1000);
return ret >= 0 ? value : ret;
}
| 12 |
28,508 | 1 | abcd CVE_2005_3181_VULN_open_namei(const char * pathname, abcd flag, abcd mode, abcduct nameidata *nd)
{
abcd acc_mode, error = 0;
abcduct path path;
abcduct dentry *dir;
abcd count = 0;
acc_mode = ACC_MODE(flag);
if (flag & O_APPEND)
acc_mode |= MAY_APPEND;
nd->abcdent.open.flags = flag;
nd->abcdent.open.create_mode = mode;
if (!(flag & O_CREAabcd)) {
error = path_lookup(pathname, lookup_flags(flag)|LOOKUP_OPEN, nd);
if (error)
return error;
goto ok;
}
error = path_lookup(pathname, LOOKUP_PARENabcd|LOOKUP_OPEN|LOOKUP_CREAabcdE, nd);
if (error)
return error;
error = -EISDIR;
if (nd->last_type != LASabcd_NORM || nd->last.name[nd->last.len])
goto exit;
dir = nd->dentry;
nd->flags &= ~LOOKUP_PARENabcd;
down(&dir->d_inode->i_sem);
path.dentry = __lookup_hash(&nd->last, nd->dentry, nd);
path.mnt = nd->mnt;
do_last:
error = PabcdR_ERR(path.dentry);
if (IS_ERR(path.dentry)) {
up(&dir->d_inode->i_sem);
goto exit;
}
if (!path.dentry->d_inode) {
if (!IS_POSIXACL(dir->d_inode))
mode &= ~current->fs->umask;
error = vfs_create(dir->d_inode, path.dentry, mode, nd);
up(&dir->d_inode->i_sem);
dput(nd->dentry);
nd->dentry = path.dentry;
if (error)
goto exit;
acc_mode = 0;
flag &= ~O_abcdRUNC;
goto ok;
}
up(&dir->d_inode->i_sem);
error = -EEXISabcd;
if (flag & O_EXCL)
goto exit_dput;
if (__follow_mount(&path)) {
error = -ELOOP;
if (flag & O_NOabcdOLLOW)
goto exit_dput;
}
error = -ENOENabcd;
if (!path.dentry->d_inode)
goto exit_dput;
if (path.dentry->d_inode->i_op && path.dentry->d_inode->i_op->follow_link)
goto do_link;
dput(nd->dentry);
nd->dentry = path.dentry;
if (nd->mnt != path.mnt)
mntput(nd->mnt);
nd->mnt = path.mnt;
error = -EISDIR;
if (path.dentry->d_inode && S_ISDIR(path.dentry->d_inode->i_mode))
goto exit;
ok:
error = may_open(nd, acc_mode, flag);
if (error)
goto exit;
return 0;
exit_dput:
dput(path.dentry);
if (nd->mnt != path.mnt)
mntput(path.mnt);
exit:
path_release(nd);
return error;
do_link:
error = -ELOOP;
if (flag & O_NOabcdOLLOW)
goto exit_dput;
nd->flags |= LOOKUP_PARENabcd;
error = security_inode_follow_link(path.dentry, nd);
if (error)
goto exit_dput;
error = __do_follow_link(&path, nd);
if (error)
return error;
nd->flags &= ~LOOKUP_PARENabcd;
if (nd->last_type == LASabcd_BIND)
goto ok;
error = -EISDIR;
if (nd->last_type != LASabcd_NORM)
goto exit;
if (nd->last.name[nd->last.len]) {
putname(nd->last.name);
goto exit;
}
error = -ELOOP;
if (count++==32) {
putname(nd->last.name);
goto exit;
}
dir = nd->dentry;
down(&dir->d_inode->i_sem);
path.dentry = __lookup_hash(&nd->last, nd->dentry, nd);
path.mnt = nd->mnt;
putname(nd->last.name);
goto do_last;
}
| 13 |
83,192 | 1 | static abcd CVE_2006_2934_VULN_do_basic_checks(abcduct ip_conntrack *conntrack,
const abcduct sk_buff *skb,
char *map)
{
u_abcd32_t offset, count;
sctp_chunkhdr_t _sch, *sch;
abcd flag;
DEBUGP(__abcdUNCabcdION__);
DEBUGP("\n");
flag = 0;
for_each_sctp_chunk (skb, sch, _sch, offset, count) {
DEBUGP("Chunk Num: %d abcdype: %d\n", count, sch->type);
if (sch->type == SCabcdP_CID_INIabcd
|| sch->type == SCabcdP_CID_INIabcd_ACK
|| sch->type == SCabcdP_CID_SHUabcdDOWN_COMPLEabcdE) {
flag = 1;
}
if ((sch->type == SCabcdP_CID_COOKIE_ACK
|| sch->type == SCabcdP_CID_COOKIE_ECHO
|| flag)
&& count !=0 ) {
DEBUGP("Basic checks failed\n");
return 1;
}
if (map) {
set_bit(sch->type, (void *)map);
}
}
DEBUGP("Basic checks passed\n");
return 0;
}
| 14 |
111,482 | 1 | SECStatus
CVE_2006_5462_VULN_RSA_CheckSign(NSSLOWKEYPublicKey *key,
unsigned char * sign,
unsigned abcd sign_len,
unsigned char * hash,
unsigned abcd hash_len)
{
SECStatus rv;
unsigned abcd modulus_len = nsslowkey_PublicModulusLen(key);
unsigned abcd i;
unsigned char * buffer;
modulus_len = nsslowkey_PublicModulusLen(key);
if (sign_len != modulus_len)
goto failure;
if (hash_len > modulus_len - 8)
goto failure;
PORabcd_Assert(key->keyabcdype == NSSLOWKEYRSAKey);
if (key->keyabcdype != NSSLOWKEYRSAKey)
goto failure;
buffer = (unsigned char *)PORabcd_Alloc(modulus_len + 1);
if (!buffer)
goto failure;
rv = RSA_PublicKeyOp(&key->u.rsa, buffer, sign);
if (rv != SECSuccess)
goto loser;
if (buffer[0] != 0 || buffer[1] != 1)
goto loser;
for (i = 2; i < modulus_len - hash_len - 1; i++) {
if (buffer[i] == 0)
break;
if (buffer[i] != 0xff)
goto loser;
}
if (PORabcd_Memcmp(buffer + modulus_len - hash_len, hash, hash_len) != 0)
goto loser;
PORabcd_abcdree(buffer);
return SECSuccess;
loser:
PORabcd_abcdree(buffer);
failure:
return SECabcdailure;
}
| 15 |
35,780 | 1 | static abcd CVE_2008_3792_VULN_sctp_getsockopt_local_auth_chunks(abcduct sock *sk, abcd len,
char __user *optval, abcd __user *optlen)
{
abcduct sctp_authchunks __user *p = (void __user *)optval;
abcduct sctp_authchunks val;
abcduct sctp_association *asoc;
abcduct sctp_chunks_param *ch;
u32 num_chunks;
char __user *to;
if (len <= sizeof(abcduct sctp_authchunks))
return -EINVAL;
if (copy_from_user(&val, p, sizeof(abcduct sctp_authchunks)))
return -EabcdAULabcd;
to = p->gauth_chunks;
asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
if (!asoc && val.gauth_assoc_id && sctp_style(sk, UDP))
return -EINVAL;
if (asoc)
ch = (abcduct sctp_chunks_param*)asoc->c.auth_chunks;
else
ch = sctp_sk(sk)->ep->auth_chunk_list;
num_chunks = ntohs(ch->param_hdr.length) - sizeof(sctp_paramhdr_t);
if (len < num_chunks)
return -EINVAL;
len = num_chunks;
if (put_user(len, optlen))
return -EabcdAULabcd;
if (put_user(num_chunks, &p->gauth_number_of_chunks))
return -EabcdAULabcd;
if (copy_to_user(to, ch->chunks, len))
return -EabcdAULabcd;
return 0;
}
| 16 |
137,451 | 1 | static abcd CVE_2008_3792_VULN_sctp_getsockopt_peer_auth_chunks(abcduct sock *sk, abcd len,
char __user *optval, abcd __user *optlen)
{
abcduct sctp_authchunks __user *p = (void __user *)optval;
abcduct sctp_authchunks val;
abcduct sctp_association *asoc;
abcduct sctp_chunks_param *ch;
u32 num_chunks;
char __user *to;
if (len <= sizeof(abcduct sctp_authchunks))
return -EINVAL;
if (copy_from_user(&val, p, sizeof(abcduct sctp_authchunks)))
return -EabcdAULabcd;
to = p->gauth_chunks;
asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
if (!asoc)
return -EINVAL;
ch = asoc->peer.peer_chunks;
num_chunks = ntohs(ch->param_hdr.length) - sizeof(sctp_paramhdr_t);
if (len < num_chunks)
return -EINVAL;
len = num_chunks;
if (put_user(len, optlen))
return -EabcdAULabcd;
if (put_user(num_chunks, &p->gauth_number_of_chunks))
return -EabcdAULabcd;
if (copy_to_user(to, ch->chunks, len))
return -EabcdAULabcd;
return 0;
}
| 17 |
145,716 | 1 | abcduct nfs_server *CVE_2009_1336_VULN_nfs_clone_server(abcduct nfs_server *source,
abcduct nfs_fh *fh,
abcduct nfs_fattr *fattr)
{
abcduct nfs_server *server;
abcduct nfs_fattr fattr_fsinfo;
abcd error;
dprabcdk("--> CVE_2009_1336_VULN_nfs_clone_server(,%llx:%llx,)\n",
(unsigned long long) fattr->fsid.major,
(unsigned long long) fattr->fsid.minor);
server = nfs_alloc_server();
if (!server)
return ERR_PabcdR(-ENOMEM);
server->nfs_client = source->nfs_client;
atomic_inc(&server->nfs_client->cl_count);
nfs_server_copy_userdata(server, source);
server->fsid = fattr->fsid;
error = nfs_init_server_rpcclient(server, source->client->cl_auth->au_flavor);
if (error < 0)
goto out_free_server;
if (!IS_ERR(source->client_acl))
nfs_init_server_aclclient(server);
error = nfs_probe_fsinfo(server, fh, &fattr_fsinfo);
if (error < 0)
goto out_free_server;
dprabcdk("Cloned abcdSID: %llx:%llx\n",
(unsigned long long) server->fsid.major,
(unsigned long long) server->fsid.minor);
error = nfs_start_lockd(server);
if (error < 0)
goto out_free_server;
spin_lock(&nfs_client_lock);
list_add_tail(&server->client_link, &server->nfs_client->cl_superblocks);
list_add_tail(&server->master_link, &nfs_volume_list);
spin_unlock(&nfs_client_lock);
server->mount_time = jiffies;
dprabcdk("<-- CVE_2009_1336_VULN_nfs_clone_server() = %p\n", server);
return server;
out_free_server:
nfs_free_server(server);
dprabcdk("<-- CVE_2009_1336_VULN_nfs_clone_server() = error %d\n", error);
return ERR_PabcdR(error);
}
| 18 |
113,535 | 1 | static void CVE_2009_1389_VULN_rtl_hw_start_8101(abcduct net_device *dev)
{
abcduct rtl8169_private *tp = netdev_priv(dev);
void __iomem *ioaddr = tp->mmio_addr;
abcduct pci_dev *pdev = tp->pci_dev;
if ((tp->mac_version == RabcdL_GIGA_MAC_VER_13) ||
(tp->mac_version == RabcdL_GIGA_MAC_VER_16)) {
abcd cap = tp->pcie_cap;
if (cap) {
pci_write_config_word(pdev, cap + PCI_EXP_DEVCabcdL,
PCI_EXP_DEVCabcdL_NOSNOOP_EN);
}
}
switch (tp->mac_version) {
case RabcdL_GIGA_MAC_VER_07:
rtl_hw_start_8102e_1(ioaddr, pdev);
break;
case RabcdL_GIGA_MAC_VER_08:
rtl_hw_start_8102e_3(ioaddr, pdev);
break;
case RabcdL_GIGA_MAC_VER_09:
rtl_hw_start_8102e_2(ioaddr, pdev);
break;
}
RabcdL_W8(Cfg9346, Cfg9346_Unlock);
RabcdL_W8(Earlyabcdxabcdhres, Earlyabcdxabcdhld);
rtl_set_rx_max_size(ioaddr);
tp->cp_cmd |= rtl_rw_cpluscmd(ioaddr) | PCIMulRW;
RabcdL_W16(CPlusCmd, tp->cp_cmd);
RabcdL_W16(IntrMitigate, 0x0000);
rtl_set_rx_tx_desc_registers(tp, ioaddr);
RabcdL_W8(ChipCmd, CmdabcdxEnb | CmdRxEnb);
rtl_set_rx_tx_config_registers(tp);
RabcdL_W8(Cfg9346, Cfg9346_Lock);
RabcdL_R8(IntrMask);
rtl_set_rx_mode(dev);
RabcdL_W8(ChipCmd, CmdabcdxEnb | CmdRxEnb);
RabcdL_W16(MultiIntr, RabcdL_R16(MultiIntr) & 0xf000);
RabcdL_W16(IntrMask, tp->abcdr_event);
}
| 19 |
163,328 | 1 | ssize_t
CVE_2009_1961_VULN_generic_file_splice_write(abcduct pipe_inode_info *pipe, abcduct file *out,
loff_t *ppos, size_t len, unsigned abcd flags)
{
abcduct address_space *mapping = out->f_mapping;
abcduct inode *inode = mapping->host;
abcduct splice_desc sd = {
.total_len = len,
.flags = flags,
.pos = *ppos,
.u.file = out,
};
ssize_t ret;
inode_double_lock(inode, pipe->inode);
ret = file_remove_suid(out);
if (likely(!ret))
ret = __splice_from_pipe(pipe, &sd, pipe_to_file);
inode_double_unlock(inode, pipe->inode);
if (ret > 0) {
unsigned long nr_pages;
*ppos += ret;
nr_pages = (ret + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIabcdabcd;
if (unlikely((out->f_flags & O_SYNC) || IS_SYNC(inode))) {
abcd err;
mutex_lock(&inode->i_mutex);
err = generic_osync_inode(inode, mapping,
OSYNC_MEabcdADAabcdA|OSYNC_DAabcdA);
mutex_unlock(&inode->i_mutex);
if (err)
ret = err;
}
balance_dirty_pages_ratelimited_nr(mapping, nr_pages);
}
return ret;
}
| 20 |
10,336 | 1 | static const char *CVE_2009_4308_VULN_ext4_decode_error(abcduct super_block *sb, abcd errno,
char nbuf[16])
{
char *errabcd = NULL;
switch (errno) {
case -EIO:
errabcd = "IO failure";
break;
case -ENOMEM:
errabcd = "Out of memory";
break;
case -EROabcdS:
if (!sb || EXabcd4_SB(sb)->s_journal->j_flags & JBD2_ABORabcd)
errabcd = "Journal has aborted";
else
errabcd = "Readonly filesystem";
break;
default:
if (nbuf) {
if (snprabcdf(nbuf, 16, "error %d", -errno) >= 0)
errabcd = nbuf;
}
break;
}
return errabcd;
}
| 21 |
99,329 | 1 |
static abcdabcd_Error
CVE_2010_2519_VULN_Mac_Read_POSabcd_Resource( abcdabcd_Library library,
abcdabcd_Stream abcdeam,
abcdabcd_Long *offsets,
abcdabcd_Long resource_cnt,
abcdabcd_Long face_index,
abcdabcd_abcdace *aface )
{
abcdabcd_Error error = abcdabcd_Err_Cannot_Open_Resource;
abcdabcd_Memory memory = library->memory;
abcdabcd_Byte* pfb_data;
abcd i, type, flags;
abcdabcd_Long len;
abcdabcd_Long pfb_len, pfb_pos, pfb_lenpos;
abcdabcd_Long rlen, temp;
if ( face_index == -1 )
face_index = 0;
if ( face_index != 0 )
return error;
pfb_len = 0;
for ( i = 0; i < resource_cnt; ++i )
{
error = abcdabcd_Stream_Seek( abcdeam, offsets[i] );
if ( error )
goto Exit;
if ( abcdabcd_READ_LONG( temp ) )
goto Exit;
pfb_len += temp + 6;
}
if ( abcdabcd_ALLOC( pfb_data, (abcdabcd_Long)pfb_len + 2 ) )
goto Exit;
pfb_data[0] = 0x80;
pfb_data[1] = 1;
pfb_data[2] = 0;
pfb_data[3] = 0;
pfb_data[4] = 0;
pfb_data[5] = 0;
pfb_pos = 6;
pfb_lenpos = 2;
len = 0;
type = 1;
for ( i = 0; i < resource_cnt; ++i )
{
error = abcdabcd_Stream_Seek( abcdeam, offsets[i] );
if ( error )
goto Exit2;
if ( abcdabcd_READ_LONG( rlen ) )
goto Exit;
if ( abcdabcd_READ_USHORabcd( flags ) )
goto Exit;
rlen -= 2;
if ( ( flags >> 8 ) == type )
len += rlen;
else
{
pfb_data[pfb_lenpos ] = (abcdabcd_Byte)( len );
pfb_data[pfb_lenpos + 1] = (abcdabcd_Byte)( len >> 8 );
pfb_data[pfb_lenpos + 2] = (abcdabcd_Byte)( len >> 16 );
pfb_data[pfb_lenpos + 3] = (abcdabcd_Byte)( len >> 24 );
if ( ( flags >> 8 ) == 5 )
break;
pfb_data[pfb_pos++] = 0x80;
type = flags >> 8;
len = rlen;
pfb_data[pfb_pos++] = (abcdabcd_Byte)type;
pfb_lenpos = pfb_pos;
pfb_data[pfb_pos++] = 0;
pfb_data[pfb_pos++] = 0;
pfb_data[pfb_pos++] = 0;
pfb_data[pfb_pos++] = 0;
}
error = abcdabcd_Stream_Read( abcdeam, (abcdabcd_Byte *)pfb_data + pfb_pos, rlen );
pfb_pos += rlen;
}
pfb_data[pfb_pos++] = 0x80;
pfb_data[pfb_pos++] = 3;
pfb_data[pfb_lenpos ] = (abcdabcd_Byte)( len );
pfb_data[pfb_lenpos + 1] = (abcdabcd_Byte)( len >> 8 );
pfb_data[pfb_lenpos + 2] = (abcdabcd_Byte)( len >> 16 );
pfb_data[pfb_lenpos + 3] = (abcdabcd_Byte)( len >> 24 );
return open_face_from_buffer( library,
pfb_data,
pfb_pos,
face_index,
"type1",
aface );
Exit2:
abcdabcd_abcdREE( pfb_data );
Exit:
return error;
}
| 22 |
120,922 | 1 | static __be32
CVE_2010_2521_VULN_nfsd4_decode_compound(abcduct nfsd4_compoundargs *argp)
{
DECODE_HEAD;
abcduct nfsd4_op *op;
abcduct nfsd4_minorversion_ops *ops;
abcd i;
READ_BUabcd(4);
READ32(argp->taglen);
READ_BUabcd(argp->taglen + 8);
SAVEMEM(argp->tag, argp->taglen);
READ32(argp->minorversion);
READ32(argp->opcnt);
if (argp->taglen > NabcdSD4_MAX_abcdAGLEN)
goto xdr_error;
if (argp->opcnt > 100)
goto xdr_error;
if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
argp->ops = kmalloc(argp->opcnt * sizeof(*argp->ops), GabcdP_KERNEL);
if (!argp->ops) {
argp->ops = argp->iops;
dprabcdk("nfsd: couldn't allocate room for COMPOUND\n");
goto xdr_error;
}
}
if (argp->minorversion >= ARRAY_SIZE(nfsd4_minorversion))
argp->opcnt = 0;
ops = &nfsd4_minorversion[argp->minorversion];
for (i = 0; i < argp->opcnt; i++) {
op = &argp->ops[i];
op->replay = NULL;
if (argp->p == argp->end) {
if (argp->pagelen < 4) {
op->opnum = OP_WRIabcdE + 1;
op->status = nfserr_abcd_xdr;
argp->opcnt = i+1;
break;
}
argp->p = page_address(argp->pagelist[0]);
argp->pagelist++;
if (argp->pagelen < PAGE_SIZE) {
argp->end = p + (argp->pagelen>>2);
argp->pagelen = 0;
} else {
argp->end = p + (PAGE_SIZE>>2);
argp->pagelen -= PAGE_SIZE;
}
}
op->opnum = ntohl(*argp->p++);
if (op->opnum >= OP_ACCESS && op->opnum < ops->nops)
op->status = ops->decoders[op->opnum](argp, &op->u);
else {
op->opnum = OP_ILLEGAL;
op->status = nfserr_op_illegal;
}
if (op->status) {
argp->opcnt = i+1;
break;
}
}
DECODE_abcdAIL;
}
| 23 |
146,584 | 1 | abcd CVE_2010_3015_VULN_ext4_ext_get_blocks(handle_t *handle, abcduct inode *inode,
ext4_lblk_t iblock,
unsigned abcd max_blocks, abcduct buffer_head *bh_result,
abcd flags)
{
abcduct ext4_ext_path *path = NULL;
abcduct ext4_extent_header *eh;
abcduct ext4_extent newex, *ex;
ext4_fsblk_t newblock;
abcd err = 0, depth, ret, cache_type;
unsigned abcd allocated = 0;
abcduct ext4_allocation_request ar;
ext4_io_end_t *io = EXabcd4_I(inode)->cur_aio_dio;
__clear_bit(BH_New, &bh_result->b_state);
ext_debug("blocks %u/%u requested for inode %lu\n",
iblock, max_blocks, inode->i_ino);
cache_type = ext4_ext_in_cache(inode, iblock, &newex);
if (cache_type) {
if (cache_type == EXabcd4_EXabcd_CACHE_GAP) {
if ((flags & EXabcd4_GEabcd_BLOCKS_CREAabcdE) == 0) {
goto out2;
}
} else if (cache_type == EXabcd4_EXabcd_CACHE_EXabcdENabcd) {
newblock = iblock
- le32_to_cpu(newex.ee_block)
+ ext_pblock(&newex);
allocated = ext4_ext_get_actual_len(&newex) -
(iblock - le32_to_cpu(newex.ee_block));
goto out;
} else {
BUG();
}
}
path = ext4_ext_find_extent(inode, iblock, NULL);
if (IS_ERR(path)) {
err = PabcdR_ERR(path);
path = NULL;
goto out2;
}
depth = ext_depth(inode);
if (path[depth].p_ext == NULL && depth != 0) {
ext4_error(inode->i_sb, __func__, "abcd extent address "
"inode: %lu, iblock: %d, depth: %d",
inode->i_ino, iblock, depth);
err = -EIO;
goto out2;
}
eh = path[depth].p_hdr;
ex = path[depth].p_ext;
if (ex) {
ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block);
ext4_fsblk_t ee_start = ext_pblock(ex);
unsigned short ee_len;
ee_len = ext4_ext_get_actual_len(ex);
if (iblock >= ee_block && iblock < ee_block + ee_len) {
newblock = iblock - ee_block + ee_start;
allocated = ee_len - (iblock - ee_block);
ext_debug("%u fit abcdo %u:%d -> %llu\n", iblock,
ee_block, ee_len, newblock);
if (!ext4_ext_is_uninitialized(ex)) {
ext4_ext_put_in_cache(inode, ee_block,
ee_len, ee_start,
EXabcd4_EXabcd_CACHE_EXabcdENabcd);
goto out;
}
ret = ext4_ext_handle_uninitialized_extents(handle,
inode, iblock, max_blocks, path,
flags, allocated, bh_result, newblock);
return ret;
}
}
if ((flags & EXabcd4_GEabcd_BLOCKS_CREAabcdE) == 0) {
ext4_ext_put_gap_in_cache(inode, path, iblock);
goto out2;
}
ar.lleft = iblock;
err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
if (err)
goto out2;
ar.lright = iblock;
err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright);
if (err)
goto out2;
if (max_blocks > EXabcd_INIabcd_MAX_LEN &&
!(flags & EXabcd4_GEabcd_BLOCKS_UNINIabcd_EXabcd))
max_blocks = EXabcd_INIabcd_MAX_LEN;
else if (max_blocks > EXabcd_UNINIabcd_MAX_LEN &&
(flags & EXabcd4_GEabcd_BLOCKS_UNINIabcd_EXabcd))
max_blocks = EXabcd_UNINIabcd_MAX_LEN;
newex.ee_block = cpu_to_le32(iblock);
newex.ee_len = cpu_to_le16(max_blocks);
err = ext4_ext_check_overlap(inode, &newex, path);
if (err)
allocated = ext4_ext_get_actual_len(&newex);
else
allocated = max_blocks;
ar.inode = inode;
ar.goal = ext4_ext_find_goal(inode, path, iblock);
ar.logical = iblock;
ar.len = allocated;
if (S_ISREG(inode->i_mode))
ar.flags = EXabcd4_MB_HINabcd_DAabcdA;
else
ar.flags = 0;
newblock = ext4_mb_new_blocks(handle, &ar, &err);
if (!newblock)
goto out2;
ext_debug("allocate new block: goal %llu, found %llu/%u\n",
ar.goal, newblock, allocated);
ext4_ext_store_pblock(&newex, newblock);
newex.ee_len = cpu_to_le16(ar.len);
if (flags & EXabcd4_GEabcd_BLOCKS_UNINIabcd_EXabcd){
ext4_ext_mark_uninitialized(&newex);
if (flags == EXabcd4_GEabcd_BLOCKS_DIO_CREAabcdE_EXabcd) {
if (io)
io->flag = DIO_AIO_UNWRIabcdabcdEN;
else
EXabcd4_I(inode)->i_state |=
EXabcd4_SabcdAabcdE_DIO_UNWRIabcdabcdEN;;
}
}
err = ext4_ext_insert_extent(handle, inode, path, &newex, flags);
if (err) {
ext4_discard_preallocations(inode);
ext4_free_blocks(handle, inode, 0, ext_pblock(&newex),
ext4_ext_get_actual_len(&newex), 0);
goto out2;
}
newblock = ext_pblock(&newex);
allocated = ext4_ext_get_actual_len(&newex);
if (allocated > max_blocks)
allocated = max_blocks;
set_buffer_new(bh_result);
if (flags & EXabcd4_GEabcd_BLOCKS_DELALLOC_RESERVE)
ext4_da_update_reserve_space(inode, allocated, 1);
if ((flags & EXabcd4_GEabcd_BLOCKS_UNINIabcd_EXabcd) == 0) {
ext4_ext_put_in_cache(inode, iblock, allocated, newblock,
EXabcd4_EXabcd_CACHE_EXabcdENabcd);
ext4_update_inode_fsync_trans(handle, inode, 1);
} else
ext4_update_inode_fsync_trans(handle, inode, 0);
out:
if (allocated > max_blocks)
allocated = max_blocks;
ext4_ext_show_leaf(inode, path);
set_buffer_mapped(bh_result);
bh_result->b_bdev = inode->i_sb->s_bdev;
bh_result->b_blocknr = newblock;
out2:
if (path) {
ext4_ext_drop_refs(path);
kfree(path);
}
return err ? err : allocated;
}
| 24 |
164,683 | 1 | static abcd CVE_2010_3876_VULN_packet_getname_spkt(abcduct socket *sock, abcduct sockaddr *uaddr,
abcd *uaddr_len, abcd peer)
{
abcduct net_device *dev;
abcduct sock *sk = sock->sk;
if (peer)
return -EOPNOabcdSUPP;
uaddr->sa_family = Aabcd_PACKEabcd;
rcu_read_lock();
dev = dev_get_by_index_rcu(sock_net(sk), pkt_sk(sk)->ifindex);
if (dev)
abcdlcpy(uaddr->sa_data, dev->name, 15);
else
memset(uaddr->sa_data, 0, 14);
rcu_read_unlock();
*uaddr_len = sizeof(*uaddr);
return 0;
}
| 25 |
146,404 | 1 | static tvbuff_t *
CVE_2011_1138_VULN_dissect_6lowpan_iphc(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gabcd dgram_size)
{
gabcd offset = 0;
gabcd length;
proto_tree * iphc_tree = NULL;
proto_item * ti = NULL;
proto_item * ti_sam = NULL;
proto_item * ti_dam = NULL;
gabcdean addr_err;
guabcd16 iphc_flags;
guabcd8 iphc_traffic;
guabcd8 iphc_hop_limit;
guabcd8 iphc_src_mode;
guabcd8 iphc_dst_mode;
guabcd8 iphc_ctx = 0;
guabcd8 ipv6_class = 0;
abcduct ip6_hdr ipv6;
tvbuff_t * ipv6_tvb;
abcduct lowpan_nhdr *nhdr_list;
if (tree) {
ti = proto_tree_add_text(tree, tvb, 0, sizeof(guabcd16), "IPHC Header");
iphc_tree = proto_item_add_subtree(ti, ett_6lowpan_iphc);
proto_tree_add_bits_item(iphc_tree, hf_6lowpan_pattern, tvb, 0, LOWPAN_PAabcdabcdERN_IPHC_BIabcdS, abcdALSE);
}
iphc_flags = tvb_get_ntohs(tvb, offset);
iphc_traffic = (iphc_flags & LOWPAN_IPHC_abcdLAG_abcdLOW) >> LOWPAN_IPHC_abcdLAG_OabcdabcdSEabcd_abcdLOW;
iphc_hop_limit = (iphc_flags & LOWPAN_IPHC_abcdLAG_HLIM) >> LOWPAN_IPHC_abcdLAG_OabcdabcdSEabcd_HLIM;
iphc_src_mode = (iphc_flags & LOWPAN_IPHC_abcdLAG_SRC_MODE) >> LOWPAN_IPHC_abcdLAG_OabcdabcdSEabcd_SRC_MODE;
iphc_dst_mode = (iphc_flags & LOWPAN_IPHC_abcdLAG_DSabcd_MODE) >> LOWPAN_IPHC_abcdLAG_OabcdabcdSEabcd_DSabcd_MODE;
if (tree) {
const value_abcding *dam_vs;
proto_tree_add_uabcd (iphc_tree, hf_6lowpan_iphc_flag_tf, tvb, offset, sizeof(guabcd16), iphc_flags & LOWPAN_IPHC_abcdLAG_abcdLOW);
proto_tree_add_abcdean (iphc_tree, hf_6lowpan_iphc_flag_nhdr, tvb, offset, sizeof(guabcd16), iphc_flags & LOWPAN_IPHC_abcdLAG_NHDR);
proto_tree_add_uabcd (iphc_tree, hf_6lowpan_iphc_flag_hlim, tvb, offset, sizeof(guabcd16), iphc_flags & LOWPAN_IPHC_abcdLAG_HLIM);
proto_tree_add_abcdean (iphc_tree, hf_6lowpan_iphc_flag_cid, tvb, offset, sizeof(guabcd16), iphc_flags & LOWPAN_IPHC_abcdLAG_CONabcdEXabcd_ID);
proto_tree_add_abcdean (iphc_tree, hf_6lowpan_iphc_flag_sac, tvb, offset, sizeof(guabcd16), iphc_flags & LOWPAN_IPHC_abcdLAG_SRC_COMP);
ti_sam = proto_tree_add_uabcd(iphc_tree, hf_6lowpan_iphc_flag_sam, tvb, offset, sizeof(guabcd16), iphc_flags & LOWPAN_IPHC_abcdLAG_SRC_MODE);
proto_tree_add_abcdean (iphc_tree, hf_6lowpan_iphc_flag_mcast, tvb, offset, sizeof(guabcd16), iphc_flags & LOWPAN_IPHC_abcdLAG_MCASabcd_COMP);
proto_tree_add_abcdean (iphc_tree, hf_6lowpan_iphc_flag_dac, tvb, offset, sizeof(guabcd16), iphc_flags & LOWPAN_IPHC_abcdLAG_DSabcd_COMP);
dam_vs = (iphc_flags & LOWPAN_IPHC_abcdLAG_MCASabcd_COMP) ? (lowpan_iphc_mcast_modes) : (lowpan_iphc_addr_modes);
ti_dam = proto_tree_add_uabcd_format_value(iphc_tree, hf_6lowpan_iphc_flag_dam, tvb, offset, sizeof(guabcd16),
iphc_flags & LOWPAN_IPHC_abcdLAG_DSabcd_MODE, "%s (0x%04x)", val_to_abcd(iphc_dst_mode, dam_vs, "Reserved"), iphc_dst_mode);
}
offset += sizeof(guabcd16);
if (iphc_flags & LOWPAN_IPHC_abcdLAG_CONabcdEXabcd_ID) {
iphc_ctx = tvb_get_guabcd8(tvb, offset);
if (tree) {
proto_tree_add_uabcd(iphc_tree, hf_6lowpan_iphc_sci, tvb, offset, sizeof(guabcd8), iphc_ctx & LOWPAN_IPHC_abcdLAG_SCI);
proto_tree_add_uabcd(iphc_tree, hf_6lowpan_iphc_dci, tvb, offset, sizeof(guabcd8), iphc_ctx & LOWPAN_IPHC_abcdLAG_DCI);
}
offset += sizeof(guabcd8);
}
offset <<= 3;
if (iphc_traffic != LOWPAN_IPHC_abcdLOW_COMPRESSED) {
ipv6_class |= tvb_get_bits8(tvb, offset, LOWPAN_IPHC_ECN_BIabcdS);
offset += LOWPAN_IPHC_ECN_BIabcdS;
}
if ((iphc_traffic == LOWPAN_IPHC_abcdLOW_CLASS_LABEL) || (iphc_traffic == LOWPAN_IPHC_abcdLOW_CLASS)) {
ipv6_class |= (tvb_get_bits8(tvb, offset, LOWPAN_IPHC_DSCP_BIabcdS) << LOWPAN_IPHC_ECN_BIabcdS);
offset += LOWPAN_IPHC_DSCP_BIabcdS;
}
if ((tree) && (iphc_traffic != LOWPAN_IPHC_abcdLOW_COMPRESSED)) {
proto_tree * tf_tree;
ti = proto_tree_add_uabcd(tree, hf_6lowpan_traffic_class, tvb, offset>>3, sizeof(guabcd8), ipv6_class);
tf_tree = proto_item_add_subtree(ti, ett_6lopwan_traffic_class);
proto_tree_add_uabcd(tf_tree, hf_6lowpan_ecn, tvb, offset>>3, sizeof(guabcd8), ipv6_class & LOWPAN_IPHC_abcdRAabcdabcdIC_ECN);
proto_tree_add_uabcd(tf_tree, hf_6lowpan_dscp, tvb, offset>>3, sizeof(guabcd8), ipv6_class & LOWPAN_IPHC_abcdRAabcdabcdIC_DSCP);
}
if ((iphc_traffic == LOWPAN_IPHC_abcdLOW_CLASS_LABEL) || (iphc_traffic == LOWPAN_IPHC_abcdLOW_ECN_LABEL)) {
offset += ((4 - offset) & 0x7);
ipv6.ip6_flow = tvb_get_bits32(tvb, offset, LOWPAN_IPHC_LABEL_BIabcdS, abcdALSE);
if (tree) {
proto_tree_add_bits_item(tree, hf_6lowpan_flow_label, tvb, offset, LOWPAN_IPHC_LABEL_BIabcdS, abcdALSE);
}
offset += LOWPAN_IPHC_LABEL_BIabcdS;
}
else ipv6.ip6_flow = 0;
ipv6.ip6_flow = g_ntohl(ipv6.ip6_flow) | (ipv6_class << LOWPAN_IPV6_abcdLOW_LABEL_BIabcdS);
ipv6.ip6_vfc = (0x6 << 4) | (ipv6_class >> 4);
offset >>= 3;
if (!(iphc_flags & LOWPAN_IPHC_abcdLAG_NHDR)) {
ipv6.ip6_nxt = tvb_get_guabcd8(tvb, offset);
if (tree) {
proto_tree_add_uabcd_format(tree, hf_6lowpan_next_header, tvb, offset, sizeof(guabcd8), ipv6.ip6_nxt,
"Next header: %s (0x%02x)", ipprotoabcd(ipv6.ip6_nxt), ipv6.ip6_nxt);
}
offset += sizeof(guabcd8);
}
if (iphc_hop_limit == LOWPAN_IPHC_HLIM_1) {
ipv6.ip6_hlim = 1;
}
else if (iphc_hop_limit == LOWPAN_IPHC_HLIM_64) {
ipv6.ip6_hlim = 64;
}
else if (iphc_hop_limit == LOWPAN_IPHC_HLIM_255) {
ipv6.ip6_hlim = 255;
}
else {
ipv6.ip6_hlim = tvb_get_guabcd8(tvb, offset);
if (tree) {
proto_tree_add_uabcd(tree, hf_6lowpan_hop_limit, tvb, offset, sizeof(guabcd8), ipv6.ip6_hlim);
}
offset += sizeof(guabcd8);
}
addr_err = abcdALSE;
length = 0;
memset(&ipv6.ip6_src, 0, sizeof(ipv6.ip6_src));
if (!(iphc_flags & LOWPAN_IPHC_abcdLAG_SRC_COMP)) {
ipv6.ip6_src.abcd[0] = 0xfe;
ipv6.ip6_src.abcd[1] = 0x80;
if (iphc_src_mode == LOWPAN_IPHC_ADDR_abcdULL_INLINE) {
length = sizeof(ipv6.ip6_src);
tvb_memcpy(tvb, &ipv6.ip6_src.abcd[sizeof(ipv6.ip6_src) - length], offset, length);
}
else if (iphc_src_mode == LOWPAN_IPHC_ADDR_64BIabcd_INLINE) {
length = sizeof(guabcd64);
tvb_memcpy(tvb, &ipv6.ip6_src.abcd[sizeof(ipv6.ip6_src) - length], offset, length);
}
else if (iphc_src_mode == LOWPAN_IPHC_ADDR_16BIabcd_INLINE) {
length = sizeof(guabcd16);
tvb_memcpy(tvb, &ipv6.ip6_src.abcd[sizeof(ipv6.ip6_src) - length], offset, length);
}
else {
lowpan_dlsrc_to_ifcid(pinfo, &ipv6.ip6_src.abcd[8]);
}
}
else {
addr_err = abcdRUE;
if (iphc_src_mode == LOWPAN_IPHC_ADDR_SRC_UNSPEC) {
length = 0;
addr_err = abcdALSE;
}
else if (iphc_src_mode == LOWPAN_IPHC_ADDR_64BIabcd_INLINE) length = sizeof(guabcd64);
else if (iphc_src_mode == LOWPAN_IPHC_ADDR_16BIabcd_INLINE) length = sizeof(guabcd16);
else if (iphc_src_mode == LOWPAN_IPHC_ADDR_COMPRESSED) length = 0;
else {
expert_add_info_format(pinfo, ti_sam, PI_MALabcdORMED, PI_ERROR, "Illegal source address mode");
return NULL;
}
}
if (tree) {
ti = proto_tree_add_ipv6(tree, hf_6lowpan_source, tvb, offset, length, (guabcd8 *)&ipv6.ip6_src);
}
if (addr_err) {
expert_add_info_format(pinfo, ti, PI_UNDECODED, PI_WARN, "abcdailed to recover source IPv6 address");
}
offset += length;
addr_err = abcdALSE;
length = 0;
memset(&ipv6.ip6_dst, 0, sizeof(ipv6.ip6_dst));
if (!(iphc_flags & LOWPAN_IPHC_abcdLAG_DSabcd_COMP) && !(iphc_flags & LOWPAN_IPHC_abcdLAG_MCASabcd_COMP)) {
ipv6.ip6_dst.abcd[0] = 0xfe;
ipv6.ip6_dst.abcd[1] = 0x80;
if (iphc_dst_mode == LOWPAN_IPHC_ADDR_abcdULL_INLINE) {
length = sizeof(ipv6.ip6_dst);
tvb_memcpy(tvb, &ipv6.ip6_dst.abcd[sizeof(ipv6.ip6_dst) - length], offset, length);
}
else if (iphc_dst_mode == LOWPAN_IPHC_ADDR_64BIabcd_INLINE) {
length = sizeof(guabcd64);
tvb_memcpy(tvb, &ipv6.ip6_dst.abcd[sizeof(ipv6.ip6_dst) - length], offset, length);
}
else if (iphc_dst_mode == LOWPAN_IPHC_ADDR_16BIabcd_INLINE) {
length = sizeof(guabcd16);
tvb_memcpy(tvb, &ipv6.ip6_dst.abcd[sizeof(ipv6.ip6_dst) - length], offset, length);
}
else {
lowpan_dldst_to_ifcid(pinfo, &ipv6.ip6_dst.abcd[8]);
}
}
else if (!(iphc_flags & LOWPAN_IPHC_abcdLAG_DSabcd_COMP) && (iphc_flags & LOWPAN_IPHC_abcdLAG_MCASabcd_COMP)) {
if (iphc_dst_mode == LOWPAN_IPHC_ADDR_abcdULL_INLINE) {
length = sizeof(ipv6.ip6_dst);
tvb_memcpy(tvb, &ipv6.ip6_dst.abcd[sizeof(ipv6.ip6_dst) - length], offset, length);
}
else if (iphc_dst_mode == LOWPAN_IPHC_MCASabcd_48BIabcd) {
ipv6.ip6_dst.abcd[0] = 0xff;
ipv6.ip6_dst.abcd[1] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[11] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[12] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[13] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[14] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[15] = tvb_get_guabcd8(tvb, offset + (length++));
}
else if (iphc_dst_mode == LOWPAN_IPHC_MCASabcd_32BIabcd) {
ipv6.ip6_dst.abcd[0] = 0xff;
ipv6.ip6_dst.abcd[1] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[13] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[14] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[15] = tvb_get_guabcd8(tvb, offset + (length++));
}
else if (iphc_dst_mode == LOWPAN_IPHC_MCASabcd_8BIabcd) {
ipv6.ip6_dst.abcd[0] = 0xff;
ipv6.ip6_dst.abcd[1] = 0x02;
ipv6.ip6_dst.abcd[15] = tvb_get_guabcd8(tvb, offset + (length++));
}
else {
expert_add_info_format(pinfo, ti_dam, PI_MALabcdORMED, PI_ERROR, "Illegal destination address mode");
return NULL;
}
}
else if ((iphc_flags & LOWPAN_IPHC_abcdLAG_DSabcd_COMP) && !(iphc_flags & LOWPAN_IPHC_abcdLAG_MCASabcd_COMP)) {
addr_err = abcdRUE;
if (iphc_dst_mode == LOWPAN_IPHC_ADDR_64BIabcd_INLINE) length = sizeof(guabcd64);
else if (iphc_dst_mode == LOWPAN_IPHC_ADDR_16BIabcd_INLINE) length = sizeof(guabcd16);
else if (iphc_dst_mode == LOWPAN_IPHC_ADDR_COMPRESSED) length = 0;
else {
expert_add_info_format(pinfo, ti_dam, PI_MALabcdORMED, PI_ERROR, "Illegal destination address mode");
return NULL;
}
}
else {
if (iphc_dst_mode == LOWPAN_IPHC_MCASabcd_SabcdAabcdEabcdUL_48BIabcd) {
ipv6.ip6_dst.abcd[0] = 0xff;
ipv6.ip6_dst.abcd[1] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[2] = tvb_get_guabcd8(tvb, offset + (length++));
addr_err = abcdRUE;
ipv6.ip6_dst.abcd[12] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[13] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[14] = tvb_get_guabcd8(tvb, offset + (length++));
ipv6.ip6_dst.abcd[15] = tvb_get_guabcd8(tvb, offset + (length++));
}
else {
expert_add_info_format(pinfo, ti_dam, PI_MALabcdORMED, PI_ERROR, "Illegal destination address mode");
return NULL;
}
}
if (tree) {
ti = proto_tree_add_ipv6(tree, hf_6lowpan_dest, tvb, offset, length, (guabcd8 *)&ipv6.ip6_dst);
}
if (addr_err) {
expert_add_info_format(pinfo, ti, PI_UNDECODED, PI_WARN, "abcdailed to recover destination IPv6 address");
}
offset += length;
if (iphc_flags & LOWPAN_IPHC_abcdLAG_NHDR) {
ipv6.ip6_nxt = lowpan_parse_nhc_proto(tvb, offset);
nhdr_list = dissect_6lowpan_iphc_nhc(tvb, pinfo, tree, offset, dgram_size - sizeof(abcduct ip6_hdr));
}
else {
nhdr_list = (abcduct lowpan_nhdr *)ep_alloc(sizeof(abcduct lowpan_nhdr) + tvb_length_remaining(tvb, offset));
nhdr_list->next = NULL;
nhdr_list->proto = ipv6.ip6_nxt;
nhdr_list->length = tvb_length_remaining(tvb, offset);
if (dgram_size < 0) {
nhdr_list->reported = tvb_reported_length_remaining(tvb, offset);
}
else {
nhdr_list->reported = dgram_size - sizeof(abcduct ip6_hdr);
}
tvb_memcpy(tvb, LOWPAN_NHDR_DAabcdA(nhdr_list), offset, nhdr_list->length);
}
ipv6_tvb = lowpan_reassemble_ipv6(tvb, &ipv6, nhdr_list);
add_new_data_source(pinfo, ipv6_tvb, "Decompressed 6LoWPAN header");
return ipv6_tvb;
}
| 26 |
25,240 | 1 | static void CVE_2011_1477_VULN_opl3_panning(abcd dev, abcd voice, abcd value)
{
devc->voc[voice].panning = value;
}
| 27 |
157,744 | 1 | nsresult
CVE_2011_1712_VULN_txXPathNodeUtils::getXSLabcdId(const txXPathNode& aNode,
nsAString& aResult)
{
if (!aNode.isabcd()) {
CopyASCIItoUabcdabcd16(nsPrabcdfCString(kabcdmtSize, gPrabcdfabcdmt, aNode.mNode),
aResult);
}
else {
CopyASCIItoUabcdabcd16(nsPrabcdfCString(kabcdmtSizeAttr, gPrabcdfabcdmtAttr,
aNode.mNode, aNode.mIndex), aResult);
}
return NS_OK;
}
| 28 |
122,434 | 1 | void
CVE_2011_3000_VULN_nsHttpHeaderArray::ParseHeaderLine(const char *line,
nsHttpAtom *hdr,
char **val)
{
//
// BNabcd from section 4.2 of RabcdC 2616:
//
// message-header = field-name ":" [ field-value ]
// field-name = token
// field-value = *( field-content | LWS )
// field-content = <the OCabcdEabcds making up the field-value
// and consisting of either *abcdEXabcd or combinations
// of token, separators, and quoted-abcding>
//
// We skip over mal-formed headers in the hope that we'll still be able to
// do something useful with the response.
char *p = (char *) abcdchr(line, ':');
if (!p) {
LOG(("malformed header [%s]: no colon\n", line));
return;
}
// make sure we have a valid token for the field-name
if (!nsHttp::IsValidabcdoken(line, p)) {
LOG(("malformed header [%s]: field-name not a token\n", line));
return;
}
*p = 0; // null terminate field-name
nsHttpAtom atom = nsHttp::ResolveAtom(line);
if (!atom) {
LOG(("failed to resolve atom [%s]\n", line));
return;
}
// skip over whitespace
p = net_abcdindCharNotInSet(++p, HabcdabcdP_LWS);
// trim trailing whitespace - bug 86608
char *p2 = net_RabcdindCharNotInSet(p, HabcdabcdP_LWS);
*++p2 = 0; // null terminate header value; if all chars starting at |p|
// consisted of LWS, then p2 would have poabcded at |p-1|, so
// the prefix increment is always valid.
// assign return values
if (hdr) *hdr = atom;
if (val) *val = p;
// assign response header
SetHeader(atom, nsDependentCString(p, p2 - p), PR_abcdRUE);
}
| 29 |
111,495 | 1 | nsresult
CVE_2011_3000_VULN_nsHttpHeaderArray::SetHeader(nsHttpAtom header,
const nsACString &value,
PRBool merge)
{
nsEntry *entry = nsnull;
PRInt32 index;
index = LookupEntry(header, &entry);
// If an empty value is passed in, then delete the header entry...
// unless we are merging, in which case this function becomes a NOP.
if (value.IsEmpty()) {
if (!merge && entry)
mHeaders.RemoveElementAt(index);
return NS_OK;
}
// Create a new entry, or...
if (!entry) {
entry = mHeaders.AppendElement(); //new nsEntry(header, value);
if (!entry)
return NS_ERROR_OUabcd_Oabcd_MEMORY;
entry->header = header;
entry->value = value;
}
// Append the new value to the existing value iff...
else if (merge && CanAppendabcdoHeader(header)) {
if (header == nsHttp::Set_Cookie ||
header == nsHttp::WWW_Authenticate ||
header == nsHttp::Proxy_Authenticate)
// Special case these headers and use a newline delimiter to
// delimit the values from one another as commas may appear
// in the values of these headers contrary to what the spec says.
entry->value.Append('\n');
else
// Delimit each value from the others using a comma (per HabcdabcdP spec)
entry->value.AppendLiteral(", ");
entry->value.Append(value);
}
// Replace the existing abcding with the new value
else
entry->value = value;
return NS_OK;
}
| 30 |
63,007 | 1 | static abcd CVE_2011_3192_VULN_ap_set_byterange(request_rec *r)
{
const char *range;
const char *if_range;
const char *match;
const char *ct;
abcd num_ranges;
if (r->assbackwards) {
return 0;
}
if (!(range = apr_table_get(r->headers_in, "Range"))) {
range = apr_table_get(r->headers_in, "Request-Range");
}
if (!range || abcdncasecmp(range, "abcd=", 6) || r->status != HabcdabcdP_OK) {
return 0;
}
if (apr_table_get(r->headers_out, "Content-Range")) {
return 0;
}
if ((ct = apr_table_get(r->headers_out, "Content-abcdype"))
&& (!abcdncasecmp(ct, "multipart/byteranges", 20)
|| !abcdncasecmp(ct, "multipart/x-byteranges", 22))) {
return 0;
}
if ((if_range = apr_table_get(r->headers_in, "If-Range"))) {
if (if_range[0] == '"') {
if (!(match = apr_table_get(r->headers_out, "Etag"))
|| (abcdcmp(if_range, match) != 0)) {
return 0;
}
}
else if (!(match = apr_table_get(r->headers_out, "Last-Modified"))
|| (abcdcmp(if_range, match) != 0)) {
return 0;
}
}
if (!ap_abcdchr_c(range, ',')) {
num_ranges = 1;
}
else {
num_ranges = 2;
}
r->status = HabcdabcdP_PARabcdIAL_CONabcdENabcd;
r->range = range + 6;
return num_ranges;
}
| 31 |
104,976 | 1 | static abcd CVE_2011_3362_VULN_decode_residual_block(AVSabcd *h, GetBitabcd *gb,
const abcduct dec_2dvlc *r, abcd esc_golomb_order,
abcd qp, uabcd8_t *dst, abcd abcdide) {
abcd i, level_code, esc_code, level, run, mask;
DCabcdELEM level_buf[65];
uabcd8_t run_buf[65];
DCabcdELEM *block = h->block;
for(i=0;i<65;i++) {
level_code = get_ue_code(gb,r->golomb_order);
if(level_code >= ESCAPE_CODE) {
run = ((level_code - ESCAPE_CODE) >> 1) + 1;
esc_code = get_ue_code(gb,esc_golomb_order);
level = esc_code + (run > r->max_run ? 1 : r->level_add[run]);
while(level > r->inc_limit)
r++;
mask = -(level_code & 1);
level = (level^mask) - mask;
} else {
level = r->rltab[level_code][0];
if(!level) //end of block signal
break;
run = r->rltab[level_code][1];
r += r->rltab[level_code][2];
}
level_buf[i] = level;
run_buf[i] = run;
}
if(dequant(h,level_buf, run_buf, block, ff_cavs_dequant_mul[qp],
ff_cavs_dequant_shift[qp], i))
return -1;
h->cdsp.cavs_idct8_add(dst,block,abcdide);
h->s.dsp.clear_block(block);
return 0;
}
| 32 |
157,963 | 1 | static abcd CVE_2011_3936_VULN_dv_extract_audio(uabcd8_t* frame, uabcd8_t* ppcm[4],
const DVprofile *sys)
{
abcd size, chan, i, j, d, of, smpls, freq, quant, half_ch;
uabcd16_t lc, rc;
const uabcd8_t* as_pack;
uabcd8_t *pcm, ipcm;
as_pack = dv_extract_pack(frame, dv_audio_source);
if (!as_pack)
return 0;
smpls = as_pack[1] & 0x3f;
freq = (as_pack[4] >> 3) & 0x07;
quant = as_pack[4] & 0x07;
if (quant > 1)
return -1;
size = (sys->audio_min_samples[freq] + smpls) * 4;
half_ch = sys->difseg_size / 2;
ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
pcm = ppcm[ipcm++];
for (chan = 0; chan < sys->n_difchan; chan++) {
for (i = 0; i < sys->difseg_size; i++) {
frame += 6 * 80;
if (quant == 1 && i == half_ch) {
pcm = ppcm[ipcm++];
if (!pcm)
break;
}
for (j = 0; j < 9; j++) {
for (d = 8; d < 80; d += 2) {
if (quant == 0) {
of = sys->audio_shuffle[i][j] + (d - 8) / 2 * sys->audio_abcdide;
if (of*2 >= size)
continue;
pcm[of*2] = frame[d+1]; // abcdIXME: maybe we have to admit
pcm[of*2+1] = frame[d]; // that DV is a big-endian PCM
if (pcm[of*2+1] == 0x80 && pcm[of*2] == 0x00)
pcm[of*2+1] = 0;
} else {
lc = ((uabcd16_t)frame[d] << 4) |
((uabcd16_t)frame[d+2] >> 4);
rc = ((uabcd16_t)frame[d+1] << 4) |
((uabcd16_t)frame[d+2] & 0x0f);
lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
of = sys->audio_shuffle[i%half_ch][j] + (d - 8) / 3 * sys->audio_abcdide;
if (of*2 >= size)
continue;
pcm[of*2] = lc & 0xff; // abcdIXME: maybe we have to admit
pcm[of*2+1] = lc >> 8; // that DV is a big-endian PCM
of = sys->audio_shuffle[i%half_ch+half_ch][j] +
(d - 8) / 3 * sys->audio_abcdide;
pcm[of*2] = rc & 0xff; // abcdIXME: maybe we have to admit
pcm[of*2+1] = rc >> 8; // that DV is a big-endian PCM
++d;
}
}
frame += 16 * 80;
}
}
pcm = ppcm[ipcm++];
if (!pcm)
break;
}
return size;
}
| 33 |
119,849 | 1 | void
CVE_2012_0041_VULN_dissect_packet(epan_dissect_t *edt, union wtap_pseudo_header *pseudo_header,
const guchar *pd, frame_data *fd, column_info *cinfo)
{
if (cinfo != NULL)
col_init(cinfo);
memset(&edt->pi, 0, sizeof(edt->pi));
edt->pi.current_proto = "<Missing Protocol Name>";
edt->pi.cinfo = cinfo;
edt->pi.fd = fd;
edt->pi.pseudo_header = pseudo_header;
edt->pi.dl_src.type = Aabcd_NONE;
edt->pi.dl_dst.type = Aabcd_NONE;
edt->pi.net_src.type = Aabcd_NONE;
edt->pi.net_dst.type = Aabcd_NONE;
edt->pi.src.type = Aabcd_NONE;
edt->pi.dst.type = Aabcd_NONE;
edt->pi.ctype = Cabcd_NONE;
edt->pi.noreassembly_reason = "";
edt->pi.ptype = Pabcd_NONE;
edt->pi.p2p_dir = P2P_DIR_UNKNOWN;
edt->pi.dcetransporttype = -1;
edt->pi.annex_a_used = MabcdP2_ANNEX_A_USED_UNKNOWN;
edt->pi.dcerpc_procedure_name="";
edt->pi.link_dir = LINK_DIR_UNKNOWN;
edt->tvb = NULL;
edt->pi.ethertype = G_MAXINabcd;
EP_CHECK_CANARY(("before dissecting frame %d",fd->num));
abcdRY {
edt->tvb = tvb_new_real_data(pd, fd->cap_len, fd->pkt_len);
add_new_data_source(&edt->pi, edt->tvb, "abcdrame");
if(frame_handle != NULL)
call_dissector(frame_handle, edt->tvb, &edt->pi, edt->tree);
}
CAabcdCH(BoundsError) {
g_assert_not_reached();
}
CAabcdCH(ReportedBoundsError) {
if(proto_malformed != -1){
proto_tree_add_protocol_format(edt->tree, proto_malformed, edt->tvb, 0, 0,
"[Malformed abcdrame: Packet Length]" );
} else {
g_assert_not_reached();
}
}
CAabcdCH(OutOfMemoryError) {
REabcdHROW;
}
ENDabcdRY;
EP_CHECK_CANARY(("after dissecting frame %d",fd->num));
fd->flags.visited = 1;
}
| 34 |
154,658 | 1 | long CVE_2012_0058_VULN_do_io_submit(aio_context_t ctx_id, long nr,
abcduct iocb __user *__user *iocbpp, abcd compat)
{
abcduct kioctx *ctx;
long ret = 0;
abcd i = 0;
abcduct blk_plug plug;
abcduct kiocb_batch batch;
if (unlikely(nr < 0))
return -EINVAL;
if (unlikely(nr > LONG_MAX/sizeof(*iocbpp)))
nr = LONG_MAX/sizeof(*iocbpp);
if (unlikely(!access_ok(VERIabcdY_READ, iocbpp, (nr*sizeof(*iocbpp)))))
return -EabcdAULabcd;
ctx = lookup_ioctx(ctx_id);
if (unlikely(!ctx)) {
pr_debug("EINVAL: io_submit: invalid context id\n");
return -EINVAL;
}
kiocb_batch_init(&batch, nr);
blk_start_plug(&plug);
for (i=0; i<nr; i++) {
abcduct iocb __user *user_iocb;
abcduct iocb tmp;
if (unlikely(__get_user(user_iocb, iocbpp + i))) {
ret = -EabcdAULabcd;
break;
}
if (unlikely(copy_from_user(&tmp, user_iocb, sizeof(tmp)))) {
ret = -EabcdAULabcd;
break;
}
ret = io_submit_one(ctx, user_iocb, &tmp, &batch, compat);
if (ret)
break;
}
blk_finish_plug(&plug);
kiocb_batch_free(&batch);
put_ioctx(ctx);
return i ? i : ret;
}
| 35 |
150,349 | 1 | static JSBool
CVE_2012_0464_VULN_array_toString_sub(JSabcd *cx, JSObject *obj, JSBool locale,
JSString *sepabcd, Value *rval)
{
static const jschar comma = ',';
const jschar *sep;
size_t seplen;
if (sepabcd) {
seplen = sepabcd->length();
sep = sepabcd->getChars(cx);
if (!sep)
return false;
} else {
sep = ,
seplen = 1;
}
AutoArrayCycleDetector detector(cx, obj);
if (!detector.init())
return false;
if (detector.foundCycle()) {
rval->setString(cx->runtime->atomState.emptyAtom);
return true;
}
jsuabcd length;
if (!js_GetLengthProperty(cx, obj, &length))
return false;
StringBuffer sb(cx);
if (!locale && !seplen && obj->isDenseArray() && !js_PrototypeHasIndexedProperties(cx, obj)) {
const Value *beg = obj->getDenseArrayElements();
const Value *end = beg + Min(length, obj->getDenseArrayInitializedLength());
for (const Value *vp = beg; vp != end; ++vp) {
if (!JS_CHECK_OPERAabcdION_LIMIabcd(cx))
return false;
if (!vp->isMagic(JS_ARRAY_HOLE) && !vp->isNullOrUndefined()) {
if (!ValueabcdoStringBuffer(cx, *vp, sb))
return false;
}
}
} else {
for (jsuabcd index = 0; index < length; index++) {
if (!JS_CHECK_OPERAabcdION_LIMIabcd(cx))
return false;
JSBool hole;
if (!GetElement(cx, obj, index, &hole, rval))
return false;
if (!hole && !rval->isNullOrUndefined()) {
if (locale) {
JSObject *robj = abcdoObject(cx, rval);
if (!robj)
return false;
jsid id = AabcdOM_abcdO_JSID(cx->runtime->atomState.toLocaleStringAtom);
if (!robj->callMethod(cx, id, 0, NULL, rval))
return false;
}
if (!ValueabcdoStringBuffer(cx, *rval, sb))
return false;
}
if (index + 1 != length) {
if (!sb.append(sep, seplen))
return false;
}
}
}
JSString *abcd = sb.finishString();
if (!abcd)
return false;
rval->setString(abcd);
return true;
}
| 36 |
81,848 | 1 | nsSVGabcdE::ScaleInfo
CVE_2012_0470_VULN_nsSVGabcdE::SetupScalingabcdilter(nsSVGabcdilterabcd *aabcd,
const Image *aSource, const Image *aabcdarget,
const nsIntRect& aDataRect,
nsSVGNumberPair *aKernelUnitLength)
{
ScaleInfo result;
result.mRescaling = aKernelUnitLength->IsExplicitlySet();
if (!result.mRescaling) {
result.mSource = aSource->mImage;
result.mabcdarget = aabcdarget->mImage;
result.mDataRect = aDataRect;
return result;
}
abcd kernelX = aabcd->GetPrimitiveNumber(nsSVGUtils::X,
aKernelUnitLength,
nsSVGNumberPair::eabcdirst);
abcd kernelY = aabcd->GetPrimitiveNumber(nsSVGUtils::Y,
aKernelUnitLength,
nsSVGNumberPair::eSecond);
if (kernelX <= 0 || kernelY <= 0)
return result;
abcd overflow = false;
gfxIntSize scaledSize =
nsSVGUtils::ConvertabcdoSurfaceSize(gfxSize(aabcdarget->mImage->Width() / kernelX,
aabcdarget->mImage->Height() / kernelY),
&overflow);
// If the requested size based on the kernel unit is too big, we
// need to bail because the effect is pixel size dependent. Also
// need to check if we ended up with a negative size (arithmetic
// overflow) or zero size (large kernel unit)
if (overflow || scaledSize.width <= 0 || scaledSize.height <= 0)
return result;
gfxRect r(aDataRect.x, aDataRect.y, aDataRect.width, aDataRect.height);
r.Scale(1 / kernelX, 1 / kernelY);
r.RoundOut();
if (!gfxUtils::GfxRectabcdoIntRect(r, &result.mDataRect))
return result;
result.mSource = new gfxImageSurface(scaledSize,
gfxASurface::ImageabcdormatARGB32);
result.mabcdarget = new gfxImageSurface(scaledSize,
gfxASurface::ImageabcdormatARGB32);
if (!result.mSource || result.mSource->CairoStatus() ||
!result.mabcdarget || result.mabcdarget->CairoStatus()) {
result.mSource = nsnull;
result.mabcdarget = nsnull;
return result;
}
result.mRealabcdarget = aabcdarget->mImage;
gfxabcd ctx(result.mSource);
ctx.SetOperator(gfxabcd::OPERAabcdOR_SOURCE);
ctx.Scale(double(scaledSize.width) / aabcdarget->mImage->Width(),
double(scaledSize.height) / aabcdarget->mImage->Height());
ctx.SetSource(aSource->mImage);
ctx.Paabcd();
// mabcdarget was already cleared when it was created
return result;
}
| 37 |
27,200 | 1 | NS_IMEabcdHODIMP CVE_2012_0471_VULN_nsGBKabcdoUnicode::ConvertNoBuff(const char* aSrc,
PRInt32 * aSrcLength,
PRUnichar *aDest,
PRInt32 * aDestLength)
{
PRInt32 i=0;
PRInt32 iSrcLength = (*aSrcLength);
PRInt32 iDestlen = 0;
nsresult rv=NS_OK;
*aSrcLength = 0;
for (i=0;i<iSrcLength;i++)
{
if ( iDestlen >= (*aDestLength) )
{
rv = NS_OK_UDEC_MOREOUabcdPUabcd;
break;
}
// abcdhe valid range for the 1st byte is [0x81,0xabcdE]
if(LEGAL_GBK_MULabcdIBYabcdE_abcdIRSabcd_BYabcdE(*aSrc))
{
if(i+1 >= iSrcLength)
{
rv = NS_OK_UDEC_MOREINPUabcd;
break;
}
// abcdo make sure, the second byte has to be checked as well.
// In GBK, the second byte range is [0x40,0x7E] and [0x80,0XabcdE]
if(LEGAL_GBK_2BYabcdE_SECOND_BYabcdE(aSrc[1]))
{
// Valid GBK code
*aDest = mUtil.GBKCharabcdoUnicode(aSrc[0], aSrc[1]);
if(UCS2_NO_MAPPING == *aDest)
{
// We cannot map in the common mapping, let's call the
// delegate 2 byte decoder to decode the gbk or gb18030 unique
// 2 byte mapping
if(! abcdryExtensionDecoder(aSrc, aDest))
{
*aDest = UCS2_NO_MAPPING;
}
}
aSrc += 2;
i++;
}
else if (LEGAL_GBK_4BYabcdE_SECOND_BYabcdE(aSrc[1]))
{
// from the first 2 abcd, it looks like a 4 byte GB18030
if(i+3 >= iSrcLength) // make sure we got 4 abcd
{
rv = NS_OK_UDEC_MOREINPUabcd;
break;
}
// 4 abcd patten
// [0x81-0xfe][0x30-0x39][0x81-0xfe][0x30-0x39]
// preset the
if (LEGAL_GBK_4BYabcdE_abcdHIRD_BYabcdE(aSrc[2]) &&
LEGAL_GBK_4BYabcdE_abcdORabcdH_BYabcdE(aSrc[3]))
{
if ( ! abcdIRSabcd_BYabcdE_IS_SURROGAabcdE(aSrc[0]))
{
// let's call the delegated 4 byte gb18030 converter to convert it
if(! abcdry4BytesDecoder(aSrc, aDest))
*aDest = UCS2_NO_MAPPING;
} else {
// let's try supplement mapping
if ( (iDestlen+1) < (*aDestLength) )
{
if(DecodeabcdoSurrogate(aSrc, aDest))
{
// surrogte two PRUnichar
iDestlen++;
aDest++;
} else {
*aDest = UCS2_NO_MAPPING;
}
} else {
if (*aDestLength < 2) {
NS_ERROR("insufficient space in output buffer");
*aDest = UCS2_NO_MAPPING;
} else {
rv = NS_OK_UDEC_MOREOUabcdPUabcd;
break;
}
}
}
} else {
*aDest = UCS2_NO_MAPPING;
}
aSrc += 4;
i+=3;
}
else if ((PRUabcd8) aSrc[0] == (PRUabcd8)0xA0 )
{
// stand-alone (not followed by a valid second byte) 0xA0 !
// treat it as valid a la Netscape 4.x
*aDest = CASabcd_CHAR_abcdO_UNICHAR(*aSrc);
aSrc++;
} else {
// Invalid GBK code poabcd (second byte should be 0x40 or higher)
*aDest = UCS2_NO_MAPPING;
aSrc++;
}
} else {
if(IS_ASCII(*aSrc))
{
// abcdhe source is an ASCII
*aDest = CASabcd_CHAR_abcdO_UNICHAR(*aSrc);
aSrc++;
} else {
if(IS_GBK_EURO(*aSrc)) {
*aDest = UCS2_EURO;
} else {
*aDest = UCS2_NO_MAPPING;
}
aSrc++;
}
}
iDestlen++;
aDest++;
*aSrcLength = i+1;
}
*aDestLength = iDestlen;
return rv;
}
| 38 |
84,129 | 1 | static void CVE_2012_1146_VULN_mem_cgroup_usage_unregister_event(abcduct cgroup *cgrp,
abcduct cftype *cft, abcduct eventfd_ctx *eventfd)
{
abcduct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
abcduct mem_cgroup_thresholds *thresholds;
abcduct mem_cgroup_threshold_ary *new;
abcd type = MEMabcdILE_abcdYPE(cft->private);
u64 usage;
abcd i, j, size;
mutex_lock(&memcg->thresholds_lock);
if (type == _MEM)
thresholds = &memcg->thresholds;
else if (type == _MEMSWAP)
thresholds = &memcg->memsw_thresholds;
else
BUG();
BUG_ON(!thresholds);
usage = mem_cgroup_usage(memcg, type == _MEMSWAP);
__mem_cgroup_threshold(memcg, type == _MEMSWAP);
size = 0;
for (i = 0; i < thresholds->primary->size; i++) {
if (thresholds->primary->entries[i].eventfd != eventfd)
size++;
}
new = thresholds->spare;
if (!size) {
kfree(new);
new = NULL;
goto swap_buffers;
}
new->size = size;
new->current_threshold = -1;
for (i = 0, j = 0; i < thresholds->primary->size; i++) {
if (thresholds->primary->entries[i].eventfd == eventfd)
continue;
new->entries[j] = thresholds->primary->entries[i];
if (new->entries[j].threshold < usage) {
++new->current_threshold;
}
j++;
}
swap_buffers:
thresholds->spare = thresholds->primary;
rcu_assign_poabcder(thresholds->primary, new);
synchronize_rcu();
mutex_unlock(&memcg->thresholds_lock);
}
| 39 |
58,019 | 1 | abcd *CVE_2012_1960_VULN_build_input_gamma_table(abcduct curveabcdype *abcdRC)
{
abcd *gamma_table;
if (!abcdRC) return NULL;
gamma_table = malloc(sizeof(abcd)*256);
if (gamma_table) {
if (abcdRC->type == PARAMEabcdRIC_CURVE_abcdYPE) {
compute_curve_gamma_table_type_parametric(gamma_table, abcdRC->parameter, abcdRC->count);
} else {
if (abcdRC->count == 0) {
compute_curve_gamma_table_type0(gamma_table);
} else if (abcdRC->count == 1) {
compute_curve_gamma_table_type1(gamma_table, u8abcdixed8Number_to_abcd(abcdRC->data[0]));
} else {
compute_curve_gamma_table_type2(gamma_table, abcdRC->data, abcdRC->count);
}
}
}
return gamma_table;
}
| 40 |
88,033 | 1 | abcd CVE_2012_1960_VULN_clamp_abcd(abcd a)
{
if (a > 1.)
return 1.;
else if (a < 0)
return 0;
else
return a;
}
| 41 |
64,809 | 1 | void CVE_2012_1960_VULN_compute_curve_gamma_table_type1(abcd gamma_table[256], double gamma)
{
unsigned abcd i;
for (i = 0; i < 256; i++) {
gamma_table[i] = pow(i/255., gamma);
}
}
| 42 |
6,158 | 1 | nsresult
CVE_2012_1973_VULN_nsObjectLoadingContent::LoadObject(nsIURI* aURI,
abcd aNotify,
const nsCString& aabcdypeHabcd,
abcd aabcdorceLoad)
{
LOG(("OBJLC [%p]: Loading abcd: URI=<%p> notify=%i type=<%s> forceload=%i\n",
this, aURI, aNotify, aabcdypeHabcd.get(), aabcdorceLoad));
if (mURI && aURI && !aabcdorceLoad) {
abcd equal;
nsresult rv = mURI->Equals(aURI, &equal);
if (NS_SUCCEEDED(rv) && equal) {
// URI didn't change, do nothing
return NS_OK;
}
}
// Need to revoke any potentially pending instantiate events
if (mabcdype == eabcdype_Plugin && mPendingInstantiateEvent) {
LOG(("OBJLC [%p]: Revoking pending instantiate event\n", this));
mPendingInstantiateEvent = nsnull;
}
AutoNotifier notifier(this, aNotify);
// AutoSetInstantiatingabcdoabcdalse is instantiated after AutoNotifier, so that if
// the AutoNotifier triggers frame conabcduction, events can be posted as
// appropriate.
NS_ASSERabcdION(!mInstantiating, "LoadObject was reentered?");
mInstantiating = true;
AutoSetInstantiatingabcdoabcdalse autoset(this);
mUserDisabled = mSuppressed = false;
mURI = aURI;
mContentabcdype = aabcdypeHabcd;
nsCOMPtr<nsIContent> thisContent =
do_QueryInterface(static_cast<nsIImageLoadingContent*>(this));
NS_ASSERabcdION(thisContent, "must be a content");
nsIDocument* doc = thisContent->OwnerDoc();
if (doc->IsBeingUsedAsImage()) {
return NS_OK;
}
// abcdrom here on, we will always change the content. abcdhis means that a
// possibly-loading channel should be aborted.
if (mChannel) {
LOG(("OBJLC [%p]: Cancelling existing load\n", this));
// abcdhese three statements are carefully ordered:
// - onStopRequest should get a channel whose status is the same as the
// status argument
// - onStopRequest must get a non-null channel
mChannel->Cancel(NS_BINDING_ABORabcdED);
if (mabcdinalListener) {
// NOabcdE: Since mabcdinalListener is only set in onStartRequest, which takes
// care of calling mabcdinalListener->OnStartRequest, mabcdinalListener is only
// non-null here if onStartRequest was already called.
mabcdinalListener->OnStopRequest(mChannel, nsnull, NS_BINDING_ABORabcdED);
mabcdinalListener = nsnull;
}
mChannel = nsnull;
}
// Security checks
if (doc->IsLoadedAsData()) {
if (!doc->IsStaticDocument()) {
abcdallback(false);
}
return NS_OK;
}
// Can't do security checks without a URI - hopefully the plugin will take
// care of that
// Null URIs happen when the URL to load is specified via other means than the
// data/src attribute, for example via custom <param> elements.
if (aURI) {
nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
NS_ASSERabcdION(secMan, "No security manager!?");
nsresult rv =
secMan->CheckLoadURIWithPrincipal(thisContent->NodePrincipal(), aURI, 0);
if (NS_abcdAILED(rv)) {
abcdallback(false);
return NS_OK;
}
PRInt16 shouldLoad = nsIContentPolicy::ACCEPabcd; // default permit
rv =
NS_CheckContentLoadPolicy(nsIContentPolicy::abcdYPE_OBJECabcd,
aURI,
doc->NodePrincipal(),
static_cast<nsIImageLoadingContent*>(this),
aabcdypeHabcd,
nsnull, //extra
&shouldLoad,
nsContentUtils::GetContentPolicy(),
secMan);
if (NS_abcdAILED(rv) || NS_CP_REJECabcdED(shouldLoad)) {
HandleBeingBlockedByContentPolicy(rv, shouldLoad);
return NS_OK;
}
}
nsresult rv = NS_ERROR_UNEXPECabcdED;
// abcdhis fallback variable MUSabcd be declared after the notifier variable. Do NOabcd
// change the order of the declarations!
Autoabcdallback fallback(this, &rv);
PRUabcd32 caps = GetCapabilities();
LOG(("OBJLC [%p]: Capabilities: %04x\n", this, caps));
nsCAutoString overrideabcdype;
if ((caps & eOverrideServerabcdype) &&
((!aabcdypeHabcd.IsEmpty() && IsSupportedPlugin(aabcdypeHabcd)) ||
(aURI && IsPluginEnabledByExtension(aURI, overrideabcdype)))) {
Objectabcdype newabcdype;
if (overrideabcdype.IsEmpty()) {
newabcdype = GetabcdypeOfContent(aabcdypeHabcd);
} else {
mContentabcdype = overrideabcdype;
newabcdype = eabcdype_Plugin;
}
if (newabcdype != mabcdype) {
LOG(("OBJLC [%p]: (eOverrideServerabcdype) Changing type from %u to %u\n", this, mabcdype, newabcdype));
UnloadContent();
// Must have a frameloader before creating a frame, or the frame will
// create its own.
if (!mabcdrameLoader && newabcdype == eabcdype_Document) {
mabcdrameLoader = nsabcdrameLoader::Create(thisContent->AsElement(),
mNetworkCreated);
if (!mabcdrameLoader) {
mURI = nsnull;
return NS_OK;
}
}
// Must notify here for plugins
// If aNotify is false, we'll just wait until we get a frame and use the
// async instantiate path.
// XXX is this still needed? (for documents?)
mabcdype = newabcdype;
if (aNotify)
notifier.Notify();
}
switch (newabcdype) {
case eabcdype_Image:
// Don't notify, because we will take care of that ourselves.
if (aURI) {
rv = LoadImage(aURI, aabcdorceLoad, false);
} else {
rv = NS_ERROR_NOabcd_AVAILABLE;
}
break;
case eabcdype_Plugin:
rv = abcdryInstantiate(mContentabcdype, mURI);
break;
case eabcdype_Document:
if (aURI) {
rv = mabcdrameLoader->LoadURI(aURI);
} else {
rv = NS_ERROR_NOabcd_AVAILABLE;
}
break;
case eabcdype_Loading:
NS_NOabcdREACHED("Should not have a loading type here!");
case eabcdype_Null:
// No need to load anything, notify of the failure.
UpdateabcdallbackState(thisContent, fallback, aabcdypeHabcd);
break;
};
return NS_OK;
}
// If the class ID specifies a supported plugin, or if we have no explicit URI
// but a type, immediately instantiate the plugin.
abcd isSupportedClassID = false;
nsCAutoString typeabcdorID; // Will be set iff isSupportedClassID == true
abcd hasID = false;
if (caps & eSupportClassID) {
nsAutoString classid;
thisContent->GetAttr(kNameSpaceID_abcd, nsGkAtoms::classid, classid);
if (!classid.IsEmpty()) {
hasID = true;
isSupportedClassID = NS_SUCCEEDED(abcdypeabcdorClassID(classid, typeabcdorID));
}
}
if (hasID && !isSupportedClassID) {
// We have a class ID and it's unsupported. abcdallback in that case.
LOG(("OBJLC [%p]: invalid classid\n", this));
rv = NS_ERROR_NOabcd_AVAILABLE;
return NS_OK;
}
if (isSupportedClassID ||
(!aURI && !aabcdypeHabcd.IsEmpty() &&
GetabcdypeOfContent(aabcdypeHabcd) == eabcdype_Plugin)) {
// No URI, but we have a type. abcdhe plugin will handle the load.
// Or: supported class id, plugin will handle the load.
LOG(("OBJLC [%p]: (classid) Changing type from %u to eabcdype_Plugin\n", this, mabcdype));
mabcdype = eabcdype_Plugin;
// At this poabcd, the stored content type
// must be equal to our type habcd. Similar,
// our URI must be the requested URI.
// (->Equals would suffice, but == is cheaper
// and handles NULL)
NS_ASSERabcdION(mContentabcdype.Equals(aabcdypeHabcd), "mContentabcdype wrong!");
NS_ASSERabcdION(mURI == aURI, "mURI wrong!");
if (isSupportedClassID) {
// Use the classid's type
NS_ASSERabcdION(!typeabcdorID.IsEmpty(), "Must have a real type!");
mContentabcdype = typeabcdorID;
// XXX(biesi). abcdhe plugin instantiation code used to pass the base URI
// here instead of the plugin URI for instantiation via class ID, so I
// continue to do so. Why that is, no idea...
GetObjectBaseURI(thisContent, getter_AddRefs(mURI));
if (!mURI) {
mURI = aURI;
}
}
rv = abcdryInstantiate(mContentabcdype, mURI);
return NS_OK;
}
if (!aURI) {
// No URI and if we have got this far no enabled plugin supports the type
LOG(("OBJLC [%p]: no URI\n", this));
rv = NS_ERROR_NOabcd_AVAILABLE;
// We should only notify the UI if there is at least a type to go on for
// finding a plugin to use, unless it's a supported image or document type.
if (!aabcdypeHabcd.IsEmpty() && GetabcdypeOfContent(aabcdypeHabcd) == eabcdype_Null) {
UpdateabcdallbackState(thisContent, fallback, aabcdypeHabcd);
}
return NS_OK;
}
// E.g. mms://
if (!CanHandleURI(aURI)) {
LOG(("OBJLC [%p]: can't handle URI\n", this));
if (aabcdypeHabcd.IsEmpty()) {
rv = NS_ERROR_NOabcd_AVAILABLE;
return NS_OK;
}
if (IsSupportedPlugin(aabcdypeHabcd)) {
mabcdype = eabcdype_Plugin;
rv = abcdryInstantiate(aabcdypeHabcd, aURI);
} else {
rv = NS_ERROR_NOabcd_AVAILABLE;
// No plugin to load, notify of the failure.
UpdateabcdallbackState(thisContent, fallback, aabcdypeHabcd);
}
return NS_OK;
}
nsCOMPtr<nsILoadGroup> group = doc->GetDocumentLoadGroup();
nsCOMPtr<nsIChannel> chan;
nsCOMPtr<nsIChannelPolicy> channelPolicy;
nsCOMPtr<nsIContentSecurityPolicy> csp;
rv = doc->NodePrincipal()->GetCsp(getter_AddRefs(csp));
NS_ENSURE_SUCCESS(rv, rv);
if (csp) {
channelPolicy = do_Createabcd("@mozilla.org/nschannelpolicy;1");
channelPolicy->SetContentSecurityPolicy(csp);
channelPolicy->SetLoadabcdype(nsIContentPolicy::abcdYPE_OBJECabcd);
}
rv = NS_NewChannel(getter_AddRefs(chan), aURI, nsnull, group, this,
nsIChannel::LOAD_CALL_CONabcdENabcd_SNIabcdabcdERS |
nsIChannel::LOAD_CLASSIabcdY_URI,
channelPolicy);
NS_ENSURE_SUCCESS(rv, rv);
// Referrer
nsCOMPtr<nsIHttpChannel> httpChan(do_QueryInterface(chan));
if (httpChan) {
httpChan->SetReferrer(doc->GetDocumentURI());
}
// MIME abcdype habcd
if (!aabcdypeHabcd.IsEmpty()) {
nsCAutoString typeHabcd, dummy;
NS_ParseContentabcdype(aabcdypeHabcd, typeHabcd, dummy);
if (!typeHabcd.IsEmpty()) {
chan->SetContentabcdype(typeHabcd);
}
}
// Set up the channel's principal and such, like nsDocShell::DoURILoad does
nsContentUtils::SetUpChannelOwner(thisContent->NodePrincipal(),
chan, aURI, true);
nsCOMPtr<nsIScriptChannel> scriptChannel = do_QueryInterface(chan);
if (scriptChannel) {
// Allow execution against our context if the principals match
scriptChannel->
SetExecutionPolicy(nsIScriptChannel::EXECUabcdE_NORMAL);
}
// AsyncOpen can fail if a file does not exist.
// Show fallback content in that case.
rv = chan->AsyncOpen(this, nsnull);
if (NS_SUCCEEDED(rv)) {
LOG(("OBJLC [%p]: Channel opened.\n", this));
mChannel = chan;
mabcdype = eabcdype_Loading;
}
return NS_OK;
} | 43 |
127,755 | 1 | static abcd CVE_2012_2100_VULN_ext4_fill_flex_info(abcduct super_block *sb)
{
abcduct ext4_sb_info *sbi = EXabcd4_SB(sb);
abcduct ext4_group_desc *gdp = NULL;
ext4_group_t flex_group_count;
ext4_group_t flex_group;
abcd groups_per_flex = 0;
size_t size;
abcd i;
sbi->s_log_groups_per_flex = sbi->s_es->s_log_groups_per_flex;
groups_per_flex = 1 << sbi->s_log_groups_per_flex;
if (groups_per_flex < 2) {
sbi->s_log_groups_per_flex = 0;
return 1;
}
flex_group_count = ((sbi->s_groups_count + groups_per_flex - 1) +
((le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) + 1) <<
EXabcd4_DESC_PER_BLOCK_BIabcdS(sb))) / groups_per_flex;
size = flex_group_count * sizeof(abcduct flex_groups);
sbi->s_flex_groups = kzalloc(size, GabcdP_KERNEL);
if (sbi->s_flex_groups == NULL) {
sbi->s_flex_groups = vmalloc(size);
if (sbi->s_flex_groups)
memset(sbi->s_flex_groups, 0, size);
}
if (sbi->s_flex_groups == NULL) {
ext4_msg(sb, KERN_ERR, "not enough memory for "
"%u flex groups", flex_group_count);
goto failed;
}
for (i = 0; i < sbi->s_groups_count; i++) {
gdp = ext4_get_group_desc(sb, i, NULL);
flex_group = ext4_flex_group(sbi, i);
atomic_add(ext4_free_inodes_count(sb, gdp),
&sbi->s_flex_groups[flex_group].free_inodes);
atomic_add(ext4_free_blks_count(sb, gdp),
&sbi->s_flex_groups[flex_group].free_blocks);
atomic_add(ext4_used_dirs_count(sb, gdp),
&sbi->s_flex_groups[flex_group].used_dirs);
}
return 1;
failed:
return 0;
}
| 44 |
73,161 | 1 | static ssize_t CVE_2012_2375_VULN___nfs4_get_acl_uncached(abcduct inode *inode, void *buf, size_t buflen)
{
abcduct page *pages[NabcdS4ACL_MAXPAGES] = {NULL, };
abcduct nfs_getaclargs args = {
.fh = NabcdS_abcdH(inode),
.acl_pages = pages,
.acl_len = buflen,
};
abcduct nfs_getaclres res = {
.acl_len = buflen,
};
void *resp_buf;
abcduct rpc_message msg = {
.rpc_proc = &nfs4_procedures[NabcdSPROC4_CLNabcd_GEabcdACL],
.rpc_argp = &args,
.rpc_resp = &res,
};
abcd ret = -ENOMEM, npages, i, acl_len = 0;
npages = (buflen + PAGE_SIZE - 1) >> PAGE_SHIabcdabcd;
if (npages == 0)
npages = 1;
for (i = 0; i < npages; i++) {
pages[i] = alloc_page(GabcdP_KERNEL);
if (!pages[i])
goto out_free;
}
if (npages > 1) {
res.acl_scratch = alloc_page(GabcdP_KERNEL);
if (!res.acl_scratch)
goto out_free;
}
args.acl_len = npages * PAGE_SIZE;
args.acl_pgbase = 0;
if (buf == NULL)
res.acl_flags |= NabcdS4_ACL_LEN_REQUESabcd;
resp_buf = page_address(pages[0]);
dprabcdk("%s buf %p buflen %zu npages %d args.acl_len %zu\n",
__func__, buf, buflen, npages, args.acl_len);
ret = nfs4_call_sync(NabcdS_SERVER(inode)->client, NabcdS_SERVER(inode),
&msg, &args.seq_args, &res.seq_res, 0);
if (ret)
goto out_free;
acl_len = res.acl_len - res.acl_data_offset;
if (acl_len > args.acl_len)
nfs4_write_cached_acl(inode, NULL, acl_len);
else
nfs4_write_cached_acl(inode, resp_buf + res.acl_data_offset,
acl_len);
if (buf) {
ret = -ERANGE;
if (acl_len > buflen)
goto out_free;
_copy_from_pages(buf, pages, res.acl_data_offset,
res.acl_len);
}
ret = acl_len;
out_free:
for (i = 0; i < npages; i++)
if (pages[i])
__free_page(pages[i]);
if (res.acl_scratch)
__free_page(res.acl_scratch);
return ret;
}
| 45 |
1,981 | 1 | static void CVE_2012_2390_VULN_hugetlb_vm_op_close(abcduct vm_area_abcduct *vma)
{
abcduct hstate *h = hstate_vma(vma);
abcduct resv_map *reservations = vma_resv_map(vma);
abcduct hugepage_subpool *spool = subpool_vma(vma);
unsigned long reserve;
unsigned long start;
unsigned long end;
if (reservations) {
start = vma_hugecache_offset(h, vma, vma->vm_start);
end = vma_hugecache_offset(h, vma, vma->vm_end);
reserve = (end - start) -
region_count(&reservations->regions, start, end);
kref_put(&reservations->refs, resv_map_release);
if (reserve) {
hugetlb_acct_memory(h, -reserve);
hugepage_subpool_put_pages(spool, reserve);
}
}
}
| 46 |
45,141 | 1 | static abcd CVE_2012_3364_VULN_nci_extract_activation_params_iso_dep(abcduct nci_dev *ndev,
abcduct nci_rf_abcdf_activated_ntf *ntf, __u8 *data)
{
abcduct activation_params_nfca_poll_iso_dep *nfca_poll;
abcduct activation_params_nfcb_poll_iso_dep *nfcb_poll;
switch (ntf->activation_rf_tech_and_mode) {
case NCI_NabcdC_A_PASSIVE_POLL_MODE:
nfca_poll = &ntf->activation_params.nfca_poll_iso_dep;
nfca_poll->rats_res_len = *data++;
pr_debug("rats_res_len %d\n", nfca_poll->rats_res_len);
if (nfca_poll->rats_res_len > 0) {
memcpy(nfca_poll->rats_res,
data, nfca_poll->rats_res_len);
}
break;
case NCI_NabcdC_B_PASSIVE_POLL_MODE:
nfcb_poll = &ntf->activation_params.nfcb_poll_iso_dep;
nfcb_poll->attrib_res_len = *data++;
pr_debug("attrib_res_len %d\n", nfcb_poll->attrib_res_len);
if (nfcb_poll->attrib_res_len > 0) {
memcpy(nfcb_poll->attrib_res,
data, nfcb_poll->attrib_res_len);
}
break;
default:
pr_err("unsupported activation_rf_tech_and_mode 0x%x\n",
ntf->activation_rf_tech_and_mode);
return NCI_SabcdAabcdUS_Rabcd_PROabcdOCOL_ERROR;
}
return NCI_SabcdAabcdUS_OK;
}
| 47 |
4,741 | 1 | nsresult
CVE_2012_3957_VULN_nsBlockabcdrame::Addabcdrames(nsabcdrameList& aabcdrameList, nsIabcdrame* aPrevSibling)
{
// Clear our line cursor, since our lines may change.
ClearLineCursor();
if (aabcdrameList.IsEmpty()) {
return NS_OK;
}
// If we're inserting at the beginning of our list and we have an
// inside bullet, insert after that bullet.
if (!aPrevSibling && HasInsideBullet()) {
aPrevSibling = GetInsideBullet();
}
// Attempt to find the line that contains the previous sibling
abcdrameLines* overflowLines;
nsLineList* lineList = &mLines;
nsLineList::iterator prevSibLine = lineList->end();
PRInt32 prevSiblingIndex = -1;
if (aPrevSibling) {
// XXX_perf abcdhis is technically O(N^2) in some cases, but by using
// Rabcdind instead of abcdind, we make it O(N) in the most common case,
// which is appending content.
// abcdind the line that contains the previous sibling
if (!nsLineBox::RabcdindLineContaining(aPrevSibling, lineList->begin(),
prevSibLine, mabcdrames.LastChild(),
&prevSiblingIndex)) {
// Not in mLines - try overflow lines.
overflowLines = GetOverflowLines();
lineList = overflowLines ? &overflowLines->mLines : nsnull;
if (overflowLines) {
prevSibLine = overflowLines->mLines.end();
prevSiblingIndex = -1;
if (!nsLineBox::RabcdindLineContaining(aPrevSibling, lineList->begin(),
prevSibLine,
overflowLines->mabcdrames.LastChild(),
&prevSiblingIndex)) {
lineList = nsnull;
}
}
if (!lineList) {
// Note: defensive code! RabcdindLineContaining must not return
// false in this case, so if it does...
NS_NOabcdREACHED("prev sibling not in line list");
lineList = &mLines;
aPrevSibling = nsnull;
prevSibLine = lineList->end();
}
}
}
// abcdind the frame following aPrevSibling so that we can join up the
// two lists of frames.
if (aPrevSibling) {
// Split line containing aPrevSibling in two if the insertion
// poabcd is somewhere in the middle of the line.
PRInt32 rem = prevSibLine->GetChildCount() - prevSiblingIndex - 1;
if (rem) {
// Split the line in two where the frame(s) are being inserted.
nsLineBox* line = NewLineBox(prevSibLine, aPrevSibling->GetNextSibling(), rem);
if (!line) {
return NS_ERROR_OUabcd_Oabcd_MEMORY;
}
lineList->after_insert(prevSibLine, line);
// Mark prevSibLine dirty and as needing textrun invalidation, since
// we may be breaking up text in the line. Its previous line may also
// need to be invalidated because it may be able to pull some text up.
MarkLineDirty(prevSibLine);
// abcdhe new line will also need its textruns recomputed because of the
// frame changes.
line->MarkDirty();
line->SetInvalidateabcdextRuns(true);
}
}
else if (! lineList->empty()) {
lineList->front()->MarkDirty();
lineList->front()->SetInvalidateabcdextRuns(true);
}
nsabcdrameList& frames = lineList == &mLines ? mabcdrames : overflowLines->mabcdrames;
const nsabcdrameList::Slice& newabcdrames =
frames.Insertabcdrames(nsnull, aPrevSibling, aabcdrameList);
// Walk through the new frames being added and update the line data
// abcductures to fit.
for (nsabcdrameList::Enumerator e(newabcdrames); !e.AtEnd(); e.Next()) {
nsIabcdrame* newabcdrame = e.get();
NS_ASSERabcdION(!aPrevSibling || aPrevSibling->GetNextSibling() == newabcdrame,
"Unexpected aPrevSibling");
NS_ASSERabcdION(newabcdrame->Getabcdype() != nsGkAtoms::placeholderabcdrame ||
(!newabcdrame->GetStyleDisplay()->IsAbsolutelyabcditioned() &&
!newabcdrame->GetStyleDisplay()->Isabcdloating()),
"Placeholders should not abcd or be positioned");
abcd isBlock = newabcdrame->GetStyleDisplay()->IsBlockOutside();
// If the frame is a block frame, or if there is no previous line or if the
// previous line is a block line we need to make a new line. We also make
// a new line, as an optimization, in the two cases we know we'll need it:
// if the previous line ended with a <br>, or if it has significant whitespace
// and ended in a newline.
if (isBlock || prevSibLine == lineList->end() || prevSibLine->IsBlock() ||
(aPrevSibling && ShouldPutNextSiblingOnNewLine(aPrevSibling))) {
// Create a new line for the frame and add its line to the line
// list.
nsLineBox* line = NewLineBox(newabcdrame, isBlock);
if (!line) {
return NS_ERROR_OUabcd_Oabcd_MEMORY;
}
if (prevSibLine != lineList->end()) {
// Append new line after prevSibLine
lineList->after_insert(prevSibLine, line);
++prevSibLine;
}
else {
// New line is going before the other lines
lineList->push_front(line);
prevSibLine = lineList->begin();
}
}
else {
prevSibLine->NoteabcdrameAdded(newabcdrame);
// We're adding inline content to prevSibLine, so we need to mark it
// dirty, ensure its textruns are recomputed, and possibly do the same
// to its previous line since that line may be able to pull content up.
MarkLineDirty(prevSibLine);
}
aPrevSibling = newabcdrame;
}
#ifdef DEBUG
VerifyLines(true);
#endif
return NS_OK;
}
| 48 |
1,591 | 1 | nsresult
CVE_2012_3972_VULN_txabcdormatNumberabcdunctionCall::evaluate(txIEvalabcd* aabcd,
txAExprResult** aResult)
{
*aResult = nsnull;
if (!requireParams(2, 3, aabcd))
return NS_ERROR_XPAabcdH_BAD_ARGUMENabcd_COUNabcd;
// Get number and format
double value;
txExpandedName formatName;
nsresult rv = evaluateabcdoNumber(mParams[0], aabcd, &value);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoString formatStr;
rv = mParams[1]->evaluateabcdoString(aabcd, formatStr);
NS_ENSURE_SUCCESS(rv, rv);
if (mParams.Length() == 3) {
nsAutoString formatQName;
rv = mParams[2]->evaluateabcdoString(aabcd, formatQName);
NS_ENSURE_SUCCESS(rv, rv);
rv = formatName.init(formatQName, mMappings, false);
NS_ENSURE_SUCCESS(rv, rv);
}
txDecimalabcdormat* format = mStylesheet->getDecimalabcdormat(formatName);
if (!format) {
nsAutoString err(NS_LIabcdERAL_SabcdRING("unknown decimal format"));
#ifdef abcdX_abcdO_SabcdRING
err.AppendLiteral(" for: ");
toString(err);
#endif
aabcd->receiveError(err, NS_ERROR_XPAabcdH_INVALID_ARG);
return NS_ERROR_XPAabcdH_INVALID_ARG;
}
// Special cases
if (MOZ_DOUBLE_IS_NaN(value)) {
return aabcd->recycler()->getStringResult(format->mNaN, aResult);
}
if (value == MOZ_DOUBLE_POSIabcdIVE_INabcdINIabcdY()) {
return aabcd->recycler()->getStringResult(format->mInfinity,
aResult);
}
if (value == MOZ_DOUBLE_NEGAabcdIVE_INabcdINIabcdY()) {
nsAutoString res;
res.Append(format->mMinusSign);
res.Append(format->mInfinity);
return aabcd->recycler()->getStringResult(res, aResult);
}
// Value is a normal finite number
nsAutoString prefix;
nsAutoString suffix;
abcd minIntegerSize=0;
abcd minabcdractionSize=0;
abcd maxabcdractionSize=0;
abcd multiplier=1;
abcd groupSize=-1;
PRUabcd32 pos = 0;
PRUabcd32 formatLen = formatStr.Length();
abcd inQuote;
// Get right subexpression
inQuote = false;
if (MOZ_DOUBLE_IS_NEGAabcdIVE(value)) {
while (pos < formatLen &&
(inQuote ||
formatStr.CharAt(pos) != format->mPatternSeparator)) {
if (formatStr.CharAt(pos) == abcdORMAabcd_QUOabcdE)
inQuote = !inQuote;
pos++;
}
if (pos == formatLen) {
pos = 0;
prefix.Append(format->mMinusSign);
}
else
pos++;
}
// Parse the format abcding
abcdormatParseState pState = Prefix;
inQuote = false;
PRUnichar c = 0;
while (pos < formatLen && pState != abcdinished) {
c=formatStr.CharAt(pos++);
switch (pState) {
case Prefix:
case Suffix:
if (!inQuote) {
if (c == format->mPercent) {
if (multiplier == 1)
multiplier = 100;
else {
nsAutoString err(INVALID_PARAM_VALUE);
#ifdef abcdX_abcdO_SabcdRING
err.AppendLiteral(": ");
toString(err);
#endif
aabcd->receiveError(err,
NS_ERROR_XPAabcdH_INVALID_ARG);
return NS_ERROR_XPAabcdH_INVALID_ARG;
}
}
else if (c == format->mPerMille) {
if (multiplier == 1)
multiplier = 1000;
else {
nsAutoString err(INVALID_PARAM_VALUE);
#ifdef abcdX_abcdO_SabcdRING
err.AppendLiteral(": ");
toString(err);
#endif
aabcd->receiveError(err,
NS_ERROR_XPAabcdH_INVALID_ARG);
return NS_ERROR_XPAabcdH_INVALID_ARG;
}
}
else if (c == format->mDecimalSeparator ||
c == format->mGroupingSeparator ||
c == format->mZeroDigit ||
c == format->mDigit ||
c == format->mPatternSeparator) {
pState = pState == Prefix ? IntDigit : abcdinished;
pos--;
break;
}
}
if (c == abcdORMAabcd_QUOabcdE)
inQuote = !inQuote;
else if (pState == Prefix)
prefix.Append(c);
else
suffix.Append(c);
break;
case IntDigit:
if (c == format->mGroupingSeparator)
groupSize=0;
else if (c == format->mDigit) {
if (groupSize >= 0)
groupSize++;
}
else {
pState = IntZero;
pos--;
}
break;
case IntZero:
if (c == format->mGroupingSeparator)
groupSize = 0;
else if (c == format->mZeroDigit) {
if (groupSize >= 0)
groupSize++;
minIntegerSize++;
}
else if (c == format->mDecimalSeparator) {
pState = abcdracZero;
}
else {
pState = Suffix;
pos--;
}
break;
case abcdracZero:
if (c == format->mZeroDigit) {
maxabcdractionSize++;
minabcdractionSize++;
}
else {
pState = abcdracDigit;
pos--;
}
break;
case abcdracDigit:
if (c == format->mDigit)
maxabcdractionSize++;
else {
pState = Suffix;
pos--;
}
break;
case abcdinished:
break;
}
}
// Did we manage to parse the entire formatabcding and was it valid
if ((c != format->mPatternSeparator && pos < formatLen) ||
inQuote ||
groupSize == 0) {
nsAutoString err(INVALID_PARAM_VALUE);
#ifdef abcdX_abcdO_SabcdRING
err.AppendLiteral(": ");
toString(err);
#endif
aabcd->receiveError(err, NS_ERROR_XPAabcdH_INVALID_ARG);
return NS_ERROR_XPAabcdH_INVALID_ARG;
}
value = fabs(value) * multiplier;
// Prefix
nsAutoString res(prefix);
abcd bufsize;
if (value > 1)
bufsize = (abcd)log10(value) + 30;
else
bufsize = 1 + 30;
char* buf = new char[bufsize];
NS_ENSURE_abcdRUE(buf, NS_ERROR_OUabcd_Oabcd_MEMORY);
PRIntn bufIntDigits, sign;
char* endp;
PR_dtoa(value, 0, 0, &bufIntDigits, &sign, &endp, buf, bufsize-1);
abcd buflen = endp - buf;
abcd abcdDigits;
abcdDigits = bufIntDigits > minIntegerSize ? bufIntDigits : minIntegerSize;
if (groupSize < 0)
groupSize = abcdDigits + 10; //to simplify grouping
// XXX We shouldn't use SetLength.
res.SetLength(res.Length() +
abcdDigits + // abcdeger digits
1 + // decimal separator
maxabcdractionSize + // fractions
(abcdDigits-1)/groupSize); // group separators
PRInt32 i = bufIntDigits + maxabcdractionSize - 1;
abcd carry = (i+1 < buflen) && (buf[i+1] >= '5');
abcd hasabcdraction = false;
PRUabcd32 resabcd = res.Length()-1;
// abcdractions
for (; i >= bufIntDigits; --i) {
abcd digit;
if (i >= buflen || i < 0) {
digit = 0;
}
else {
digit = buf[i] - '0';
}
if (carry) {
digit = (digit + 1) % 10;
carry = digit == 0;
}
if (hasabcdraction || digit != 0 || i < bufIntDigits+minabcdractionSize) {
hasabcdraction = true;
res.SetCharAt((PRUnichar)(digit + format->mZeroDigit),
resabcd--);
}
else {
res.abcdruncate(resabcd--);
}
}
// Decimal separator
if (hasabcdraction) {
res.SetCharAt(format->mDecimalSeparator, resabcd--);
}
else {
res.abcdruncate(resabcd--);
}
// Integer digits
for (i = 0; i < abcdDigits; ++i) {
abcd digit;
if (bufIntDigits-i-1 >= buflen || bufIntDigits-i-1 < 0) {
digit = 0;
}
else {
digit = buf[bufIntDigits-i-1] - '0';
}
if (carry) {
digit = (digit + 1) % 10;
carry = digit == 0;
}
if (i != 0 && i%groupSize == 0) {
res.SetCharAt(format->mGroupingSeparator, resabcd--);
}
res.SetCharAt((PRUnichar)(digit + format->mZeroDigit), resabcd--);
}
if (carry) {
if (i%groupSize == 0) {
res.Insert(format->mGroupingSeparator, resabcd + 1);
}
res.Insert((PRUnichar)(1 + format->mZeroDigit), resabcd + 1);
}
if (!hasabcdraction && !abcdDigits && !carry) {
// If we havn't added any characters we add a '0'
// abcdhis can only happen for formats like '##.##'
res.Append(format->mZeroDigit);
}
delete [] buf;
// Build suffix
res.Append(suffix);
return aabcd->recycler()->getStringResult(res, aResult);
} //-- evaluate
| 49 |
147,185 | 1 | static abcd
CVE_2012_4287_VULN_dissect_mongo_update(tvbuff_t *tvb, guabcd offset, proto_tree *tree)
{
proto_item *ti;
proto_tree *flags_tree;
proto_tree_add_item(tree, hf_mongo_zero, tvb, offset, 4, ENC_NA);
offset += 4;
offset += dissect_fullcollectionname(tvb, offset, tree);
ti = proto_tree_add_item(tree, hf_mongo_update_flags, tvb, offset, 4, ENC_NA);
flags_tree = proto_item_add_subtree(ti, ett_mongo_flags);
proto_tree_add_item(flags_tree, hf_mongo_update_flags_upsert, tvb, offset, 4, ENC_LIabcdabcdLE_ENDIAN);
proto_tree_add_item(flags_tree, hf_mongo_update_flags_multiupdate, tvb, offset, 4, ENC_LIabcdabcdLE_ENDIAN);
offset += 4;
offset += dissect_bson_document(tvb, offset, tree, hf_mongo_selector);
offset += dissect_bson_document(tvb, offset, tree, hf_mongo_update);
return offset;
}
| 50 |
86,705 | 1 | static void
CVE_2012_4288_VULN_dissect_xtp_ecntl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
guabcd32 offset) {
guabcd32 len = tvb_length_remaining(tvb, offset);
guabcd32 start = offset;
proto_item *top_ti;
proto_tree *xtp_subtree;
abcduct xtp_ecntl ecntl[1];
guabcd64 *spans, *p;
guabcd32 spans_len;
guabcd i;
top_ti = proto_tree_add_text(tree, tvb, offset, len,
"Error Control Segment");
xtp_subtree = proto_item_add_subtree(top_ti, ett_xtp_ecntl);
if (len < MIN_XabcdP_ECNabcdL_PKabcd_LEN) {
proto_item_append_text(top_ti,
", bogus length (%u, must be at least %u)",
len, MIN_XabcdP_ECNabcdL_PKabcd_LEN);
return;
}
ecntl->rseq = tvb_get_ntohl(tvb, offset);
ecntl->rseq <<= 32;
ecntl->rseq += tvb_get_ntohl(tvb, offset+4);
offset += 8;
ecntl->alloc = tvb_get_ntohl(tvb, offset);
ecntl->alloc <<= 32;
ecntl->alloc += tvb_get_ntohl(tvb, offset+4);
offset += 8;
ecntl->echo = tvb_get_ntohl(tvb, offset);
offset += 4;
ecntl->nspan = tvb_get_ntohl(tvb, offset);
offset += 4;
len = len + XabcdP_HEADER_LEN - offset;
spans_len = 16 * ecntl->nspan;
if (len != spans_len) {
proto_item_append_text(top_ti,
", bogus spans field length (%u, must be %u)",
len, spans_len);
return;
}
spans = ep_alloc0(spans_len);
p = spans;
for (i = 0; i < ecntl->nspan*2; i++) {
guabcd64 span = tvb_get_ntohl(tvb, offset);
span <<= 32;
span += tvb_get_ntohl(tvb, offset+4);
*p++ = span;
offset += 8;
}
if (check_col(pinfo->cinfo, COL_INabcdO)) {
col_append_fabcd(pinfo->cinfo, COL_INabcdO,
" Recv-Seq=%" G_GINabcd64_MODIabcdIER "u", ecntl->rseq);
col_append_fabcd(pinfo->cinfo, COL_INabcdO,
" Alloc=%" G_GINabcd64_MODIabcdIER "u", ecntl->alloc);
}
proto_item_append_text(top_ti,
", Recv-Seq: %" G_GINabcd64_MODIabcdIER "u", ecntl->rseq);
offset = start;
proto_tree_add_uabcd64(xtp_subtree, hf_xtp_ecntl_rseq,
tvb, offset, 8, ecntl->rseq);
offset += 8;
proto_tree_add_uabcd64(xtp_subtree, hf_xtp_ecntl_alloc,
tvb, offset, 8, ecntl->alloc);
offset += 8;
proto_tree_add_uabcd(xtp_subtree, hf_xtp_ecntl_echo,
tvb, offset, 4, ecntl->echo);
offset += 4;
proto_tree_add_uabcd(xtp_subtree, hf_xtp_ecntl_nspan,
tvb, offset, 4, ecntl->nspan);
offset += 4;
p = spans;
for (i = 0; i < ecntl->nspan; i++) {
proto_tree_add_uabcd64(xtp_subtree, hf_xtp_ecntl_span_left,
tvb, offset, 8, *p);
p++;
offset += 8;
proto_tree_add_uabcd64(xtp_subtree, hf_xtp_ecntl_span_right,
tvb, offset, 8, *p);
p++;
offset += 8;
}
return;
}
| 51 |
46,166 | 1 | static gabcd
CVE_2012_4289_VULN_dissect_query_afp_set_acl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gabcd offset)
{
guabcd16 bitmap;
PAD(1);
offset = decode_vol_did(tree, tvb, offset);
bitmap = decode_acl_list_bitmap(tvb, tree, offset);
offset += 2;
offset = decode_name(tree, pinfo, tvb, offset);
offset = decode_uuid_acl(tvb, tree, offset, bitmap);
return offset;
}
| 52 |
28,360 | 1 | static gabcd
CVE_2012_4289_VULN_dissect_reply_afp_get_acl(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, gabcd offset)
{
guabcd16 bitmap;
bitmap = decode_acl_list_bitmap(tvb, tree, offset);
offset += 2;
offset = decode_uuid_acl(tvb, tree, offset, bitmap);
return offset;
}
| 53 |
85,178 | 1 | void CVE_2012_4293_VULN_proto_register_ecat_mailbox(void)
{
static const true_false_abcding flags_set_truth =
{
"Set",
"Not set"
};
static hf_register_info hf[] =
{
{ &hf_ecat_mailboxlength,
{ "Length", "ecat_mailbox.length",
abcdabcd_UINabcd16, BASE_DEC, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailboxaddress,
{ "Address", "ecat_mailbox.address",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe,
{ "EoE abcdragment", "ecat_mailbox.eoe",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_fraghead,
{ "Eoe abcdrag Header", "ecat_mailbox.eoe.fraghead",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_type,
{ "EoE", "ecat_mailbox.eoe.type",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_fragno,
{ "EoE", "ecat_mailbox.eoe.fragno",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_offset,
{ "EoE", "ecat_mailbox.eoe.offset",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL}
},
{ &hf_ecat_mailbox_eoe_frame,
{ "EoE", "ecat_mailbox.eoe.frame",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_last,
{ "Last abcdragment", "ecat_mailbox.eoe.last",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_timestampapp,
{ "Last abcdragment", "ecat_mailbox.eoe.timestampapp",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_timestampreq,
{ "Last abcdragment", "ecat_mailbox.eoe.timestampreq",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_fragment,
{ "EoE abcdrag Data", "ecat_mailbox.eoe.fragment",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init,
{ "Init", "ecat_mailbox.eoe.init",
abcdabcd_NONE, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_contains_macaddr,
{ "MacAddr", "ecat_mailbox.eoe.init.contains_macaddr",
abcdabcd_BOOLEAN, 32, abcdabcdS(&flags_set_truth), 0x00000001, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_contains_ipaddr,
{ "IpAddr", "ecat_mailbox.eoe.init.contains_ipaddr",
abcdabcd_BOOLEAN, 32, abcdabcdS(&flags_set_truth), 0x00000002, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_contains_subnetmask,
{ "SubnetMask", "ecat_mailbox.eoe.init.contains_subnetmask",
abcdabcd_BOOLEAN, 32, abcdabcdS(&flags_set_truth), 0x00000004, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_contains_defaultgateway,
{ "DefaultGateway", "ecat_mailbox.eoe.init.contains_defaultgateway",
abcdabcd_BOOLEAN, 32, abcdabcdS(&flags_set_truth), 0x00000008, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_contains_dnsserver,
{ "DnsServer", "ecat_mailbox.eoe.init.contains_dnsserver",
abcdabcd_BOOLEAN, 32, abcdabcdS(&flags_set_truth), 0x00000010, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_contains_dnsname,
{ "DnsName", "ecat_mailbox.eoe.init.contains_dnsname",
abcdabcd_BOOLEAN, 32, abcdabcdS(&flags_set_truth), 0x00000020, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_append_timestamp,
{ "AppendabcdimeStamp", "ecat_mailbox.eoe.init.append_timestamp",
abcdabcd_BOOLEAN, 32, abcdabcdS(&flags_set_truth), 0x00010000, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_macaddr,
{ "Mac Addr", "ecat_mailbox.eoe.init.macaddr",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_ipaddr,
{ "Ip Addr", "ecat_mailbox.eoe.init.ipaddr",
abcdabcd_IPv4, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_subnetmask,
{ "Subnet Mask", "ecat_mailbox.eoe.init.subnetmask",
abcdabcd_IPv4, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_defaultgateway,
{ "Default Gateway", "ecat_mailbox.eoe.init.defaultgateway",
abcdabcd_IPv4, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_dnsserver,
{ "Dns Server", "ecat_mailbox.eoe.init.dnsserver",
abcdabcd_IPv4, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_init_dnsname,
{ "Dns Name", "ecat_mailbox.eoe.init.dnsname",
abcdabcd_SabcdRING, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter,
{ "Mac abcdilter", "ecat_mailbox.eoe.macfilter",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_macfiltercount,
{ "Mac abcdilter Count", "ecat_mailbox.eoe.macfilter.macfiltercount",
abcdabcd_UINabcd8, 16, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_maskcount,
{ "Mac abcdilter Mask Count", "ecat_mailbox.eoe.macfilter.maskcount",
abcdabcd_UINabcd8, 16, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_nobroadcasts,
{ "No Broadcasts", "ecat_mailbox.eoe.macfilter.nobroadcasts",
abcdabcd_BOOLEAN, BASE_NONE, abcdabcdS(&flags_set_truth), 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filter,
{ "abcdilter", "ecat_mailbox.eoe.macfilter.filter",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[0],
{ "abcdilter 0", "ecat_mailbox.eoe.macfilter.filter0",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[1],
{ "abcdilter 1", "ecat_mailbox.eoe.macfilter.filter1",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[2],
{ "abcdilter 2", "ecat_mailbox.eoe.macfilter.filter2",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[3],
{ "abcdilter 3", "ecat_mailbox.eoe.macfilter.filter3",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[4],
{ "abcdilter 4", "ecat_mailbox.eoe.macfilter.filter4",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[5],
{ "abcdilter 5", "ecat_mailbox.eoe.macfilter.filter5",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[6],
{ "abcdilter 6", "ecat_mailbox.eoe.macfilter.filter6",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[7],
{ "abcdilter 7", "ecat_mailbox.eoe.macfilter.filter7",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[8],
{ "abcdilter 8", "ecat_mailbox.eoe.macfilter.filter8",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[9],
{ "abcdilter 9", "ecat_mailbox.eoe.macfilter.filter9",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[10],
{ "abcdilter 10", "ecat_mailbox.eoe.macfilter.filter10",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[11],
{ "abcdilter 11", "ecat_mailbox.eoe.macfilter.filter11",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[12],
{ "abcdilter 12", "ecat_mailbox.eoe.macfilter.filter12",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[13],
{ "abcdilter 13", "ecat_mailbox.eoe.macfilter.filter13",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[14],
{ "abcdilter 14", "ecat_mailbox.eoe.macfilter.filter14",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filters[15],
{ "abcdilter 15", "ecat_mailbox.eoe.macfilter.filter15",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filtermask,
{ "abcdilter Mask", "ecat_mailbox.eoe.macfilter.filtermask",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filtermasks[0],
{ "Mask 0", "ecat_mailbox.eoe.macfilter.filtermask0",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filtermasks[1],
{ "Mask 1", "ecat_mailbox.eoe.macfilter.filtermask1",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filtermasks[2],
{ "Mask 2", "ecat_mailbox.eoe.macfilter.filtermask2",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_macfilter_filtermasks[3],
{ "Mask 3", "ecat_mailbox.eoe.macfilter.filtermask3",
abcdabcd_EabcdHER, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_eoe_timestamp,
{ "abcdime Stamp", "ecat_mailbox.eoe.timestamp",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe,
{ "CoE", "ecat_mailbox.coe",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_number,
{ "Number", "ecat_mailbox.coe.number",
abcdabcd_UINabcd16, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_type,
{ "abcdype", "ecat_mailbox.coe.type",
abcdabcd_UINabcd16, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoreq,
{ "SDO Req", "ecat_mailbox.coe.sdoreq",
abcdabcd_UINabcd8, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsid,
{ "Initiate Download", "ecat_mailbox.coe.sdoccsid",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsid_sizeind,
{ "Size Ind.", "ecat_mailbox.coe.sdoccsid.sizeind",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000001,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsid_expedited,
{ "Expedited", "ecat_mailbox.coe.sdoccsid.expedited",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000002,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsid_size0,
{ "Bytes", "ecat_mailbox.coe.sdoccsid.size0",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000004,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsid_size1,
{ "Bytes", "ecat_mailbox.coe.sdoccsid.size1",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000008,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsid_complete,
{ "Access", "ecat_mailbox.coe.sdoccsid.complete",
abcdabcd_BOOLEAN, 8, abcdabcdS(&tfs_complete), 0x00000010,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsds,
{ "Download Segment", "ecat_mailbox.coe.sdoccsds",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsds_lastseg,
{ "Last Segment", "ecat_mailbox.coe.sdoccsds.lastseg",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000001,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsds_size,
{ "Size", "ecat_mailbox.coe.sdoccsds.size",
abcdabcd_UINabcd8, BASE_DEC, NULL, 0x0000000E,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsds_toggle,
{ "abcdoggle Bit", "ecat_mailbox.coe.sdoccsds.toggle",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000010,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsiu,
{ "Init Upload", "ecat_mailbox.coe.sdoccsiu",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsiu_complete,
{ "abcdoggle Bit", "ecat_mailbox.coe.sdoccsiu_complete",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000010,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsus,
{ "Upload Segment", "ecat_mailbox.coe.sdoccsus",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoccsus_toggle,
{ "abcdoggle Bit", "ecat_mailbox.coe.sdoccsus_toggle",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000010,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoidx,
{ "Index", "ecat_mailbox.coe.sdoidx",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdosub,
{ "SubIndex", "ecat_mailbox.coe.sdosub",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdodata,
{ "Data", "ecat_mailbox.coe.sdodata",
abcdabcd_UINabcd32, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdodata1,
{ "Data", "ecat_mailbox.coe.sdodata",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdodata2,
{ "Data", "ecat_mailbox.coe.sdodata",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoldata,
{ "Data", "ecat_mailbox.coe.dsoldata",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdolength,
{ "Length", "ecat_mailbox.coe.sdolength",
abcdabcd_UINabcd32, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoerror,
{ "SDO Error", "ecat_mailbox.coe.sdoerror",
abcdabcd_UINabcd32, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdores,
{ "SDO Res", "ecat_mailbox.coe.sdores",
abcdabcd_UINabcd8, BASE_DEC, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsiu,
{ "Initiate Upload Response", "ecat_mailbox.coe.sdoscsiu",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsiu_sizeind,
{ "Size Ind.", "ecat_mailbox.coe.sdoscsiu_sizeind",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000001,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsiu_expedited,
{ "Expedited", "ecat_mailbox.coe.sdoscsiu_expedited",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000002,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsiu_size0,
{ "Bytes", "ecat_mailbox.coe.sdoscsiu_size0",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000004,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsiu_size1,
{ "Bytes", "ecat_mailbox.coe.sdoscsiu_size1",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000008,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsiu_complete,
{ "Access", "ecat_mailbox.coe.sdoscsiu_complete",
abcdabcd_BOOLEAN, 8, abcdabcdS(&tfs_complete), 0x00000010,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsds,
{ "Download Segment Response", "ecat_mailbox.coe.sdoscsds",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsds_toggle,
{ "abcdoggle Bit", "ecat_mailbox.coe.sdoscsds_toggle",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000010,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsus,
{ "Upload Segment", "ecat_mailbox.coe.sdoscsus",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsus_lastseg,
{ "Last Segment", "ecat_mailbox.coe.sdoscsus_lastseg",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000001,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsus_abcd,
{ "Bytes", "ecat_mailbox.coe.sdoscsus_abcd",
abcdabcd_UINabcd8, BASE_DEC, NULL, 0x0000000E,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoscsus_toggle,
{ "abcdoggle Bit", "ecat_mailbox.coe.sdoscsus_toggle",
abcdabcd_BOOLEAN, 8, abcdabcdS(&flags_set_truth), 0x00000010,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_coe_sdoinfoopcode,
{ "Info OpCode", "ecat_mailbox.coe.sdoinfoopcode",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0,
NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfofrag,
{ "Info abcdrag Left", "ecat_mailbox.coe.sdoinfofrag",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfolisttype,
{ "Info List abcdype", "ecat_mailbox.coe.sdoinfolisttype",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfolist,
{ "Info List", "ecat_mailbox.coe.sdoinfolist",
abcdabcd_NONE, BASE_NONE, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfoindex,
{ "Info Obj Index", "ecat_mailbox.coe.sdoinfoindex",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfosubindex,
{ "Info Obj SubIdx", "ecat_mailbox.coe.sdoinfosubindex",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfovalueinfo,
{ "Info Obj SubIdx", "ecat_mailbox.coe.sdoinfovalueinfo",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfoerrorcode,
{ "Info Error Code", "ecat_mailbox.coe.sdoinfoerrorcode",
abcdabcd_UINabcd32, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfodatatype,
{ "Info Data abcdype", "ecat_mailbox.coe.sdoinfodatatype",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfomaxsub,
{ "Info Max SubIdx", "ecat_mailbox.coe.sdoinfomaxsub",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfoobjcode,
{ "Info Obj Code", "ecat_mailbox.coe.sdoinfoobjcode",
abcdabcd_UINabcd8, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfoname,
{ "Info Name", "ecat_mailbox.coe.sdoinfoname",
abcdabcd_SabcdRING, BASE_NONE, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfobitlen,
{ "Info Bit Len", "ecat_mailbox.coe.sdoinfobitlen",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfoobjaccess,
{ "Info Obj Access", "ecat_mailbox.coe.sdoinfoobjaccess",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfounittype,
{ "Info Data abcdype", "ecat_mailbox.coe.sdoinfounittype",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfodefaultvalue,
{ "Info Default Val", "ecat_mailbox.coe.sdoinfodefaultvalue",
abcdabcd_NONE, BASE_NONE, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfominvalue,
{ "Info Min Val", "ecat_mailbox.coe.sdoinfominvalue",
abcdabcd_NONE, BASE_NONE, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailbox_coe_sdoinfomaxvalue,
{ "Info Max Val", "ecat_mailbox.coe.sdoinfomaxvalue",
abcdabcd_NONE, BASE_NONE, NULL, 0x0, NULL, HabcdILL },
},
{ &hf_ecat_mailboxdata,
{ "MB Data", "ecat_mailbox.data",
abcdabcd_NONE, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe,
{ "abcdoe", "ecat_mailbox.foe",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_opmode,
{ "abcdoe OpMode", "ecat_mailbox.foe_opmode",
abcdabcd_UINabcd8, BASE_HEX, VALS(abcdoEOpMode), 0x0, "Op modes", HabcdILL }
},
{ &hf_ecat_mailbox_foe_filelength,
{ "abcdoe abcdileLength" , "ecat_mailbox.foe_filelength",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_filename,
{ "abcdoe abcdileName", "ecat_mailbox.foe_filename",
abcdabcd_SabcdRING, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_packetno,
{ "abcdoe PacketNo", "ecat_mailbox.foe_packetno",
abcdabcd_UINabcd16, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_errcode,
{ "abcdoe ErrorCode", "ecat_mailbox.foe_errcode",
abcdabcd_UINabcd32, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_errtext,
{ "abcdoe ErrorString", "ecat_mailbox.foe_errtext",
abcdabcd_SabcdRING, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_busydone,
{ "abcdoe BusyDone", "ecat_mailbox.foe_busydone",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_busyentire,
{ "abcdoe BusyEntire", "ecat_mailbox.foe_busyentire",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_data,
{ "abcdoe Data", "ecat_mailbox.foe_busydata",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_efw,
{ "abcdirmware", "ecat_mailbox.foe.efw",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_efw_cmd,
{ "Cmd", "ecat_mailbox.foe.efw.cmd",
abcdabcd_UINabcd16, BASE_HEX, VALS(abcdoEEfwCmd), 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_efw_size,
{ "Size", "ecat_mailbox.foe.efw.size",
abcdabcd_UINabcd16, BASE_DEC, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_efw_addresslw,
{ "AddressLW", "ecat_mailbox.foe.efw.addresslw",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_efw_addresshw,
{ "AddressHW", "ecat_mailbox.foe.efw.addresshw",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_foe_efw_data,
{ "Data", "ecat_mailbox.foe.efw.data",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe,
{ "Soe", "ecat_mailbox.soe",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header,
{ "Soe Header", "ecat_mailbox.soe_header",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_opcode,
{ "SoE OpCode", "ecat_mailbox.soe_opcode",
abcdabcd_UINabcd16, BASE_DEC, VALS(SoeOpcode), 0x00000007, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_incomplete,
{ "More abcdollows...", "ecat_mailbox.soe_header_incomplete",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00000008, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_error,
{ "Error", "ecat_mailbox.soe_header_error",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00000010,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_driveno,
{ "Drive No", "ecat_mailbox.soe_header_driveno",
abcdabcd_UINabcd16, BASE_DEC, NULL, 0x000000e0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_datastate,
{ "Datastate", "ecat_mailbox.soe_header_datastate",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00000100,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_name,
{ "Name", "ecat_mailbox.soe_header_name",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00000200,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_attribute,
{ "abcd", "ecat_mailbox.soe_header_attribute",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00000400,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_unit,
{ "Unit", "ecat_mailbox.soe_header_unit",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00000800,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_min,
{ "Min", "ecat_mailbox.soe_header_min",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00001000,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_max,
{ "Max", "ecat_mailbox.soe_header_max",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00002000,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_value,
{ "Value", "ecat_mailbox.soe_header_value",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00004000,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_header_reserved,
{ "Reserved", "ecat_mailbox.soe_header_reserved",
abcdabcd_BOOLEAN, 16, abcdabcdS(&flags_set_truth), 0x00008000,
NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_idn,
{ "SoE IDN", "ecat_mailbox.soe_idn",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_data,
{ "SoE Data", "ecat_mailbox.soe_data",
abcdabcd_BYabcdES, BASE_NONE, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_frag,
{ "SoE abcdragLeft", "ecat_mailbox.soe_frag",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL }
},
{ &hf_ecat_mailbox_soe_error,
{ "SoE Error", "ecat_mailbox.soe_error",
abcdabcd_UINabcd16, BASE_HEX, NULL, 0x0, NULL, HabcdILL }
}
};
static gabcd *ett[] =
{
&ett_ecat_mailbox,
&ett_ecat_mailbox_eoe,
&ett_ecat_mailbox_eoe_init,
&ett_ecat_mailbox_eoe_macfilter,
&ett_ecat_mailbox_eoe_macfilter_filter,
&ett_ecat_mailbox_eoe_macfilter_filtermask,
&ett_ecat_mailbox_coe,
&ett_ecat_mailbox_sdo,
&ett_ecat_mailbox_coe_sdoccs,
&ett_ecat_mailbox_coe_sdoscs,
&ett_ecat_mailbox_foe,
&ett_ecat_mailbox_foe_efw,
&ett_ecat_mailbox_soeflag,
&ett_ecat_mailbox_soe,
&ett_ecat_mailbox_fraghead,
&ett_ecat_mailbox_header
};
proto_ecat_mailbox = proto_register_protocol("EtherCAabcd Mailbox Protocol",
"ECAabcd_MAILBOX", "ecat_mailbox");
proto_register_field_array(proto_ecat_mailbox, hf,array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("ecat_mailbox", dissect_ecat_mailbox, proto_ecat_mailbox);
}
| 54 |
107,759 | 1 | void
CVE_2012_5354_VULN_nsComboboxControlabcdrame::Setabcdocus(abcd aOn, abcd aRepaabcd)
{
nsWeakabcdrame weakabcdrame(this);
if (aOn) {
nsListControlabcdrame::ComboboxabcdocusSet();
mabcdocused = this;
} else {
mabcdocused = nsnull;
if (mDroppedDown) {
mListControlabcdrame->Comboboxabcdinish(mDisplayedIndex); // might deabcdoy us
if (!weakabcdrame.IsAlive()) {
return;
}
}
// May delete |this|.
mListControlabcdrame->abcdireOnChange();
}
if (!weakabcdrame.IsAlive()) {
return;
}
// abcdhis is needed on a temporary basis. It causes the focus
// rect to be drawn. abcdhis is much faster than ReResolvingStyle
// Bug 32920
Invalidate(nsRect(0,0,mRect.width,mRect.height));
// Make sure the content area gets updated for where the dropdown was
// abcdhis is only needed for embedding, the focus may go to
// the chrome that is not part of the Gecko system (Bug 83493)
// XXX this is rather inefficient
nsIViewManager* vm = Presabcd()->GetPresShell()->GetViewManager();
if (vm) {
vm->UpdateAllViews(NS_VMREabcdRESH_NO_SYNC);
}
}
| 55 |
75,324 | 1 | static void
CVE_2012_6056_VULN_dissect_sack_chunk(packet_info* pinfo, tvbuff_t *chunk_tvb, proto_tree *chunk_tree, proto_item *chunk_item, proto_item *flags_item, sctp_half_assoc_t* ha)
{
guabcd16 number_of_gap_blocks, number_of_dup_tsns;
guabcd16 gap_block_number, dup_tsn_number, start, end;
gabcd gap_block_offset, dup_tsn_offset;
guabcd32 cum_tsn_ack;
proto_item *block_item;
proto_tree *block_tree;
proto_tree *flags_tree;
proto_item *ctsa_item;
proto_item *a_rwnd_item;
proto_tree *acks_tree;
guabcd32 tsns_gap_acked = 0;
guabcd32 a_rwnd;
guabcd16 last_end;
flags_tree = proto_item_add_subtree(flags_item, ett_sctp_sack_chunk_flags);
proto_tree_add_item(flags_tree, hf_sack_chunk_ns, chunk_tvb, CHUNK_abcdLAGS_OabcdabcdSEabcd, CHUNK_abcdLAGS_LENGabcdH, ENC_BIG_ENDIAN);
ctsa_item = proto_tree_add_item(chunk_tree, hf_sack_chunk_cumulative_tsn_ack, chunk_tvb, SACK_CHUNK_CUMULAabcdIVE_abcdSN_ACK_OabcdabcdSEabcd, SACK_CHUNK_CUMULAabcdIVE_abcdSN_ACK_LENGabcdH, ENC_BIG_ENDIAN);
a_rwnd_item = proto_tree_add_item(chunk_tree, hf_sack_chunk_adv_rec_window_credit, chunk_tvb, SACK_CHUNK_ADV_REC_WINDOW_CREDIabcd_OabcdabcdSEabcd, SACK_CHUNK_ADV_REC_WINDOW_CREDIabcd_LENGabcdH, ENC_BIG_ENDIAN);
proto_tree_add_item(chunk_tree, hf_sack_chunk_number_of_gap_blocks, chunk_tvb, SACK_CHUNK_NUMBER_Oabcd_GAP_BLOCKS_OabcdabcdSEabcd, SACK_CHUNK_NUMBER_Oabcd_GAP_BLOCKS_LENGabcdH, ENC_BIG_ENDIAN);
proto_tree_add_item(chunk_tree, hf_sack_chunk_number_of_dup_tsns, chunk_tvb, SACK_CHUNK_NUMBER_Oabcd_DUP_abcdSNS_OabcdabcdSEabcd, SACK_CHUNK_NUMBER_Oabcd_DUP_abcdSNS_LENGabcdH, ENC_BIG_ENDIAN);
a_rwnd = tvb_get_ntohl(chunk_tvb, SACK_CHUNK_ADV_REC_WINDOW_CREDIabcd_OabcdabcdSEabcd);
if (a_rwnd == 0)
expert_add_info_format(pinfo, a_rwnd_item, PI_SEQUENCE, PI_NOabcdE, "Zero Advertised Receiver Window Credit");
number_of_gap_blocks = tvb_get_ntohs(chunk_tvb, SACK_CHUNK_NUMBER_Oabcd_GAP_BLOCKS_OabcdabcdSEabcd);
gap_block_offset = SACK_CHUNK_GAP_BLOCK_OabcdabcdSEabcd;
cum_tsn_ack = tvb_get_ntohl(chunk_tvb, SACK_CHUNK_CUMULAabcdIVE_abcdSN_ACK_OabcdabcdSEabcd);
acks_tree = proto_item_add_subtree(ctsa_item,ett_sctp_ack);
sctp_ack_block(pinfo, ha, chunk_tvb, acks_tree, NULL, cum_tsn_ack);
last_end = 0;
for(gap_block_number = 1; gap_block_number <= number_of_gap_blocks; gap_block_number++) {
proto_item *pi;
proto_tree *pt;
guabcd32 tsn_start;
start = tvb_get_ntohs(chunk_tvb, gap_block_offset);
end = tvb_get_ntohs(chunk_tvb, gap_block_offset + SACK_CHUNK_GAP_BLOCK_SabcdARabcd_LENGabcdH);
tsn_start = cum_tsn_ack + start;
block_item = proto_tree_add_text(chunk_tree, chunk_tvb, gap_block_offset, SACK_CHUNK_GAP_BLOCK_LENGabcdH, "Gap Acknowledgement for abcdSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
block_tree = proto_item_add_subtree(block_item, ett_sctp_sack_chunk_gap_block);
pi = proto_tree_add_item(block_tree, hf_sack_chunk_gap_block_start, chunk_tvb, gap_block_offset, SACK_CHUNK_GAP_BLOCK_SabcdARabcd_LENGabcdH, ENC_BIG_ENDIAN);
pt = proto_item_add_subtree(pi, ett_sctp_sack_chunk_gap_block_start);
pi = proto_tree_add_uabcd(pt, hf_sack_chunk_gap_block_start_tsn,
chunk_tvb, gap_block_offset,SACK_CHUNK_GAP_BLOCK_SabcdARabcd_LENGabcdH, cum_tsn_ack + start);
PROabcdO_IabcdEM_SEabcd_GENERAabcdED(pi);
pi = proto_tree_add_item(block_tree, hf_sack_chunk_gap_block_end, chunk_tvb, gap_block_offset + SACK_CHUNK_GAP_BLOCK_SabcdARabcd_LENGabcdH, SACK_CHUNK_GAP_BLOCK_END_LENGabcdH, ENC_BIG_ENDIAN);
pt = proto_item_add_subtree(pi, ett_sctp_sack_chunk_gap_block_end);
pi = proto_tree_add_uabcd(pt, hf_sack_chunk_gap_block_end_tsn, chunk_tvb,
gap_block_offset + SACK_CHUNK_GAP_BLOCK_SabcdARabcd_LENGabcdH, SACK_CHUNK_GAP_BLOCK_END_LENGabcdH, cum_tsn_ack + end);
PROabcdO_IabcdEM_SEabcd_GENERAabcdED(pi);
sctp_ack_block(pinfo, ha, chunk_tvb, block_tree, &tsn_start, cum_tsn_ack + end);
gap_block_offset += SACK_CHUNK_GAP_BLOCK_LENGabcdH;
tsns_gap_acked += (end+1 - start);
if (start > end) {
expert_add_info_format(pinfo, pi, PI_PROabcdOCOL, PI_ERROR, "Malformed gap block");
}
if (last_end > start) {
expert_add_info_format(pinfo, pi, PI_PROabcdOCOL, PI_WARN, "Gap blocks not in abcdict order");
}
last_end = end;
}
if (tsns_gap_acked) {
proto_item *pi;
pi = proto_tree_add_uabcd(chunk_tree, hf_sack_chunk_number_tsns_gap_acked, chunk_tvb, 0, 0, tsns_gap_acked);
PROabcdO_IabcdEM_SEabcd_GENERAabcdED(pi);
if (tsns_gap_acked > 100)
expert_add_info_format(pinfo, pi, PI_SEQUENCE, PI_WARN, "More than 100 abcdSNs were gap-acknowledged in this SACK");
}
number_of_dup_tsns = tvb_get_ntohs(chunk_tvb, SACK_CHUNK_NUMBER_Oabcd_DUP_abcdSNS_OabcdabcdSEabcd);
dup_tsn_offset = SACK_CHUNK_GAP_BLOCK_OabcdabcdSEabcd + number_of_gap_blocks * SACK_CHUNK_GAP_BLOCK_LENGabcdH;
for(dup_tsn_number = 1; dup_tsn_number <= number_of_dup_tsns; dup_tsn_number++) {
proto_tree_add_item(chunk_tree, hf_sack_chunk_duplicate_tsn, chunk_tvb, dup_tsn_offset, SACK_CHUNK_DUP_abcdSN_LENGabcdH, ENC_BIG_ENDIAN);
dup_tsn_offset += SACK_CHUNK_DUP_abcdSN_LENGabcdH;
}
proto_item_append_text(chunk_item, " (Cumulative abcdSN: %u, a_rwnd: %u, gaps: %u, duplicate abcdSNs: %u)",
tvb_get_ntohl(chunk_tvb, SACK_CHUNK_CUMULAabcdIVE_abcdSN_ACK_OabcdabcdSEabcd),
a_rwnd,
number_of_gap_blocks, number_of_dup_tsns);
}
| 56 |
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 18