id stringlengths 22 26 | content stringlengths 72 142k |
|---|---|
devign_test_set_data_3 | int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb,
AVCodecContext *codec, int size, int big_endian)
{
int id;
uint64_t bitrate;
if (size < 14) {
avpriv_request_sample(codec, "wav header size < 14");
return AVERROR_INVALIDDATA;
}
codec->codec... |
devign_test_set_data_12 | static int xen_9pfs_connect(struct XenDevice *xendev)
{
int i;
Xen9pfsDev *xen_9pdev = container_of(xendev, Xen9pfsDev, xendev);
V9fsState *s = &xen_9pdev->state;
QemuOpts *fsdev;
if (xenstore_read_fe_int(&xen_9pdev->xendev, "num-rings",
&xen_9pdev->num_rings) =... |
devign_test_set_data_35 | static int subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub,
int pred_order)
{
int p, porder, psize;
int i, part_end;
int count = 0;
/* subframe header */
count += 8;
/* subframe */
if (sub->type == FLAC_SUBFRAME_CONSTANT) {
c... |
devign_test_set_data_43 | static void ppc_spapr_init(QEMUMachineInitArgs *args)
{
ram_addr_t ram_size = args->ram_size;
const char *cpu_model = args->cpu_model;
const char *kernel_filename = args->kernel_filename;
const char *kernel_cmdline = args->kernel_cmdline;
const char *initrd_filename = args->initrd_filename;
... |
devign_test_set_data_60 | static int mpeg1_decode_sequence(AVCodecContext *avctx,
UINT8 *buf, int buf_size)
{
Mpeg1Context *s1 = avctx->priv_data;
MpegEncContext *s = &s1->mpeg_enc_ctx;
int width, height, i, v, j;
float aspect;
init_get_bits(&s->gb, buf, buf_size);
width = ge... |
devign_test_set_data_70 | static uint32_t drc_set_unusable(sPAPRDRConnector *drc)
{
drc->allocation_state = SPAPR_DR_ALLOCATION_STATE_UNUSABLE;
if (drc->awaiting_release) {
uint32_t drc_index = spapr_drc_index(drc);
trace_spapr_drc_set_allocation_state_finalizing(drc_index);
spapr_drc_detach(drc);
}
... |
devign_test_set_data_83 | static void scsi_read_request(SCSIDiskReq *r)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
uint32_t n;
if (r->sector_count == (uint32_t)-1) {
DPRINTF("Read buf_len=%zd\n", r->iov.iov_len);
r->sector_count = 0;
scsi_req_data(&r->req, r->iov.iov_len);
... |
devign_test_set_data_84 | static void lm32_evr_init(MachineState *machine)
{
const char *cpu_model = machine->cpu_model;
const char *kernel_filename = machine->kernel_filename;
LM32CPU *cpu;
CPULM32State *env;
DriveInfo *dinfo;
MemoryRegion *address_space_mem = get_system_memory();
MemoryRegion *phys_ram = g... |
devign_test_set_data_108 | aio_write_f(int argc, char **argv)
{
char *p;
int count = 0;
int nr_iov, i, c;
int pattern = 0xcd;
struct aio_ctx *ctx = calloc(1, sizeof(struct aio_ctx));
BlockDriverAIOCB *acb;
while ((c = getopt(argc, argv, "CqP:")) != EOF) {
switch (c) {
case 'C':
ctx->Cflag = 1;
break;
case 'q':
... |
devign_test_set_data_121 | static void vc1_inv_trans_8x8_dc_c(uint8_t *dest, int linesize, DCTELEM *block)
{
int i;
int dc = block[0];
const uint8_t *cm;
dc = (3 * dc + 1) >> 1;
dc = (3 * dc + 16) >> 5;
cm = ff_cropTbl + MAX_NEG_CROP + dc;
for(i = 0; i < 8; i++){
dest[0] = cm[dest[0]];
dest[... |
devign_test_set_data_122 | static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
const char *desc_file_path)
{
int ret;
char access[11];
char type[11];
char fname[512];
const char *p = desc;
int64_t sectors = 0;
int64_t flat_offset;
char extent_path[PATH_MAX];
BlockDriverStat... |
devign_test_set_data_149 | static void compute_rematrixing_strategy(AC3EncodeContext *s)
{
int nb_coefs;
int blk, bnd, i;
AC3Block *block, *block0;
s->num_rematrixing_bands = 4;
if (s->rematrixing & AC3_REMATRIXING_IS_STATIC)
return;
nb_coefs = FFMIN(s->nb_coefs[0], s->nb_coefs[1]);
for (blk =... |
devign_test_set_data_164 | void OPPROTO op_udiv_T1_T0(void)
{
uint64_t x0;
uint32_t x1;
x0 = T0 | ((uint64_t) (env->y) << 32);
x1 = T1;
x0 = x0 / x1;
if (x0 > 0xffffffff) {
T0 = 0xffffffff;
T1 = 1;
} else {
T0 = x0;
T1 = 0;
FORCE_RET();
The vulnerability label is: Vulnerable |
devign_test_set_data_176 | void cpu_x86_init_mmu(CPUX86State *env)
{
a20_enabled = 1;
a20_mask = 0xffffffff;
last_pg_state = -1;
cpu_x86_update_cr0(env);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_178 | int qemu_cpu_self(void *env)
{
return 1;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_179 | static void net_vhost_link_down(VhostUserState *s, bool link_down)
{
s->nc.link_down = link_down;
if (s->nc.peer) {
s->nc.peer->link_down = link_down;
}
if (s->nc.info->link_status_changed) {
s->nc.info->link_status_changed(&s->nc);
}
if (s->nc.peer && s->nc.peer->... |
devign_test_set_data_185 | static int rv34_decode_mv(RV34DecContext *r, int block_type)
{
MpegEncContext *s = &r->s;
GetBitContext *gb = &s->gb;
int i, j, k, l;
int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
int next_bt;
memset(r->dmv, 0, sizeof(r->dmv));
for(i = 0; i < num_mvs[block_type]; i++){
... |
devign_test_set_data_200 | static void mirror_start_job(BlockDriverState *bs, BlockDriverState *target,
const char *replaces,
int64_t speed, uint32_t granularity,
int64_t buf_size,
BlockdevOnError on_source_error,
... |
devign_test_set_data_218 | START_TEST(qint_get_int_test)
{
QInt *qi;
const int value = 123456;
qi = qint_from_int(value);
fail_unless(qint_get_int(qi) == value);
QDECREF(qi);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_244 | static int read_code_table(CLLCContext *ctx, GetBitContext *gb, VLC *vlc)
{
uint8_t symbols[256];
uint8_t bits[256];
uint16_t codes[256];
int num_lens, num_codes, num_codes_sum, prefix;
int i, j, count;
prefix = 0;
count = 0;
num_codes_sum = 0;
num_lens = get_bits(gb, ... |
devign_test_set_data_245 | static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
CodedBitstreamUnit *unit)
{
BitstreamContext bc;
int err;
err = bitstream_init(&bc, unit->data, 8 * unit->data_size);
if (err < 0)
return err;
switch (unit->type) {
case HEVC_NAL_... |
devign_test_set_data_246 | static void qpa_audio_fini (void *opaque)
{
(void) opaque;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_248 | static void usbredir_bulk_packet(void *priv, uint32_t id,
struct usb_redir_bulk_packet_header *bulk_packet,
uint8_t *data, int data_len)
{
USBRedirDevice *dev = priv;
uint8_t ep = bulk_packet->endpoint;
int len = bulk_packet->length;
AsyncURB *aurb;
DPRINTF("bulk-in status %d ep %0... |
devign_test_set_data_262 | static av_cold int hevc_init_context(AVCodecContext *avctx)
{
HEVCContext *s = avctx->priv_data;
int i;
s->avctx = avctx;
s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
if (!s->HEVClc)
goto fail;
s->HEVClcList[0] = s->HEVClc;
s->sList[0] = s;
s->cabac_state = av_malloc(HEVC_CO... |
devign_test_set_data_265 | static int decode_plte_chunk(AVCodecContext *avctx, PNGDecContext *s,
uint32_t length)
{
int n, i, r, g, b;
if ((length % 3) != 0 || length > 256 * 3)
return AVERROR_INVALIDDATA;
/* read the palette */
n = length / 3;
for (i = 0; i < n; i++) {
... |
devign_test_set_data_272 | static MemTxResult vtd_mem_ir_write(void *opaque, hwaddr addr,
uint64_t value, unsigned size,
MemTxAttrs attrs)
{
int ret = 0;
MSIMessage from = {0}, to = {0};
from.address = (uint64_t) addr + VTD_INTERRUPT_ADDR_FIRST;
from... |
devign_test_set_data_280 | void st_flush_trace_buffer(void)
{
if (trace_file_enabled) {
flush_trace_file();
}
/* Discard written trace records */
trace_idx = 0;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_289 | VirtIODevice *virtio_blk_init(DeviceState *dev, BlockConf *conf,
char **serial)
{
VirtIOBlock *s;
int cylinders, heads, secs;
static int virtio_blk_id;
DriveInfo *dinfo;
if (!conf->bs) {
error_report("virtio-blk-pci: drive property not set");
... |
devign_test_set_data_304 | static size_t header_ext_add(char *buf, uint32_t magic, const void *s,
size_t len, size_t buflen)
{
QCowExtension *ext_backing_fmt = (QCowExtension*) buf;
size_t ext_len = sizeof(QCowExtension) + ((len + 7) & ~7);
if (buflen < ext_len) {
return -ENOSPC;
}
*ext_backing_fmt = (... |
devign_test_set_data_305 | static int mov_read_strf(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
if (c->fc->nb_streams < 1)
return 0;
if (atom.size <= 40)
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30))
return AVERROR_INVALIDDATA;
... |
devign_test_set_data_321 | static void mem_begin(MemoryListener *listener)
{
AddressSpaceDispatch *d = container_of(listener, AddressSpaceDispatch, listener);
d->phys_map.ptr = PHYS_MAP_NODE_NIL;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_325 | static uint32_t tight_palette_buf2rgb(int bpp, const uint8_t *buf)
{
uint32_t rgb = 0;
if (bpp == 32) {
rgb |= ((buf[0] & ~1) | !((buf[4] >> 3) & 1)) << 24;
rgb |= ((buf[1] & ~1) | !((buf[4] >> 2) & 1)) << 16;
rgb |= ((buf[2] & ~1) | !((buf[4] >> 1) & 1)) << 8;
rgb |= (... |
devign_test_set_data_338 | int net_init_tap(const Netdev *netdev, const char *name,
NetClientState *peer, Error **errp)
{
const NetdevTapOptions *tap;
int fd, vnet_hdr = 0, i = 0, queues;
/* for the no-fd, no-helper case */
const char *script = NULL; /* suppress wrong "uninit'd use" gcc warning */
cons... |
devign_test_set_data_369 | void stream_start(const char *job_id, BlockDriverState *bs,
BlockDriverState *base, const char *backing_file_str,
int64_t speed, BlockdevOnError on_error,
BlockCompletionFunc *cb, void *opaque, Error **errp)
{
StreamBlockJob *s;
s = block_job_create(... |
devign_test_set_data_372 | int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
AVPacket *avpkt)
{
int ret;
*got_picture_ptr = 0;
if ((avctx->coded_width || avctx->coded_height) && av_ima... |
devign_test_set_data_373 | static int omap_gpio_init(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
struct omap_gpif_s *s = OMAP1_GPIO(dev);
if (!s->clk) {
hw_error("omap-gpio: clk not connected\n");
}
qdev_init_gpio_in(dev, omap_gpio_set, 16);
qdev_init_gpio_out(dev, s->omap1.handler, 16);
sy... |
devign_test_set_data_391 | void omap_mcbsp_i2s_attach(struct omap_mcbsp_s *s, I2SCodec *slave)
{
s->codec = slave;
slave->rx_swallow = qemu_allocate_irqs(omap_mcbsp_i2s_swallow, s, 1)[0];
slave->tx_start = qemu_allocate_irqs(omap_mcbsp_i2s_start, s, 1)[0];
}
The vulnerability label is: Vulnerable |
devign_test_set_data_399 | int floatx80_eq(floatx80 a, floatx80 b, float_status *status)
{
if ( ( ( extractFloatx80Exp( a ) == 0x7FFF )
&& (uint64_t) ( extractFloatx80Frac( a )<<1 ) )
|| ( ( extractFloatx80Exp( b ) == 0x7FFF )
&& (uint64_t) ( extractFloatx80Frac( b )<<1 ) )
) {
... |
devign_test_set_data_402 | void json_lexer_init(JSONLexer *lexer, JSONLexerEmitter func)
{
lexer->emit = func;
lexer->state = IN_START;
lexer->token = qstring_new();
lexer->x = lexer->y = 0;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_404 | BlockDriverAIOCB *paio_submit(BlockDriverState *bs, int fd,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int type)
{
struct qemu_paiocb *acb;
acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);
if (!acb)
return NULL;
... |
devign_test_set_data_436 | static int crypto_open(URLContext *h, const char *uri, int flags)
{
const char *nested_url;
int ret;
CryptoContext *c = h->priv_data;
if (!av_strstart(uri, "crypto+", &nested_url) &&
!av_strstart(uri, "crypto:", &nested_url)) {
av_log(h, AV_LOG_ERROR, "Unsupported url %s\n", uri... |
devign_test_set_data_439 | int ff_alloc_entries(AVCodecContext *avctx, int count)
{
int i;
if (avctx->active_thread_type & FF_THREAD_SLICE) {
SliceThreadContext *p = avctx->internal->thread_ctx;
p->thread_count = avctx->thread_count;
p->entries = av_mallocz_array(count, sizeof(int));
if ... |
devign_test_set_data_444 | static int floppy_probe_device(const char *filename)
{
int fd, ret;
int prio = 0;
struct floppy_struct fdparam;
struct stat st;
if (strstart(filename, "/dev/fd", NULL) &&
!strstart(filename, "/dev/fdset/", NULL)) {
prio = 50;
}
fd = qemu_open(filename, O_RDONLY ... |
devign_test_set_data_461 | static void sun4uv_init(ram_addr_t RAM_size,
const char *boot_devices,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model,
const struct hwdef *hwdef)
{
CPUSt... |
devign_test_set_data_474 | static void fpu_init (CPUMIPSState *env, const mips_def_t *def)
{
int i;
for (i = 0; i < MIPS_FPU_MAX; i++)
env->fpus[i].fcr0 = def->CP1_fcr0;
memcpy(&env->active_fpu, &env->fpus[0], sizeof(env->active_fpu));
if (env->user_mode_only) {
if (env->CP0_Config1 & (1 << CP0C1_FP))
... |
devign_test_set_data_490 | static int bfi_decode_frame(AVCodecContext *avctx, void *data,
int *data_size, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data, *buf_end = avpkt->data + avpkt->size;
int buf_size = avpkt->size;
BFIContext *bfi = avctx->priv_data;
uint8_t *dst = bfi->dst;
uint8_... |
devign_test_set_data_491 | DeviceState *qdev_device_add(QemuOpts *opts)
{
ObjectClass *oc;
DeviceClass *dc;
const char *driver, *path, *id;
DeviceState *dev;
BusState *bus = NULL;
Error *err = NULL;
driver = qemu_opt_get(opts, "driver");
if (!driver) {
qerror_report(QERR_MISSING_PARAMETER, "dri... |
devign_test_set_data_501 | void thread_pool_submit(ThreadPoolFunc *func, void *arg)
{
thread_pool_submit_aio(func, arg, NULL, NULL);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_510 | static void pl061_register_devices(void)
{
sysbus_register_dev("pl061", sizeof(pl061_state),
pl061_init_arm);
sysbus_register_dev("pl061_luminary", sizeof(pl061_state),
pl061_init_luminary);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_539 | int cpu_exec(CPUState *cpu)
{
CPUClass *cc = CPU_GET_CLASS(cpu);
int ret;
SyncClocks sc;
/* replay_interrupt may need current_cpu */
current_cpu = cpu;
if (cpu_handle_halt(cpu)) {
return EXCP_HALTED;
}
rcu_read_lock();
cc->cpu_exec_enter(cpu);
/* Cal... |
devign_test_set_data_547 | static void copy_irb_to_guest(IRB *dest, const IRB *src, PMCW *pmcw)
{
int i;
uint16_t stctl = src->scsw.ctrl & SCSW_CTRL_MASK_STCTL;
uint16_t actl = src->scsw.ctrl & SCSW_CTRL_MASK_ACTL;
copy_scsw_to_guest(&dest->scsw, &src->scsw);
for (i = 0; i < ARRAY_SIZE(dest->esw); i++) {
de... |
devign_test_set_data_566 | static int process_input_packet(InputStream *ist, const AVPacket *pkt)
{
int i;
int got_output;
AVPacket avpkt;
if (ist->next_dts == AV_NOPTS_VALUE)
ist->next_dts = ist->last_dts;
if (pkt == NULL) {
/* EOF handling */
av_init_packet(&avpkt);
avpkt.data =... |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 4