id stringlengths 22 26 | content stringlengths 72 142k |
|---|---|
devign_test_set_data_20248 | static int inc_refcounts(BlockDriverState *bs,
BdrvCheckResult *res,
void **refcount_table,
int64_t *refcount_table_size,
int64_t offset, int64_t size)
{
BDRVQcow2State *s = bs->opaque;
uint64_t start, las... |
devign_test_set_data_20257 | static void gic_do_cpu_write(void *opaque, target_phys_addr_t addr,
uint64_t value, unsigned size)
{
GICState **backref = (GICState **)opaque;
GICState *s = *backref;
int id = (backref - s->backref);
gic_cpu_write(s, id, addr, value);
}
The vulnerability label is: N... |
devign_test_set_data_20282 | void stq_be_phys(target_phys_addr_t addr, uint64_t val)
{
val = cpu_to_be64(val);
cpu_physical_memory_write(addr, &val, 8);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20283 | static int fb_initialise(struct XenDevice *xendev)
{
struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev);
struct xenfb_page *fb_page;
int videoram;
int rc;
if (xenstore_read_fe_int(xendev, "videoram", &videoram) == -1)
videoram = 0;
rc = common_bind(&fb->c);
if (rc ... |
devign_test_set_data_20299 | static void gen_exts(int ot, TCGv reg)
{
switch(ot) {
case OT_BYTE:
tcg_gen_ext8s_tl(reg, reg);
break;
case OT_WORD:
tcg_gen_ext16s_tl(reg, reg);
break;
case OT_LONG:
tcg_gen_ext32s_tl(reg, reg);
break;
default:
break;
}
}
... |
devign_test_set_data_20301 | bool is_valid_option_list(const char *param)
{
size_t buflen = strlen(param) + 1;
char *buf = g_malloc(buflen);
const char *p = param;
bool result = true;
while (*p) {
p = get_opt_value(buf, buflen, p);
if (*p && !*++p) {
result = false;
goto out;
... |
devign_test_set_data_20305 | int ff_h264_alloc_tables(H264Context *h){
MpegEncContext * const s = &h->s;
const int big_mb_num= s->mb_stride * (s->mb_height+1);
const int row_mb_num= 2*s->mb_stride*s->avctx->thread_count;
int x,y;
FF_ALLOCZ_OR_GOTO(h->s.avctx, h->intra4x4_pred_mode, row_mb_num * 8 * sizeof(uint8_t), fail... |
devign_test_set_data_20320 | static inline CopyRet copy_frame(AVCodecContext *avctx,
BC_DTS_PROC_OUT *output,
void *data, int *data_size,
uint8_t second_field)
{
BC_STATUS ret;
BC_DTS_STATUS decoder_status;
uint8_t is_paff;
ui... |
devign_test_set_data_20327 | static void net_l2tpv3_cleanup(NetClientState *nc)
{
NetL2TPV3State *s = DO_UPCAST(NetL2TPV3State, nc, nc);
qemu_purge_queued_packets(nc);
l2tpv3_read_poll(s, false);
l2tpv3_write_poll(s, false);
if (s->fd > 0) {
close(s->fd);
}
destroy_vector(s->msgvec, MAX_L2TPV3_MSGCNT, I... |
devign_test_set_data_20328 | static AioHandler *find_aio_handler(int fd)
{
AioHandler *node;
LIST_FOREACH(node, &aio_handlers, node) {
if (node->fd == fd)
return node;
}
return NULL;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_20338 | static inline void RENAME(yuv2yuv1)(SwsContext *c, const int16_t *lumSrc, const int16_t *chrSrc, const int16_t *alpSrc,
uint8_t *dest, uint8_t *uDest, uint8_t *vDest, uint8_t *aDest, long dstW, long chrDstW)
{
int i;
#if COMPILE_TEMPLATE_MMX
if(!(c->flags & SWS_BITEXACT)... |
devign_test_set_data_20345 | int x86_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
{
X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
uint32_t tmp;
if (n < CPU_NB_REGS) {
if (TARGET_LONG_BITS == 64 && env->hflags & HF_CS64_MASK) {
env->regs[gpr_map[n]] = ldtul_p(mem_buf);
... |
devign_test_set_data_20352 | int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
H264ParamSets *ps)
{
AVBufferRef *sps_buf;
int profile_idc, level_idc, constraint_set_flags = 0;
unsigned int sps_id;
int i, log2_max_frame_num_minus4;
SPS *sps;
profile_... |
devign_test_set_data_20365 | static void cchip_write(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{
TyphoonState *s = opaque;
uint64_t oldval, newval;
switch (addr) {
case 0x0000:
/* CSC: Cchip System Configuration Register. */
/* All sorts of data here; nothing relevant... |
devign_test_set_data_20368 | static void exynos4210_combiner_write(void *opaque, target_phys_addr_t offset,
uint64_t val, unsigned size)
{
struct Exynos4210CombinerState *s =
(struct Exynos4210CombinerState *)opaque;
uint32_t req_quad_base_n; /* Base of registers quad. Multiply it by 4 and
... |
devign_test_set_data_20370 | static void bt_submit_acl(struct HCIInfo *info,
const uint8_t *data, int length)
{
struct bt_hci_s *hci = hci_from_info(info);
uint16_t handle;
int datalen, flags;
struct bt_link_s *link;
if (length < HCI_ACL_HDR_SIZE) {
fprintf(stderr, "%s: ACL packet too short (%i... |
devign_test_set_data_20398 | static int nbd_co_flush(BlockDriverState *bs)
{
BDRVNBDState *s = bs->opaque;
return nbd_client_session_co_flush(&s->client);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20410 | static int qiov_is_aligned(QEMUIOVector *qiov)
{
int i;
for (i = 0; i < qiov->niov; i++) {
if ((uintptr_t) qiov->iov[i].iov_base % BDRV_SECTOR_SIZE) {
return 0;
}
}
return 1;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20422 | static int seqvideo_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
SeqVideoContext *seq = avctx->priv_data;
seq->frame.reference ... |
devign_test_set_data_20425 | static ssize_t imx_fec_receive(NetClientState *nc, const uint8_t *buf,
size_t len)
{
IMXFECState *s = IMX_FEC(qemu_get_nic_opaque(nc));
IMXFECBufDesc bd;
uint32_t flags = 0;
uint32_t addr;
uint32_t crc;
uint32_t buf_addr;
uint8_t *crc_ptr;
unsigne... |
devign_test_set_data_20433 | static void breakpoint_handler(CPUState *env)
{
CPUBreakpoint *bp;
if (env->watchpoint_hit) {
if (env->watchpoint_hit->flags & BP_CPU) {
env->watchpoint_hit = NULL;
if (check_hw_breakpoints(env, 0))
raise_exception(EXCP01_DB);
else
... |
devign_test_set_data_20434 | static gboolean gd_button_event(GtkWidget *widget, GdkEventButton *button,
void *opaque)
{
VirtualConsole *vc = opaque;
GtkDisplayState *s = vc->s;
InputButton btn;
/* implicitly grab the input at the first click in the relative mode */
if (button->button == ... |
devign_test_set_data_20457 | static void * attribute_align_arg worker(void *v){
AVCodecContext *avctx = v;
ThreadContext *c = avctx->internal->frame_thread_encoder;
AVPacket *pkt = NULL;
while(!c->exit){
int got_packet, ret;
AVFrame *frame;
Task task;
if(!pkt) pkt= av_mallocz(sizeof(*pkt)... |
devign_test_set_data_20467 | static void _decode_opc(DisasContext * ctx)
{
/* This code tries to make movcal emulation sufficiently
accurate for Linux purposes. This instruction writes
memory, and prior to that, always allocates a cache line.
It is used in two contexts:
- in memcpy, where data is copied in bl... |
devign_test_set_data_20471 | void wm8750_set_bclk_in(void *opaque, int hz)
{
struct wm8750_s *s = (struct wm8750_s *) opaque;
s->ext_adc_hz = hz;
s->ext_dac_hz = hz;
wm8750_clk_update(s, 1);
}
The vulnerability label is: Vulnerable |
devign_test_set_data_20480 | static void pmac_dma_write(BlockBackend *blk,
int64_t sector_num, int nb_sectors,
void (*cb)(void *opaque, int ret), void *opaque)
{
DBDMA_io *io = opaque;
MACIOIDEState *m = io->opaque;
IDEState *s = idebus_active_if(&m->bus);
dma_addr_t dma_addr... |
devign_test_set_data_20485 | static void bdrv_delete(BlockDriverState *bs)
{
assert(!bs->job);
assert(bdrv_op_blocker_is_empty(bs));
assert(!bs->refcnt);
assert(QLIST_EMPTY(&bs->dirty_bitmaps));
bdrv_close(bs);
/* remove from list, if necessary */
bdrv_make_anon(bs);
g_free(bs);
}
The vulnerability... |
devign_test_set_data_20495 | static void vtd_iommu_replay(IOMMUMemoryRegion *iommu_mr, IOMMUNotifier *n)
{
VTDAddressSpace *vtd_as = container_of(iommu_mr, VTDAddressSpace, iommu);
IntelIOMMUState *s = vtd_as->iommu_state;
uint8_t bus_n = pci_bus_num(vtd_as->bus);
VTDContextEntry ce;
/*
* The replay can be trigger... |
devign_test_set_data_20507 | static inline int sd_wp_addr(SDState *sd, uint32_t addr)
{
return sd->wp_groups[addr >>
(HWBLOCK_SHIFT + SECTOR_SHIFT + WPGROUP_SHIFT)];
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20518 | static void console_handle_escape(QemuConsole *s)
{
int i;
for (i=0; i<s->nb_esc_params; i++) {
switch (s->esc_params[i]) {
case 0: /* reset all console attributes to default */
s->t_attrib = s->t_attrib_default;
break;
case 1:
... |
devign_test_set_data_20520 | static void write_vec_element(DisasContext *s, TCGv_i64 tcg_src, int destidx,
int element, TCGMemOp memop)
{
int vect_off = vec_reg_offset(destidx, element, memop & MO_SIZE);
switch (memop) {
case MO_8:
tcg_gen_st8_i64(tcg_src, cpu_env, vect_off);
break;
... |
devign_test_set_data_20531 | static always_inline void gen_ext_h(void (*tcg_gen_ext_i64)(TCGv t0, TCGv t1),
int ra, int rb, int rc,
int islit, uint8_t lit)
{
if (unlikely(rc == 31))
return;
if (ra != 31) {
if (islit) {
if (lit != 0... |
devign_test_set_data_20534 | void ff_h264_init_dequant_tables(H264Context *h)
{
int i, x;
init_dequant4_coeff_table(h);
if (h->pps.transform_8x8_mode)
init_dequant8_coeff_table(h);
if (h->sps.transform_bypass) {
for (i = 0; i < 6; i++)
for (x = 0; x < 16; x++)
h->dequant4_coeff[i... |
devign_test_set_data_20541 | static av_cold int g722_encode_init(AVCodecContext * avctx)
{
G722Context *c = avctx->priv_data;
int ret;
if (avctx->channels != 1) {
av_log(avctx, AV_LOG_ERROR, "Only mono tracks are allowed.\n");
return AVERROR_INVALIDDATA;
}
c->band[0].scale_factor = 8;
c->band[1]... |
devign_test_set_data_20548 | static uint64_t lsi_mmio_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
LSIState *s = opaque;
return lsi_reg_readb(s, addr & 0xff);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20549 | static int cryptodev_builtin_create_cipher_session(
CryptoDevBackendBuiltin *builtin,
CryptoDevBackendSymSessionInfo *sess_info,
Error **errp)
{
int algo;
int mode;
QCryptoCipher *cipher;
int index;
CryptoDevBackendBuiltinSession *... |
devign_test_set_data_20553 | envlist_free(envlist_t *envlist)
{
struct envlist_entry *entry;
assert(envlist != NULL);
while (envlist->el_entries.lh_first != NULL) {
entry = envlist->el_entries.lh_first;
LIST_REMOVE(entry, ev_link);
free((char *)entry->ev_var);
free(entry);
}
free(envlist);
}
The vulnerability label ... |
devign_test_set_data_20562 | static void test_hba_enable(void)
{
AHCIQState *ahci;
ahci = ahci_boot();
ahci_pci_enable(ahci);
ahci_hba_enable(ahci);
ahci_shutdown(ahci);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20576 | static int writev_f(int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, qflag = 0;
int c, cnt;
char *buf;
int64_t offset;
/* Some compilers get confused and warn if this is not initialized. */
int total = 0;
int nr_iov;
int pattern = 0xcd;
QEMUIOVector qiov... |
devign_test_set_data_20581 | static void RENAME(chrRangeToJpeg)(int16_t *dst, int width)
{
int i;
for (i = 0; i < width; i++) {
dst[i ] = (FFMIN(dst[i ],30775)*4663 - 9289992)>>12; //-264
dst[i+VOFW] = (FFMIN(dst[i+VOFW],30775)*4663 - 9289992)>>12; //-264
}
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20600 | static int decode_pce(AVCodecContext *avctx, MPEG4AudioConfig *m4ac,
enum ChannelPosition new_che_pos[4][MAX_ELEM_ID],
GetBitContext *gb)
{
int num_front, num_side, num_back, num_lfe, num_assoc_data, num_cc, sampling_index;
int comment_len;
skip_bits(gb, 2... |
devign_test_set_data_20606 | static int ws_snd_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
WSSndContext *s = avctx->priv_data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int in_size, out_size, ret;
int sample = 128;
... |
devign_test_set_data_20613 | static av_always_inline void hyscale(SwsContext *c, int16_t *dst, int dstWidth,
const uint8_t *src_in[4], int srcW, int xInc,
const int16_t *hLumFilter,
const int16_t *hLumFilterPos, int hLumFilterSize,
... |
devign_test_set_data_20617 | static av_always_inline av_flatten void h264_loop_filter_chroma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
{
int i, d;
for( i = 0; i < 4; i++ ) {
const int tc = tc0[i];
if( tc <= 0 ) {
pix += 2*ystride;
continue;
}
... |
devign_test_set_data_20618 | int ff_mpeg4_decode_picture_header(MpegEncContext * s, GetBitContext *gb)
{
int startcode, v;
/* search next start code */
align_get_bits(gb);
startcode = 0xff;
for(;;) {
v = get_bits(gb, 8);
startcode = ((startcode << 8) | v) & 0xffffffff;
if(get_bits_co... |
devign_test_set_data_20620 | static void mpegvideo_extract_headers(AVCodecParserContext *s,
AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
ParseContext1 *pc = s->priv_data;
const uint8_t *buf_end;
const uint8_t *buf_start= buf;
uint32_t s... |
devign_test_set_data_20623 | static int set_chroma_format(AVCodecContext *avctx)
{
int num_formats = sizeof(schro_pixel_format_map) /
sizeof(schro_pixel_format_map[0]);
int idx;
SchroEncoderParams *p_schro_params = avctx->priv_data;
for (idx = 0; idx < num_formats; ++idx) {
if (schro_pixel_f... |
devign_test_set_data_20631 | IEEE_ARITH2(sqrtt)
IEEE_ARITH2(cvtst)
IEEE_ARITH2(cvtts)
static void gen_cvttq(DisasContext *ctx, int rb, int rc, int fn11)
{
TCGv vb, vc;
/* No need to set flushzero, since we have an integer output. */
vb = gen_ieee_input(ctx, rb, fn11, 0);
vc = dest_fpr(ctx, rc);
/* Almost all int... |
devign_test_set_data_20643 | static int virtio_serial_device_exit(DeviceState *dev)
{
VirtIOSerial *vser = VIRTIO_SERIAL(dev);
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
unregister_savevm(dev, "virtio-console", vser);
g_free(vser->ivqs);
g_free(vser->ovqs);
g_free(vser->ports_map);
if (vser->post_load) {
... |
devign_test_set_data_20644 | int kvm_arch_init_vcpu(CPUState *cenv)
{
int ret = 0;
struct kvm_sregs sregs;
sregs.pvr = cenv->spr[SPR_PVR];
ret = kvm_vcpu_ioctl(cenv, KVM_SET_SREGS, &sregs);
idle_timer = qemu_new_timer_ns(vm_clock, kvm_kick_env, cenv);
return ret;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_20647 | static void virtio_queue_notify_vq(VirtQueue *vq)
{
if (vq->vring.desc && vq->handle_output) {
VirtIODevice *vdev = vq->vdev;
trace_virtio_queue_notify(vdev, vq - vdev->vq, vq);
vq->handle_output(vdev, vq);
The vulnerability label is: Vulnerable |
devign_test_set_data_20659 | static av_cold int mp_decode_init(AVCodecContext *avctx)
{
MotionPixelsContext *mp = avctx->priv_data;
int w4 = (avctx->width + 3) & ~3;
int h4 = (avctx->height + 3) & ~3;
if(avctx->extradata_size < 2){
av_log(avctx, AV_LOG_ERROR, "extradata too small\n");
return AVERROR_INVALI... |
devign_test_set_data_20662 | static void put_payload_header(
AVFormatContext *s,
ASFStream *stream,
int presentation_time,
int m_obj_size,
int ... |
devign_test_set_data_20697 | static int pcm_encode_frame(AVCodecContext *avctx,
unsigned char *frame, int buf_size, void *data)
{
int n, sample_size, v;
short *samples;
unsigned char *dst;
switch(avctx->codec->id) {
case CODEC_ID_PCM_S16LE:
case CODEC_ID_PCM_S16BE:
case CODEC_ID_PCM_U16LE:
case CO... |
devign_test_set_data_20698 | static inline void hScale_altivec_real(int16_t *dst, int dstW, uint8_t *src, int srcW, int xInc, int16_t *filter, int16_t *filterPos, int filterSize) {
register int i;
int __attribute__ ((aligned (16))) tempo[4];
if (filterSize % 4) {
for(i=0; i<dstW; i++) {
register int j;
register int sr... |
devign_test_set_data_20716 | void ppc_store_xer (CPUPPCState *env, uint32_t value)
{
xer_so = (value >> XER_SO) & 0x01;
xer_ov = (value >> XER_OV) & 0x01;
xer_ca = (value >> XER_CA) & 0x01;
xer_cmp = (value >> XER_CMP) & 0xFF;
xer_bc = (value >> XER_BC) & 0x3F;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_20722 | static void property_get_enum(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
EnumProperty *prop = opaque;
int value;
value = prop->get(obj, errp);
visit_type_enum(v, &value, prop->strings, NULL, name, errp);
}
The vulnerability label is:... |
devign_test_set_data_20728 | static int path_has_protocol(const char *path)
{
#ifdef _WIN32
if (is_windows_drive(path) ||
is_windows_drive_prefix(path)) {
return 0;
}
#endif
return strchr(path, ':') != NULL;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20738 | static int mch_init(PCIDevice *d)
{
int i;
MCHPCIState *mch = MCH_PCI_DEVICE(d);
/* setup pci memory regions */
memory_region_init_alias(&mch->pci_hole, OBJECT(mch), "pci-hole",
mch->pci_address_space,
mch->below_4g_mem_size,
... |
devign_test_set_data_20741 | static int h261_find_frame_end(ParseContext *pc, AVCodecContext* avctx, const uint8_t *buf, int buf_size){
int vop_found, i, j, bits_left, last_bits;
uint32_t state;
H261Context *h = avctx->priv_data;
if(h){
bits_left = h->bits_left;
last_bits = h->last_bits;
}
else{
... |
devign_test_set_data_20743 | void address_space_write(AddressSpace *as, target_phys_addr_t addr,
const uint8_t *buf, int len)
{
address_space_rw(as, addr, (uint8_t *)buf, len, true);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20751 | static void audio_run_capture (AudioState *s)
{
CaptureVoiceOut *cap;
for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
int live, rpos, captured;
HWVoiceOut *hw = &cap->hw;
SWVoiceOut *sw;
captured = live = audio_pcm_hw_get_live_out (hw);
rpo... |
devign_test_set_data_20761 | CharDriverState *qemu_chr_alloc(void)
{
CharDriverState *chr = g_malloc0(sizeof(CharDriverState));
return chr;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_20766 | static void ecc_init(target_phys_addr_t base, qemu_irq irq, uint32_t version)
{
DeviceState *dev;
SysBusDevice *s;
dev = qdev_create(NULL, "eccmemctl");
qdev_prop_set_uint32(dev, "version", version);
qdev_init(dev);
s = sysbus_from_qdev(dev);
sysbus_connect_irq(s, 0, irq);
sys... |
devign_test_set_data_20797 | int pcistb_service_call(S390CPU *cpu, uint8_t r1, uint8_t r3, uint64_t gaddr,
uint8_t ar)
{
CPUS390XState *env = &cpu->env;
S390PCIBusDevice *pbdev;
MemoryRegion *mr;
int i;
uint32_t fh;
uint8_t pcias;
uint8_t len;
uint8_t buffer[128];
if (env->ps... |
devign_test_set_data_20802 | static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
void *opaque)
{
monitor_flush(opaque);
return FALSE;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20803 | static always_inline void gen_store_spr(int reg, TCGv t)
{
tcg_gen_st_tl(t, cpu_env, offsetof(CPUState, spr[reg]));
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20811 | int bdrv_is_read_only(BlockDriverState *bs)
{
return bs->read_only;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20812 | static void bw_conf1_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
PCIBus *b = opaque;
pci_data_write(b, addr, val, size);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20831 | void tlb_fill(target_ulong addr, int is_write, int is_user, void *retaddr)
{
TranslationBlock *tb;
int ret;
unsigned long pc;
CPUX86State *saved_env;
/* XXX: hack to restore env in all cases, even if not called from
generated code */
saved_env = env;
env = cpu_single_env;
... |
devign_test_set_data_20835 | static void test_tco1_status_bits(void)
{
TestData d;
uint16_t ticks = 8;
uint16_t val;
int ret;
d.args = NULL;
d.noreboot = true;
test_init(&d);
stop_tco(&d);
clear_tco_status(&d);
reset_on_second_timeout(false);
set_tco_timeout(&d, ticks);
load_tco(&d);... |
devign_test_set_data_20840 | block_crypto_create_opts_init(QCryptoBlockFormat format,
QemuOpts *opts,
Error **errp)
{
OptsVisitor *ov;
QCryptoBlockCreateOptions *ret = NULL;
Error *local_err = NULL;
ret = g_new0(QCryptoBlockCreateOptions, 1);
ret->format = fo... |
devign_test_set_data_20856 | static void RENAME(yuv2yuvX)(SwsContext *c, const int16_t *lumFilter,
const int16_t **lumSrc, int lumFilterSize,
const int16_t *chrFilter, const int16_t **chrUSrc,
const int16_t **chrVSrc,
int chrFilt... |
devign_test_set_data_20902 | static void add_cpreg_to_list(gpointer key, gpointer opaque)
{
ARMCPU *cpu = opaque;
uint64_t regidx;
const ARMCPRegInfo *ri;
regidx = *(uint32_t *)key;
ri = get_arm_cp_reginfo(cpu->cp_regs, regidx);
if (!(ri->type & ARM_CP_NO_MIGRATE)) {
cpu->cpreg_indexes[cpu->cpreg_array_l... |
devign_test_set_data_20903 | static int xan_huffman_decode(unsigned char *dest, unsigned char *src)
{
unsigned char byte = *src++;
unsigned char ival = byte + 0x16;
unsigned char * ptr = src + byte*2;
unsigned char val = ival;
int counter = 0;
unsigned char bits = *ptr++;
while ( val != 0x16 ) {
if ... |
devign_test_set_data_20908 | static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
{
return t && t->rearm;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_20917 | static int iff_read_header(AVFormatContext *s)
{
IffDemuxContext *iff = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st;
uint8_t *buf;
uint32_t chunk_id, data_size;
uint32_t screenmode = 0, num, den;
unsigned transparency = 0;
unsigned masking = 0; // no mask
uint8_t fm... |
devign_test_set_data_20918 | static int ftp_status(FTPContext *s, char **line, const int response_codes[])
{
int err, i, dash = 0, result = 0, code_found = 0;
char buf[CONTROL_BUFFER_SIZE];
AVBPrint line_buffer;
if (line)
av_bprint_init(&line_buffer, 0, AV_BPRINT_SIZE_AUTOMATIC);
while (!code_found || dash) {... |
devign_test_set_data_20938 | static uint32_t arm_sysctl_read(void *opaque, target_phys_addr_t offset)
{
arm_sysctl_state *s = (arm_sysctl_state *)opaque;
switch (offset) {
case 0x00: /* ID */
return s->sys_id;
case 0x04: /* SW */
/* General purpose hardware switches.
We don't have a useful way o... |
devign_test_set_data_20945 | void run_on_cpu(CPUState *cpu, void (*func)(void *data), void *data)
{
struct qemu_work_item wi;
if (qemu_cpu_is_self(cpu)) {
func(data);
return;
}
wi.func = func;
wi.data = data;
wi.free = false;
if (cpu->queued_work_first == NULL) {
cpu->queued_work_f... |
devign_test_set_data_20958 | double avpriv_strtod(char *restrict nptr, char **restrict endptr)
{
char *end;
double res;
/* Skip leading spaces */
while (isspace(*nptr))
nptr++;
if (!av_strncasecmp(nptr, "infinity", 8)) {
end = nptr + 8;
res = INFINITY;
} else if (!av_strncasecmp(nptr, "... |
devign_test_set_data_20961 | static void update_video_pts(VideoState *is, double pts, int64_t pos, int serial) {
double time = av_gettime() / 1000000.0;
/* update current video pts */
is->video_current_pts = pts;
is->video_current_pts_drift = is->video_current_pts - time;
is->video_current_pos = pos;
is->frame_last_pt... |
devign_test_set_data_20970 | open_f(int argc, char **argv)
{
int flags = 0;
int readonly = 0;
int growable = 0;
int c;
while ((c = getopt(argc, argv, "snrg")) != EOF) {
switch (c) {
case 's':
flags |= BDRV_O_SNAPSHOT;
break;
case 'n':
flags |= BDRV_O_NOCACHE;
break;
case 'r':
readonly = 1;
break;
... |
devign_test_set_data_20975 | static unsigned int event_status_media(IDEState *s,
uint8_t *buf)
{
uint8_t event_code, media_status;
media_status = 0;
if (s->tray_open) {
media_status = MS_TRAY_OPEN;
} else if (bdrv_is_inserted(s->bs)) {
media_status = MS_MEDIA_PRESENT;... |
devign_test_set_data_20994 | static void virtio_scsi_hotunplug(HotplugHandler *hotplug_dev, DeviceState *dev,
Error **errp)
{
VirtIODevice *vdev = VIRTIO_DEVICE(hotplug_dev);
VirtIOSCSI *s = VIRTIO_SCSI(vdev);
SCSIDevice *sd = SCSI_DEVICE(dev);
if ((vdev->guest_features >> VIRTIO_SCSI_F_HOT... |
devign_test_set_data_20996 | int qio_channel_socket_connect_sync(QIOChannelSocket *ioc,
SocketAddress *addr,
Error **errp)
{
int fd;
trace_qio_channel_socket_connect_sync(ioc, addr);
fd = socket_connect(addr, NULL, NULL, errp);
if (fd < 0) {
t... |
devign_test_set_data_21007 | static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
int append)
{
int buflen;
/** when the frame data does not need to be concatenated, the input buffer
is resetted and additional bits from the previous frame are copyed
and skipped later so that a fast byt... |
devign_test_set_data_21012 | static int read_interval_packets(WriterContext *w, AVFormatContext *fmt_ctx,
const ReadInterval *interval, int64_t *cur_ts)
{
AVPacket pkt, pkt1;
AVFrame *frame = NULL;
int ret = 0, i = 0, frame_count = 0;
int64_t start = -INT64_MAX, end = interval->end;
int h... |
devign_test_set_data_21030 | int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx,
uint8_t *buf, int buf_size,
const short *samples)
{
AVPacket pkt;
AVFrame *frame;
int ret, samples_size, got_packet;
av_init_packet(&pkt);
pkt... |
devign_test_set_data_21034 | static void host_cpuid(uint32_t function, uint32_t count,
uint32_t *eax, uint32_t *ebx,
uint32_t *ecx, uint32_t *edx)
{
#if defined(CONFIG_KVM)
uint32_t vec[4];
#ifdef __x86_64__
asm volatile("cpuid"
: "=a"(vec[0]), "=b"(vec[1]),
... |
devign_test_set_data_21037 | static int dxva2_map_frame(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src,
int flags)
{
IDirect3DSurface9 *surface = (IDirect3DSurface9*)src->data[3];
DXVA2Mapping *map;
D3DSURFACE_DESC surfaceDesc;
D3DLOCKED_RECT LockedRect;
HRESULT ... |
devign_test_set_data_21050 | void show_help(void)
{
const char *prog;
const OptionDef *po;
int i, expert;
prog = do_play ? "ffplay" : "ffmpeg";
printf("%s version " FFMPEG_VERSION ", Copyright (c) 2000, 2001, 2002 Gerard Lantau\n",
prog);
if (!do_play) {
printf("usage: ffmpeg [[opt... |
devign_test_set_data_21061 | av_cold int ffv1_common_init(AVCodecContext *avctx)
{
FFV1Context *s = avctx->priv_data;
if (!avctx->width || !avctx->height)
return AVERROR_INVALIDDATA;
s->avctx = avctx;
s->flags = avctx->flags;
s->picture.f = avcodec_alloc_frame();
s->last_picture.f = av_frame_alloc();
... |
devign_test_set_data_21070 | static int vqa_decode_chunk(VqaContext *s)
{
unsigned int chunk_type;
unsigned int chunk_size;
int byte_skip;
unsigned int index = 0;
int i;
unsigned char r, g, b;
int index_shift;
int res;
int cbf0_chunk = -1;
int cbfz_chunk = -1;
int cbp0_chunk = -1;
int ... |
devign_test_set_data_21092 | static void platform_mmio_map(PCIDevice *d, int region_num,
pcibus_t addr, pcibus_t size, int type)
{
int mmio_io_addr;
mmio_io_addr = cpu_register_io_memory_simple(&platform_mmio_handler,
DEVICE_NATIVE_ENDIAN);
cpu_reg... |
devign_test_set_data_21100 | static void bt_submit_hci(struct HCIInfo *info,
const uint8_t *data, int length)
{
struct bt_hci_s *hci = hci_from_info(info);
uint16_t cmd;
int paramlen, i;
if (length < HCI_COMMAND_HDR_SIZE)
goto short_hci;
memcpy(&hci->last_cmd, data, 2);
cmd = (data[1] ... |
devign_test_set_data_21102 | static int kvm_s390_register_io_adapter(S390FLICState *fs, uint32_t id,
uint8_t isc, bool swap,
bool is_maskable)
{
struct kvm_s390_io_adapter adapter = {
.id = id,
.isc = isc,
.maskable = is_maskable,
... |
devign_test_set_data_21106 | static void dec_calc(DisasContext *dc, uint32_t insn)
{
uint32_t op0, op1, op2;
uint32_t ra, rb, rd;
op0 = extract32(insn, 0, 4);
op1 = extract32(insn, 8, 2);
op2 = extract32(insn, 6, 2);
ra = extract32(insn, 16, 5);
rb = extract32(insn, 11, 5);
rd = extract32(insn, 21, 5);
... |
devign_test_set_data_21110 | QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list)
{
return timer_list->clock->type;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_21118 | void palette8tobgr16(const uint8_t *src, uint8_t *dst, long num_pixels, const uint8_t *palette)
{
long i;
for(i=0; i<num_pixels; i++)
((uint16_t *)dst)[i] = bswap_16(((uint16_t *)palette)[ src[i] ]);
}
The vulnerability label is: Vulnerable |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.