id stringlengths 19 22 | source_name stringclasses 2
values | source_type stringclasses 1
value | source_split stringclasses 2
values | original_id unknown | language stringclasses 2
values | framework stringclasses 1
value | task stringclasses 2
values | cwe_id stringclasses 15
values | owasp_category stringclasses 6
values | severity stringclasses 3
values | is_vulnerable bool 2
classes | vulnerability_name stringclasses 15
values | input_code stringlengths 26 142k | fixed_code stringclasses 1
value | explanation stringclasses 2
values | secure_pattern stringclasses 1
value | tags listlengths 4 4 | metadata unknown |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
codexglue_train_007726 | CodeXGLUE Defect Detection | public_dataset | train | 9603 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state,
int is_signed)
{
if (get_rac(c, state + 0))
return 0;
else {
int i, e, a;
e = 0;
while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "8630b2cd36c57918acfe18302fe77d1ceefbd676",
"normalized_at": "2026-06-20T05:17:39.120243Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009120 | CodeXGLUE Defect Detection | public_dataset | train | 11346 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int check_directory_consistency(BDRVVVFATState *s,
int cluster_num, const char* path)
{
int ret = 0;
unsigned char* cluster = qemu_malloc(s->cluster_size);
direntry_t* direntries = (direntry_t*)cluster;
mapping_t* mapping = find_mapping_for_cluster(s, cluster_num);
long_file_name lf... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "6265eb26a375179f193f792e4f0d49036d2cf052",
"normalized_at": "2026-06-20T05:17:39.154015Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014476 | CodeXGLUE Defect Detection | public_dataset | train | 18073 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int get_last_needed_nal(H264Context *h)
{
int nals_needed = 0;
int i;
for (i = 0; i < h->pkt.nb_nals; i++) {
H2645NAL *nal = &h->pkt.nals[i];
GetBitContext gb;
/* packets can sometimes contain multiple PPS/SPS,
* e.g. two PAFF field pictures in one packet,... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "76f7e70aa04fc5dbef5242b11cbf8fe4499f61d4",
"normalized_at": "2026-06-20T05:17:39.290098Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021320 | CodeXGLUE Defect Detection | public_dataset | train | 26658 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
{
phdr->p_type = PT_NOTE;
phdr->p_offset = offset;
phdr->p_vaddr = 0;
phdr->p_paddr = 0;
phdr->p_filesz = sz;
phdr->p_memsz = 0;
phdr->p_flags = 0;
phdr->p_align = 0;
#ifdef BSWAP_NEEDED
bswap_ph... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "991f8f0c91d65cebf51fa931450e02b0d5209012",
"normalized_at": "2026-06-20T05:17:39.476198Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015862 | CodeXGLUE Defect Detection | public_dataset | train | 19817 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void pcie_aer_root_init(PCIDevice *dev)
{
uint16_t pos = dev->exp.aer_cap;
pci_set_long(dev->wmask + pos + PCI_ERR_ROOT_COMMAND,
PCI_ERR_ROOT_CMD_EN_MASK);
pci_set_long(dev->w1cmask + pos + PCI_ERR_ROOT_STATUS,
PCI_ERR_ROOT_STATUS_REPORT_MASK);
} | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "0e180d9c8a7429c55d23d2e7855f1e490a063aaa",
"normalized_at": "2026-06-20T05:17:39.328199Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013914 | CodeXGLUE Defect Detection | public_dataset | train | 17351 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
AVSubtitleRect *r)
{
uint32_t *pal, *dst2;
uint8_t *src, *src2;
int x, y;
if (r->type != SUBTITLE_BITMAP) {
av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "0ac83047f67bb56406c66d4ca664d3c0cb07c2f2",
"normalized_at": "2026-06-20T05:17:39.275689Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004458 | CodeXGLUE Defect Detection | public_dataset | train | 5522 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int event_qdev_exit(DeviceState *qdev)
{
SCLPEvent *event = DO_UPCAST(SCLPEvent, qdev, qdev);
SCLPEventClass *child = SCLP_EVENT_GET_CLASS(event);
if (child->exit) {
child->exit(event);
}
return 0;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "c804c2a71752dd1e150cde768d8c54b02fa8bad9",
"normalized_at": "2026-06-20T05:17:39.036982Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017053 | CodeXGLUE Defect Detection | public_dataset | train | 21307 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void write_dt(void *ptr, unsigned long addr, unsigned long limit,
int flags)
{
unsigned int e1, e2;
uint32_t *p;
e1 = (addr << 16) | (limit & 0xffff);
e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
e2 |= flags;
p = ptr;
p[0] = ts... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "d538e8f50d89a66ae14a2cf351d2e0e5365d463b",
"normalized_at": "2026-06-20T05:17:39.358994Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018881 | CodeXGLUE Defect Detection | public_dataset | train | 23588 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void pci_spapr_set_irq(void *opaque, int irq_num, int level)
{
/*
* Here we use the number returned by pci_spapr_map_irq to find a
* corresponding qemu_irq.
*/
sPAPRPHBState *phb = opaque;
qemu_set_irq(phb->lsi_table[irq_num].qirq, level);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "a307d59434ba78b97544b42b8cfd24a1b62e39a6",
"normalized_at": "2026-06-20T05:17:39.411028Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012486 | CodeXGLUE Defect Detection | public_dataset | train | 15551 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
int64_t cur_sector, int64_t nr_sectors)
{
assert(bdrv_dirty_bitmap_enabled(bitmap));
hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "b64bd51efa9bbf30df1b2f91477d2805678d0b93",
"normalized_at": "2026-06-20T05:17:39.240671Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000702 | CodeXGLUE Defect Detection | public_dataset | train | 866 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static inline void RENAME(rgb16to15)(const uint8_t *src,uint8_t *dst,long src_size)
{
register const uint8_t* s=src;
register uint8_t* d=dst;
register const uint8_t *end;
const uint8_t *mm_end;
end = s + src_size;
#ifdef HAVE_MMX
__asm __volatile(PREFETCH" %0"::"m"(*s));
__asm __volatile("movq %0... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "6e42e6c4b410dbef8b593c2d796a5dad95f89ee4",
"normalized_at": "2026-06-20T05:17:38.934955Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007643 | CodeXGLUE Defect Detection | public_dataset | train | 9496 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static size_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...)
{
size_t old_offset = offset;
va_list ap;
int i;
va_start(ap, fmt);
for (i = 0; fmt[i]; i++) {
switch (fmt[i]) {
case 'b': {
uint8_t val = va_arg(ap, int);
offset += pdu_p... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "302a0d3ed721e4c30c6a2a37f64c60b50ffd33b9",
"normalized_at": "2026-06-20T05:17:39.118293Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008529 | CodeXGLUE Defect Detection | public_dataset | train | 10616 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
{
const uint8_t *buf_ptr;
unsigned int v, v2;
int val;
int skipped = 0;
buf_ptr = *pbuf_ptr;
while (buf_ptr < buf_end) {
v = *buf_ptr++;
v2 = *buf_ptr;
if ((v == 0xff) && (v2 >= 0xc0) &&... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "16a0d75c769a7df6f457b2200dbc9a7cc73798c6",
"normalized_at": "2026-06-20T05:17:39.138662Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013699 | CodeXGLUE Defect Detection | public_dataset | train | 17079 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void error(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "qemu-img: ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
va_end(ap);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "8b7968f7c4ac8c07cad6a1a0891d38cf239a2839",
"normalized_at": "2026-06-20T05:17:39.270450Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001067 | CodeXGLUE Defect Detection | public_dataset | train | 1304 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void slirp_init_once(void)
{
static int initialized;
struct hostent *he;
char our_name[256];
#ifdef _WIN32
WSADATA Data;
#endif
if (initialized) {
return;
}
initialized = 1;
#ifdef _WIN32
WSAStartup(MAKEWORD(2,0), &Data);
atexit(winsock_cleanup);
#en... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "ce0bd027df9c62766a5417521d0f08f27359d43f",
"normalized_at": "2026-06-20T05:17:38.946549Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020330 | CodeXGLUE Defect Detection | public_dataset | train | 25416 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt,
int discard)
{
AviSynthContext *avs = s->priv_data;
AVS_VideoFrame *frame;
unsigned char *dst_p;
const unsigned char *src_p;
int n, i, plane, rowsize, planeheight, pitch, bits;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "aaae59700f7fc10fd80cb93b38c5d109900872d9",
"normalized_at": "2026-06-20T05:17:39.449750Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003905 | CodeXGLUE Defect Detection | public_dataset | train | 4811 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void usb_ep_combine_input_packets(USBEndpoint *ep)
{
USBPacket *p, *u, *next, *prev = NULL, *first = NULL;
USBPort *port = ep->dev->port;
int ret;
assert(ep->pipeline);
assert(ep->pid == USB_TOKEN_IN);
QTAILQ_FOREACH_SAFE(p, &ep->queue, queue, next) {
/* Empty the queue on a ... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "579967bea69bf1b32faee13ff76b19ba641a2618",
"normalized_at": "2026-06-20T05:17:39.023667Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000283 | CodeXGLUE Defect Detection | public_dataset | train | 352 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void ff_rtp_send_h263(AVFormatContext *s1, const uint8_t *buf1, int size)
{
RTPMuxContext *s = s1->priv_data;
int len, max_packet_size;
uint8_t *q;
max_packet_size = s->max_payload_size;
while (size > 0) {
q = s->buf;
if ((buf1[0] == 0) && (buf1[1] == 0)) {
*... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "34056cbba55f0131e8d2698717ab9e86e2da5178",
"normalized_at": "2026-06-20T05:17:38.923983Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007081 | CodeXGLUE Defect Detection | public_dataset | train | 8795 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void write_section_data(MpegTSContext *ts, MpegTSFilter *tss1,
const uint8_t *buf, int buf_size, int is_start)
{
MpegTSSectionFilter *tss = &tss1->u.section_filter;
int len;
if (is_start) {
memcpy(tss->section_buf, buf, buf_size);
tss->section_i... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "4b6be54bed27eb7fc8f005505ff38e71b3c86cec",
"normalized_at": "2026-06-20T05:17:39.104681Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007582 | CodeXGLUE Defect Detection | public_dataset | train | 9417 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_vbv_update(MpegEncContext *s, int frame_size)
{
RateControlContext *rcc = &s->rc_context;
const double fps = get_fps(s->avctx);
const int buffer_size = s->avctx->rc_buffer_size;
const double min_rate = s->avctx->rc_min_rate / fps;
const double max_rate = s->avctx->rc_max_ra... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "d8fb170da2e7edbfd250c1d8e1de6b1a0e965170",
"normalized_at": "2026-06-20T05:17:39.116558Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011869 | CodeXGLUE Defect Detection | public_dataset | train | 14766 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int gif_parse_next_image(GifState *s)
{
ByteIOContext *f = s->f;
int ret, code;
for (;;) {
code = url_fgetc(f);
#ifdef DEBUG
printf("gif: code=%02x '%c'\n", code, code);
#endif
switch (code) {
case ',':
if (gif_read_image(s) < 0)
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "0b54f3c0878a3acaa9142e4f24942e762d97e350",
"normalized_at": "2026-06-20T05:17:39.225716Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011920 | CodeXGLUE Defect Detection | public_dataset | train | 14837 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int targa_encode_close(AVCodecContext *avctx)
{
av_frame_free(&avctx->coded_frame);
return 0;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "d6604b29ef544793479d7fb4e05ef6622bb3e534",
"normalized_at": "2026-06-20T05:17:39.226819Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000547 | OWASP Benchmark Python | public_dataset | processed | 547 | python | generic | security_review | CWE-643 | A03: Injection | high | false | XPath Injection | '''
OWASP Benchmark for Python v0.1
This file is part of the Open Web Application Security Project (OWASP) Benchmark Project.
For details, please see https://owasp.org/www-project-benchmark.
The OWASP Benchmark is free software: you can redistribute it and/or modify it under the terms
of the GNU General Public Licens... | This example was normalized from OWASP Benchmark Python. It is intended for security review and vulnerability detection. A secure repair is not included in this source-specific normalized record. | [
"owasp",
"benchmark-python",
"python",
"cwe-643"
] | {
"raw_path": "testcode/BenchmarkTest00547.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.704388Z",
"name_fixed_at": "2026-06-20T05:22:49.834530Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002930 | CodeXGLUE Defect Detection | public_dataset | train | 3586 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int decode_mb_info(IVI4DecContext *ctx, IVIBandDesc *band,
IVITile *tile, AVCodecContext *avctx)
{
int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, blks_per_mb,
mv_scale, mb_type_bits, s;
IVIMbInfo *mb, *ref_mb;
int row_offset = band->... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "5216245a2c5ed8140d99f14fcc148fbb6db9831e",
"normalized_at": "2026-06-20T05:17:38.998402Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018947 | CodeXGLUE Defect Detection | public_dataset | train | 23670 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | iscsi_aio_read16_cb(struct iscsi_context *iscsi, int status,
void *command_data, void *opaque)
{
IscsiAIOCB *acb = opaque;
trace_iscsi_aio_read16_cb(iscsi, status, acb, acb->canceled);
if (acb->canceled) {
qemu_aio_release(acb);
return;
}
acb->statu... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "b20909195745c34a819aed14ae996b60ab0f591f",
"normalized_at": "2026-06-20T05:17:39.412600Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013117 | CodeXGLUE Defect Detection | public_dataset | train | 16336 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int mpegts_resync(ByteIOContext *pb)
{
int c, i;
for(i = 0;i < MAX_RESYNC_SIZE; i++) {
c = url_fgetc(pb);
if (c < 0)
return -1;
if (c == 0x47) {
url_fseek(pb, -1, SEEK_CUR);
return 0;
}
}
/* no sync found */
re... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "1303d62d8416fa315a0cc7bbbe35cfdab787ea92",
"normalized_at": "2026-06-20T05:17:39.256940Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014257 | CodeXGLUE Defect Detection | public_dataset | train | 17799 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void FUNCC(ff_h264_idct8_add)(uint8_t *_dst, int16_t *_block, int stride){
int i;
pixel *dst = (pixel*)_dst;
dctcoef *block = (dctcoef*)_block;
stride >>= sizeof(pixel)-1;
block[0] += 32;
for( i = 0; i < 8; i++ )
{
const int a0 = block[i+0*8] + block[i+4*8];
con... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "0ba22831e1fcc88c755190b08a9cfc235df3a9a9",
"normalized_at": "2026-06-20T05:17:39.284038Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005260 | CodeXGLUE Defect Detection | public_dataset | train | 6527 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void qmp_blockdev_change_medium(const char *device, const char *filename,
bool has_format, const char *format,
bool has_read_only,
BlockdevChangeReadOnlyMode read_only,
Error **errp)
{
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "a5614993d79584af93bb845f69f59872b3f76cf8",
"normalized_at": "2026-06-20T05:17:39.058010Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014987 | CodeXGLUE Defect Detection | public_dataset | train | 18734 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void ff_avg_h264_qpel16_mc11_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_hv_qrt_and_aver_dst_16x16_msa(src - 2,
src - (stride * 2),
stride, dst, stride);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "1181d93231e9b807965724587d363c1cfd5a1d0d",
"normalized_at": "2026-06-20T05:17:39.303960Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010827 | CodeXGLUE Defect Detection | public_dataset | train | 13500 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void arm_cpu_initfn(Object *obj)
{
CPUState *cs = CPU(obj);
ARMCPU *cpu = ARM_CPU(obj);
static bool inited;
cs->env_ptr = &cpu->env;
cpu_exec_init(&cpu->env);
cpu->cp_regs = g_hash_table_new_full(g_int_hash, g_int_equal,
g_free, g_free);
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "98128601ac8ff23df8a4c48acff00f9614613463",
"normalized_at": "2026-06-20T05:17:39.197970Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021048 | CodeXGLUE Defect Detection | public_dataset | train | 26308 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void net_rx_pkt_attach_iovec_ex(struct NetRxPkt *pkt,
const struct iovec *iov, int iovcnt,
size_t iovoff, bool strip_vlan,
uint16_t vet)
{
uint16_t tci = 0;
uint16_t ploff = iovoff;
assert(pkt);
pkt->... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "df8bf7a7fe75eb5d5caffa55f5cd4292b757aea6",
"normalized_at": "2026-06-20T05:17:39.468110Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009314 | CodeXGLUE Defect Detection | public_dataset | train | 11588 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | altivec_packIntArrayToCharArray(int *val, uint8_t* dest, int dstW) {
register int i;
vector unsigned int altivec_vectorShiftInt19 =
vec_add(vec_splat_u32(10),vec_splat_u32(9));
if ((unsigned long)dest % 16) {
/* badly aligned store, we force store alignement */
/* and will handle load misalignem... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "6e42e6c4b410dbef8b593c2d796a5dad95f89ee4",
"normalized_at": "2026-06-20T05:17:39.159313Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014088 | CodeXGLUE Defect Detection | public_dataset | train | 17570 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void net_socket_receive(void *opaque, const uint8_t *buf, size_t size)
{
NetSocketState *s = opaque;
uint32_t len;
len = htonl(size);
send_all(s->fd, (const uint8_t *)&len, sizeof(len));
send_all(s->fd, buf, size);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "e3f5ec2b5e92706e3b807059f79b1fb5d936e567",
"normalized_at": "2026-06-20T05:17:39.280284Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005029 | CodeXGLUE Defect Detection | public_dataset | train | 6247 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc)
{
int bps, blkalign, bytespersec;
int hdrsize = 18;
int waveformatextensible;
uint8_t temp[256];
uint8_t *riff_extradata= temp;
uint8_t *riff_extradata_start= temp;
if(!enc->codec_tag || enc->codec_tag > 0xffff)
r... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "2c4e08d89327595f7f4be57dda4b3775e1198d5e",
"normalized_at": "2026-06-20T05:17:39.051136Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017521 | CodeXGLUE Defect Detection | public_dataset | train | 21886 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | av_cold int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
int fullRange, int brightness,
int contrast, int saturation)
{
const int isRgb = c->dstFormat == AV_PIX_FMT_RGB32 ||
c->dstFormat == AV... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "1dd797e3c9f179f957316a0becbec048b42df8aa",
"normalized_at": "2026-06-20T05:17:39.373777Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002037 | CodeXGLUE Defect Detection | public_dataset | train | 2480 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void patch_instruction(VAPICROMState *s, X86CPU *cpu, target_ulong ip)
{
CPUState *cs = CPU(cpu);
CPUX86State *env = &cpu->env;
VAPICHandlers *handlers;
uint8_t opcode[2];
uint32_t imm32 = 0;
target_ulong current_pc = 0;
target_ulong current_cs_base = 0;
uint32_t current_... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "6886b98036a8f8f5bce8b10756ce080084cef11b",
"normalized_at": "2026-06-20T05:17:38.971709Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019465 | CodeXGLUE Defect Detection | public_dataset | train | 24322 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int qemu_gluster_parseuri(GlusterConf *gconf, const char *filename)
{
URI *uri;
QueryParams *qp = NULL;
bool is_unix = false;
int ret = 0;
uri = uri_parse(filename);
if (!uri) {
return -EINVAL;
}
/* transport */
if (!strcmp(uri->scheme, "gluster")) {
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "24897a767bd778fc6a050537d024565f9272cd06",
"normalized_at": "2026-06-20T05:17:39.427960Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014963 | CodeXGLUE Defect Detection | public_dataset | train | 18705 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | YUV2RGB(rgb8, uint8_t)
YUV2RGB(rgb16, uint16_t)
/* process exactly one decompressed row */
static void png_handle_row(PNGDecContext *s)
{
uint8_t *ptr, *last_row;
int got_line;
if (!s->interlace_type) {
ptr = s->image_buf + s->image_linesize * (s->y + s->y_offset) + s->x_offset * s->bpp;... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "478f1c3d5e5463a284ea7efecfc62d47ba3be11a",
"normalized_at": "2026-06-20T05:17:39.303316Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017540 | CodeXGLUE Defect Detection | public_dataset | train | 21908 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void net_socket_accept(void *opaque)
{
NetSocketListenState *s = opaque;
NetSocketState *s1;
struct sockaddr_in saddr;
socklen_t len;
int fd;
for(;;) {
len = sizeof(saddr);
fd = qemu_accept(s->fd, (struct sockaddr *)&saddr, &len);
if (fd < 0 && errno !=... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "e5d1fca0f20babbe355957b9ba536fe6187691cc",
"normalized_at": "2026-06-20T05:17:39.374286Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009962 | CodeXGLUE Defect Detection | public_dataset | train | 12430 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void virtio_blk_free_request(VirtIOBlockReq *req)
{
if (req) {
g_slice_free(VirtQueueElement, req->elem);
g_slice_free(VirtIOBlockReq, req);
}
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "f897bf751fbd95e4015b95d202c706548586813a",
"normalized_at": "2026-06-20T05:17:39.175681Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002777 | CodeXGLUE Defect Detection | public_dataset | train | 3395 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
const uint8_t *buf, unsigned int substr)
{
SubStream *s = &m->substream[substr];
unsigned int ch;
int sync_word, tmp;
uint8_t checksum;
uint8_t lossless_check;
int start_count = get_bit... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "a9cd12ee2afb3f3aad783c396816b23d8513f472",
"normalized_at": "2026-06-20T05:17:38.993546Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010700 | CodeXGLUE Defect Detection | public_dataset | train | 13335 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void set_chr(Object *obj, Visitor *v, const char *name, void *opaque,
Error **errp)
{
DeviceState *dev = DEVICE(obj);
Error *local_err = NULL;
Property *prop = opaque;
CharBackend *be = qdev_get_prop_ptr(dev, prop);
CharDriverState *s;
char *str;
if (dev... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "2209401fa73e176ed093167b8f60aba797f25d49",
"normalized_at": "2026-06-20T05:17:39.195334Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014951 | CodeXGLUE Defect Detection | public_dataset | train | 18690 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void ppc_store_sdr1(CPUPPCState *env, target_ulong value)
{
LOG_MMU("%s: " TARGET_FMT_lx "\n", __func__, value);
if (env->spr[SPR_SDR1] != value) {
env->spr[SPR_SDR1] = value;
#if defined(TARGET_PPC64)
if (env->mmu_model & POWERPC_MMU_64) {
target_ulong htabsize = value & SDR_... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "f3c75d42adbba553eaf218a832d4fbea32c8f7b8",
"normalized_at": "2026-06-20T05:17:39.303009Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004105 | CodeXGLUE Defect Detection | public_dataset | train | 5068 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int fourxm_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
FourxmDemuxContext *fourxm = s->priv_data;
ByteIOContext *pb = s->pb;
unsigned int fourcc_tag;
unsigned int size, out_size;
int ret = 0;
unsigned int track_number;
int packet_read = 0;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "8bb7d97be0cda3c944956c79c50d0cf6f1efb7b9",
"normalized_at": "2026-06-20T05:17:39.028529Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020134 | CodeXGLUE Defect Detection | public_dataset | train | 25174 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int qxl_init_secondary(PCIDevice *dev)
{
static int device_id = 1;
PCIQXLDevice *qxl = DO_UPCAST(PCIQXLDevice, pci, dev);
ram_addr_t ram_size = msb_mask(qxl->vga.vram_size * 2 - 1);
qxl->id = device_id++;
if (ram_size < 16 * 1024 * 1024) {
ram_size = 16 * 1024 * 1024;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "96c05abc904c6f74b60981d956cee531920e4cdf",
"normalized_at": "2026-06-20T05:17:39.445240Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010801 | CodeXGLUE Defect Detection | public_dataset | train | 13470 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void qemu_spice_destroy_host_primary(SimpleSpiceDisplay *ssd)
{
dprint(1, "%s:\n", __FUNCTION__);
qemu_mutex_unlock_iothread();
ssd->worker->destroy_primary_surface(ssd->worker, 0);
qemu_mutex_lock_iothread();
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "196a778428989217b82de042725dc8eb29c8f8d8",
"normalized_at": "2026-06-20T05:17:39.197524Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014251 | CodeXGLUE Defect Detection | public_dataset | train | 17791 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | real_parse_asm_rulebook(AVFormatContext *s, AVStream *orig_st,
const char *p)
{
const char *end;
int n_rules, odd = 0;
AVStream *st;
/**
* The ASMRuleBook contains a list of comma-separated strings per rule,
* and each rule is separated by a ;. The last one al... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "dfdb353cd565efbd1f64105ce7519ec809ad338d",
"normalized_at": "2026-06-20T05:17:39.283885Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000775 | OWASP Benchmark Python | public_dataset | processed | 775 | python | generic | security_review | CWE-330 | A02: Cryptographic Failures | medium | true | Use of Insufficiently Random Values | '''
OWASP Benchmark for Python v0.1
This file is part of the Open Web Application Security Project (OWASP) Benchmark Project.
For details, please see https://owasp.org/www-project-benchmark.
The OWASP Benchmark is free software: you can redistribute it and/or modify it under the terms
of the GNU General Public Licens... | This example was normalized from OWASP Benchmark Python. It is intended for security review and vulnerability detection. A secure repair is not included in this source-specific normalized record. | [
"owasp",
"benchmark-python",
"python",
"cwe-330"
] | {
"raw_path": "testcode/BenchmarkTest00775.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.714605Z",
"name_fixed_at": "2026-06-20T05:22:49.838221Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004116 | CodeXGLUE Defect Detection | public_dataset | train | 5082 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int usb_qdev_exit(DeviceState *qdev)
{
USBDevice *dev = USB_DEVICE(qdev);
if (dev->attached) {
usb_device_detach(dev);
}
usb_device_handle_destroy(dev);
if (dev->port) {
usb_release_port(dev);
}
return 0;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "7d553f27fce284805d7f94603932045ee3bbb979",
"normalized_at": "2026-06-20T05:17:39.028726Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014603 | CodeXGLUE Defect Detection | public_dataset | train | 18240 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void HELPER(wsr_lbeg)(uint32_t v)
{
if (env->sregs[LBEG] != v) {
tb_invalidate_phys_page_range(
env->sregs[LEND] - 1, env->sregs[LEND], 0);
env->sregs[LBEG] = v;
}
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "3d0be8a5c135dadcfbd68ed354007a8cece98849",
"normalized_at": "2026-06-20T05:17:39.293715Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020047 | CodeXGLUE Defect Detection | public_dataset | train | 25065 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_thread_decode_frame(AVCodecContext *avctx,
AVFrame *picture, int *got_picture_ptr,
AVPacket *avpkt)
{
FrameThreadContext *fctx = avctx->internal->thread_ctx;
int finished = fctx->next_finished;
PerThreadContext *p;
int err;
/* re... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "1269cd5b6f540bef5913bf134d2f461aac50d70b",
"normalized_at": "2026-06-20T05:17:39.443110Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021722 | CodeXGLUE Defect Detection | public_dataset | train | 27157 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int libopenjpeg_copy_unpacked16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
{
int compno;
int x;
int y;
int width;
int height;
int *image_line;
int frame_index;
const int numcomps = image->numcomps;
uint16_t *frame_ptr;
for (compno = 0; co... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "56706ac0d5723cb549fec2602e798ab1bf6004cd",
"normalized_at": "2026-06-20T05:17:39.490691Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020071 | CodeXGLUE Defect Detection | public_dataset | train | 25099 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | float32 helper_fdtos(CPUSPARCState *env, float64 src)
{
float32 ret;
clear_float_exceptions(env);
ret = float64_to_float32(src, &env->fp_status);
check_ieee_exceptions(env);
return ret;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "7385aed20db5d83979f683b9d0048674411e963c",
"normalized_at": "2026-06-20T05:17:39.443782Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021064 | CodeXGLUE Defect Detection | public_dataset | train | 26327 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,
URLContext *handle, int packet_size)
{
AVFormatContext *rtpctx;
int ret;
AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);
if (!rtp_format)
return NULL;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "ce41c51b0c71c87f623914ba0786aef325d818fe",
"normalized_at": "2026-06-20T05:17:39.468671Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007902 | CodeXGLUE Defect Detection | public_dataset | train | 9839 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void *acpi_add_rom_blob(AcpiBuildState *build_state, GArray *blob,
const char *name)
{
return rom_add_blob(name, blob->data, acpi_data_len(blob), -1, name,
acpi_build_update, build_state);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "ad5b88b1f198182642b6cbf3dacb4cade0c80fb9",
"normalized_at": "2026-06-20T05:17:39.124526Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000633 | CodeXGLUE Defect Detection | public_dataset | train | 783 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int mpeg_decode_mb(MpegEncContext *s,
DCTELEM block[12][64])
{
int i, j, k, cbp, val, mb_type, motion_type;
const int mb_block_count = 4 + (1<< s->chroma_format)
dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
assert(s->mb_skiped==0);
if (s->mb_skip... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "71434945f20c6d340b4c942de7746e6ea46ec74b",
"normalized_at": "2026-06-20T05:17:38.932601Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001409 | CodeXGLUE Defect Detection | public_dataset | train | 1727 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt)
{
IVI45DecContext *ctx = avctx->priv_data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int result, p, b;
init_get_bits(&ctx->gb, bu... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "b146d74730ab9ec5abede9066f770ad851e45fbc",
"normalized_at": "2026-06-20T05:17:38.955708Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015026 | CodeXGLUE Defect Detection | public_dataset | train | 18784 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void visitor_reset(TestOutputVisitorData *data)
{
visitor_output_teardown(data, NULL);
visitor_output_setup(data, NULL);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "b3db211f3c80bb996a704d665fe275619f728bd4",
"normalized_at": "2026-06-20T05:17:39.305040Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002849 | CodeXGLUE Defect Detection | public_dataset | train | 3486 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static av_cold int mov_text_encode_init(AVCodecContext *avctx)
{
/*
* For now, we'll use a fixed default style. When we add styling
* support, this will be generated from the ASS style.
*/
static const uint8_t text_sample_entry[] = {
0x00, 0x00, 0x00, 0x00, // uint32_t displayFlags... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "f95c81ce104554b6860d94724a681a1bac0c4fbd",
"normalized_at": "2026-06-20T05:17:38.995494Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009357 | CodeXGLUE Defect Detection | public_dataset | train | 11645 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
{
TAKDemuxContext *tc = s->priv_data;
int ret;
if (tc->mlast_frame) {
AVIOContext *pb = s->pb;
int64_t size, left;
left = tc->data_end - avio_tell(s->pb);
size = FFMIN(left, 1024);
if (size <= ... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "4977e467a50a690a46af5988d568eaab2e5933c7",
"normalized_at": "2026-06-20T05:17:39.160735Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000065 | CodeXGLUE Defect Detection | public_dataset | train | 78 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | SwsContext *sws_alloc_context(void)
{
SwsContext *c = av_mallocz(sizeof(SwsContext));
c->av_class = &sws_context_class;
av_opt_set_defaults(c);
return c;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "f73f76fd202b310e8e1d0215b2e0cf038cd18c4a",
"normalized_at": "2026-06-20T05:17:38.916511Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005531 | CodeXGLUE Defect Detection | public_dataset | train | 6873 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size)
{
skip_spaces(p);
if(**p) {
get_word_sep(attr, attr_size, "=", p);
if (**p == '=')
(*p)++;
get_word_sep(value, value_size, ";", p);
if (**p == ';')
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "c89658008705d949c319df3fa6f400c481ad73e1",
"normalized_at": "2026-06-20T05:17:39.065129Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004320 | CodeXGLUE Defect Detection | public_dataset | train | 5343 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int find_debugfs(char *debugfs)
{
char type[100];
FILE *fp;
fp = fopen("/proc/mounts", "r");
if (fp == NULL) {
return 0;
}
while (fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n",
debugfs, type) == 2) {
if (strcmp(type, "debugfs") == ... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "5070570c9089b905dd9efae30ee4318033c6ccd6",
"normalized_at": "2026-06-20T05:17:39.033903Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004847 | CodeXGLUE Defect Detection | public_dataset | train | 6015 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void *virtqueue_pop(VirtQueue *vq, size_t sz)
{
unsigned int i, head, max;
hwaddr desc_pa = vq->vring.desc;
VirtIODevice *vdev = vq->vdev;
VirtQueueElement *elem;
unsigned out_num, in_num;
hwaddr addr[VIRTQUEUE_MAX_SIZE];
struct iovec iov[VIRTQUEUE_MAX_SIZE];
VRingDesc desc;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "be1fea9bc286f64c6c995bb0d7145a0b738aeddb",
"normalized_at": "2026-06-20T05:17:39.047050Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009968 | CodeXGLUE Defect Detection | public_dataset | train | 12437 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | long do_sigreturn(CPUS390XState *env)
{
sigframe *frame;
abi_ulong frame_addr = env->regs[15];
qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__,
(unsigned long long)frame_addr);
target_sigset_t target_set;
sigset_t set;
if (!lock_user_struct(VERIFY_READ, frame, frame_addr,... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "1c275925bfbbc2de84a8f0e09d1dd70bbefb6da3",
"normalized_at": "2026-06-20T05:17:39.175847Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008894 | CodeXGLUE Defect Detection | public_dataset | train | 11074 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | yuv2rgb_2_c_template(SwsContext *c, const int16_t *buf[2],
const int16_t *ubuf[2], const int16_t *vbuf[2],
const int16_t *abuf[2], uint8_t *dest, int dstW,
int yalpha, int uvalpha, int y,
enum PixelFormat target, int hasAlpha)
{
con... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "9487fb4dea3498eb4711eb023f43199f68701b1e",
"normalized_at": "2026-06-20T05:17:39.147955Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017522 | CodeXGLUE Defect Detection | public_dataset | train | 21887 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int vp3_decode_init(AVCodecContext *avctx)
{
Vp3DecodeContext *s = avctx->priv_data;
int i;
s->avctx = avctx;
s->width = avctx->width;
s->height = avctx->height;
avctx->pix_fmt = PIX_FMT_YUV420P;
avctx->has_b_frames = 0;
dsputil_init(&s->dsp, avctx);
/* initializ... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "892fc83e88a20f9543c6c5be3626712be7a2e6f2",
"normalized_at": "2026-06-20T05:17:39.373838Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011582 | CodeXGLUE Defect Detection | public_dataset | train | 14420 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | char *g_strconcat(const char *s, ...)
{
char *s;
/*
* Can't model: last argument must be null, the others
* null-terminated strings
*/
s = __coverity_alloc_nosize__();
__coverity_writeall__(s);
__coverity_mark_as_afm_allocated__(s, AFM_free);
return s;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "7ad4c7200111d20eb97eed4f46b6026e3f0b0eef",
"normalized_at": "2026-06-20T05:17:39.218467Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019988 | CodeXGLUE Defect Detection | public_dataset | train | 24999 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void qemu_input_transform_abs_rotate(InputEvent *evt)
{
InputMoveEvent *move = evt->u.abs;
switch (graphic_rotate) {
case 90:
if (move->axis == INPUT_AXIS_X) {
move->axis = INPUT_AXIS_Y;
} else if (move->axis == INPUT_AXIS_Y) {
move->axis = INPUT_AXIS_X... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "32bafa8fdd098d52fbf1102d5a5e48d29398c0aa",
"normalized_at": "2026-06-20T05:17:39.441853Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016137 | CodeXGLUE Defect Detection | public_dataset | train | 20168 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void set_int16(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Property *prop = opaque;
int16_t *ptr = qdev_get_prop_ptr(dev, prop);
Error *local_err = NULL;
int64_t value;
if (dev->state != DEV_STATE... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "6350b0904615cc0531cc3059ea34db5c009c88aa",
"normalized_at": "2026-06-20T05:17:39.335454Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006974 | CodeXGLUE Defect Detection | public_dataset | train | 8672 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int bdrv_file_open(BlockDriverState **pbs, const char *filename, int flags)
{
BlockDriverState *bs;
int ret;
bs = bdrv_new("");
if (!bs)
return -ENOMEM;
ret = bdrv_open2(bs, filename, flags | BDRV_O_FILE, NULL);
if (ret < 0) {
bdrv_delete(bs);
return ret;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "51d7c00c14550334ec140ce8f40e04ed4c88de57",
"normalized_at": "2026-06-20T05:17:39.101373Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 56