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_002079 | CodeXGLUE Defect Detection | public_dataset | train | 2532 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int pci_dec_21154_init_device(SysBusDevice *dev)
{
UNINState *s;
int pci_mem_config, pci_mem_data;
/* Uninorth bridge */
s = FROM_SYSBUS(UNINState, dev);
// XXX: s = &pci_bridge[2];
pci_mem_config = cpu_register_io_memory(pci_unin_config_read,
... | 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": "4f5e19e6c570459cd524b29b24374f03860f5149",
"normalized_at": "2026-06-20T05:17:38.973045Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005100 | CodeXGLUE Defect Detection | public_dataset | train | 6332 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void qmp_input_end_struct(Visitor *v, Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
qmp_input_pop(qiv, 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": true,
"project": "qemu",
"commit_id": "15c2f669e3fb2bc97f7b42d1871f595c0ac24af8",
"normalized_at": "2026-06-20T05:17:39.053955Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009346 | CodeXGLUE Defect Detection | public_dataset | train | 11630 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int block_crypto_create_generic(QCryptoBlockFormat format,
const char *filename,
QemuOpts *opts,
Error **errp)
{
int ret = -EINVAL;
QCryptoBlockCreateOptions *create_opts = 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": "306a06e5f766acaf26b71397a5692c65b65a61c7",
"normalized_at": "2026-06-20T05:17:39.160530Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007917 | CodeXGLUE Defect Detection | public_dataset | train | 9857 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int v4l2_set_parameters(AVFormatContext *s1)
{
struct video_data *s = s1->priv_data;
struct v4l2_standard standard = { 0 };
struct v4l2_streamparm streamparm = { 0 };
struct v4l2_fract *tpf = &streamparm.parm.capture.timeperframe;
AVRational framerate_q = { 0 };
int i, 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": "FFmpeg",
"commit_id": "514216d8a928cf80980ca8dc5daea46e9d41cad9",
"normalized_at": "2026-06-20T05:17:39.124927Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000409 | CodeXGLUE Defect Detection | public_dataset | train | 508 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | uint32_t ldl_be_phys(target_phys_addr_t addr)
{
return ldl_phys_internal(addr, DEVICE_BIG_ENDIAN);
}
| 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": "a8170e5e97ad17ca169c64ba87ae2f53850dab4c",
"normalized_at": "2026-06-20T05:17:38.927659Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004836 | CodeXGLUE Defect Detection | public_dataset | train | 6000 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void ehci_frame_timer(void *opaque)
{
EHCIState *ehci = opaque;
int need_timer = 0;
int64_t expire_time, t_now;
uint64_t ns_elapsed;
uint64_t uframes, skipped_uframes;
int i;
t_now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
ns_elapsed = t_now - ehci->last_run_ns;
ufr... | 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": "3bfecee2cb71f21cd39d6183f18b446c01917573",
"normalized_at": "2026-06-20T05:17:39.046832Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020425 | CodeXGLUE Defect Detection | public_dataset | train | 25533 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int planarRgb16ToRgb16Wrapper(SwsContext *c, const uint8_t *src[],
int srcStride[], int srcSliceY, int srcSliceH,
uint8_t *dst[], int dstStride[])
{
const uint16_t *src102[] = { (uint16_t *)src[1], (uint16_t *)src[0], (uint16_t *)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": "FFmpeg",
"commit_id": "7800b09ece52490dda4c46fbd8e93f92e8438428",
"normalized_at": "2026-06-20T05:17:39.452225Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000361 | OWASP Benchmark Python | public_dataset | processed | 361 | python | generic | security_review | CWE-22 | A01: Broken Access Control | medium | false | Path Traversal | '''
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-22"
] | {
"raw_path": "testcode/BenchmarkTest00361.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.696342Z",
"name_fixed_at": "2026-06-20T05:22:49.831455Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004635 | CodeXGLUE Defect Detection | public_dataset | train | 5738 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
int64_t bytes, CoroutineEntry co_entry,
BdrvRequestFlags flags)
{
AioContext *aio_context;
QEMUIOVector qiov;
struct iovec iov;
Coroutine *co;
BlkRwCo rwco;
iov = (struct iovec) {... | 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": "0b8b8753e4d94901627b3e86431230f2319215c4",
"normalized_at": "2026-06-20T05:17:39.041740Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009635 | CodeXGLUE Defect Detection | public_dataset | train | 12001 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static inline int cris_bound_b(int v, int b)
{
int r = v;
asm ("bound.b\t%1, %0\n" : "+r" (r) : "ri" (b));
return 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": true,
"project": "qemu",
"commit_id": "21ce148c7ec71ee32834061355a5ecfd1a11f90f",
"normalized_at": "2026-06-20T05:17:39.167186Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009166 | CodeXGLUE Defect Detection | public_dataset | train | 11405 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int nut_read_packet(AVFormatContext *s, AVPacket *pkt)
{
NUTContext *nut = s->priv_data;
StreamContext *stream;
ByteIOContext *bc = &s->pb;
int size, frame_code, flags, size_mul, size_lsb, stream_id;
int key_frame = 0;
int frame_type= 0;
int64_t pts = 0;
const int64_t fra... | 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": "465e1dadbef7596a3eb87089a66bb4ecdc26d3c4",
"normalized_at": "2026-06-20T05:17:39.155127Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004979 | CodeXGLUE Defect Detection | public_dataset | train | 6181 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int proxy_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
const char *name)
{
int retval;
V9fsString xname;
v9fs_string_init(&xname);
v9fs_string_sprintf(&xname, "%s", name);
retval = v9fs_request(ctx->private, T_LREMOVEXATTR, NULL, "ss",
... | 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": "494a8ebe713055d3946183f4b395f85a18b43e9e",
"normalized_at": "2026-06-20T05:17:39.050054Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011548 | CodeXGLUE Defect Detection | public_dataset | train | 14374 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int vc9_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
VC9Context *v = avctx->priv_data;
MpegEncContext *s = &v->s;
int ret = FRAME_SKIPED, len, start_code;
AVFrame *pict = data;
uin... | 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": "7cc84d241ba6ef8e27e4d057176a4ad385ad3d59",
"normalized_at": "2026-06-20T05:17:39.217594Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015422 | CodeXGLUE Defect Detection | public_dataset | train | 19279 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | main (void)
{
struct timeval t_m = {0, 0};
struct timezone t_z = {0, 0};
struct timeval t_m1 = {0, 0};
int i;
if (gettimeofday (&t_m, &t_z) != 0)
err ("gettimeofday");
for (i = 1; i < 10000; i++)
if (gettimeofday (&t_m1, NULL) != 0)
err ("gettimeofday 1");
else
if (t_... | 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": "85b3ed1db5e50b66016ef59ca2afce10e753cbc6",
"normalized_at": "2026-06-20T05:17:39.315309Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002216 | CodeXGLUE Defect Detection | public_dataset | train | 2703 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int net_dump_init(NetClientState *peer, const char *device,
const char *name, const char *filename, int len)
{
struct pcap_file_hdr hdr;
NetClientState *nc;
DumpState *s;
struct tm tm;
int fd;
fd = open(filename, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, ... | 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": "3791f83ca999edc2d11eb2006ccc1091cd712c15",
"normalized_at": "2026-06-20T05:17:38.977956Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015744 | CodeXGLUE Defect Detection | public_dataset | train | 19673 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int multiwrite_f(int argc, char **argv)
{
struct timeval t1, t2;
int Cflag = 0, qflag = 0;
int c, cnt;
char **buf;
int64_t offset, first_offset = 0;
/* Some compilers get confused and warn if this is not initialized. */
int total = 0;
int nr_iov;
int nr_reqs;
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": "qemu",
"commit_id": "67403dbba76fb294fb3a2317227f4b77037145cc",
"normalized_at": "2026-06-20T05:17:39.324081Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019946 | CodeXGLUE Defect Detection | public_dataset | train | 24949 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void vp7_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
{
int i, a1, b1, c1, d1;
int16_t tmp[16];
for (i = 0; i < 4; i++) {
a1 = (block[i * 4 + 0] + block[i * 4 + 2]) * 23170;
b1 = (block[i * 4 + 0] - block[i * 4 + 2]) * 23170;
c1 = block[i * 4 + 1] * 1... | 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": "8824b7370a9fb72f9c699c3751a5ceb56e0cc41d",
"normalized_at": "2026-06-20T05:17:39.440965Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008919 | CodeXGLUE Defect Detection | public_dataset | train | 11104 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
{
int bin, band, ch, band_end;
bin = s->start_freq[CPL_CH];
for (band = 0; band < s->num_cpl_bands; band++) {
band_end = bin + s->cpl_band_sizes[band];
for (; bin < band_end; bin++) {
for (ch = 1; ch <= s->fbw_ch... | 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": "3b6c5ad2f67cc8eeeec89fb9d497ec79c1f3948a",
"normalized_at": "2026-06-20T05:17:39.148677Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019630 | CodeXGLUE Defect Detection | public_dataset | train | 24529 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int asf_read_simple_index(AVFormatContext *s, const GUIDParseTable *g)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st = NULL;
uint64_t interval; // index entry time interval in 100 ns units, usually it's 1s
uint32_t pkt_num, nb_entries;
int32_t prev_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": "FFmpeg",
"commit_id": "cd7a2e1502f174c725c0de82711d2c7649057574",
"normalized_at": "2026-06-20T05:17:39.432423Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004944 | CodeXGLUE Defect Detection | public_dataset | train | 6139 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int ffat_close_decoder(AVCodecContext *avctx)
{
ATDecodeContext *at = avctx->priv_data;
if (at->converter)
AudioConverterDispose(at->converter);
av_packet_unref(&at->new_in_pkt);
av_packet_unref(&at->in_pkt);
av_free(at->decoded_data);
av_free(at->extradata);
... | 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": "f4e593f7b51f7cb30986186c187cff939c82d86d",
"normalized_at": "2026-06-20T05:17:39.049165Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009122 | CodeXGLUE Defect Detection | public_dataset | train | 11348 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void h264_free_context(PayloadContext *data)
{
#ifdef DEBUG
int ii;
for (ii = 0; ii < 32; ii++) {
if (data->packet_types_received[ii])
av_log(NULL, AV_LOG_DEBUG, "Received %d packets of type %d\n",
data->packet_types_received[ii], ii);
}
#endif
... | 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": "5a571d324129ce367584ad9d92aae1d286f389a2",
"normalized_at": "2026-06-20T05:17:39.154101Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020937 | CodeXGLUE Defect Detection | public_dataset | train | 26169 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static inline void RENAME(yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst,
long width, long height,
long lumStride, long chromStride, long dstStride)
{
//FIXME interpolate chroma
RENAME(yuvPl... | 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": "d1adad3cca407f493c3637e20ecd4f7124e69212",
"normalized_at": "2026-06-20T05:17:39.463814Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002597 | CodeXGLUE Defect Detection | public_dataset | train | 3157 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void serial_reset(void *opaque)
{
SerialState *s = opaque;
s->divider = 0;
s->rbr = 0;
s->ier = 0;
s->iir = UART_IIR_NO_INT;
s->lcr = 0;
s->mcr = 0;
s->lsr = UART_LSR_TEMT | UART_LSR_THRE;
s->msr = UART_MSR_DCD | UART_MSR_DSR | UART_MSR_CTS;
s->scr = 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": "81174dae3f9189519cd60c7b79e91c291b021bbe",
"normalized_at": "2026-06-20T05:17:38.988747Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019232 | CodeXGLUE Defect Detection | public_dataset | train | 24019 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MatroskaMuxContext *mkv = s->priv_data;
int codec_type = s->streams[pkt->stream_index]->codec->codec_type;
int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
int cluster_size;
int cluster_size_limit;
int64_... | 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": "98308bd44face14ea3142b501d16226eec23b75a",
"normalized_at": "2026-06-20T05:17:39.420446Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021553 | CodeXGLUE Defect Detection | public_dataset | train | 26943 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void openpic_cpu_write_internal(void *opaque, hwaddr addr,
uint32_t val, int idx)
{
openpic_t *opp = opaque;
IRQ_src_t *src;
IRQ_dst_t *dst;
int s_IRQ, n_IRQ;
DPRINTF("%s: cpu %d addr " TARGET_FMT_plx " <= %08x\n", __func__, idx,
ad... | 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": "5861a33898bbddfd1a80c2e202cb9352e3b1ba62",
"normalized_at": "2026-06-20T05:17:39.484112Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016588 | CodeXGLUE Defect Detection | public_dataset | train | 20731 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void tftp_handle_rrq(struct tftp_t *tp, int pktlen)
{
struct tftp_session *spt;
int s, k, n;
u_int8_t *src, *dst;
s = tftp_session_allocate(tp);
if (s < 0) {
return;
}
spt = &tftp_sessions[s];
src = tp->x.tp_buf;
dst = spt->filename;
n = pktlen - ((uint8_t *)&tp->x.tp_... | 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": "f8e3cbd3b5d1c76ec295cfc8858fd696188c270d",
"normalized_at": "2026-06-20T05:17:39.346684Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001840 | CodeXGLUE Defect Detection | public_dataset | train | 2244 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int parse_uint32(DeviceState *dev, Property *prop, const char *str)
{
uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
const char *fmt;
/* accept both hex and decimal */
fmt = strncasecmp(str, "0x",2) == 0 ? "%" PRIx32 : "%" PRIu32;
if (sscanf(str, fmt, ptr) != 1)
return -EINVAL... | 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": "449041d4db1f82f281fe097e832f07cd9ee1e864",
"normalized_at": "2026-06-20T05:17:38.966685Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019797 | CodeXGLUE Defect Detection | public_dataset | train | 24760 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | yuv2mono_1_c_template(SwsContext *c, const uint16_t *buf0,
const uint16_t *ubuf0, const uint16_t *ubuf1,
const uint16_t *vbuf0, const uint16_t *vbuf1,
const uint16_t *abuf0, uint8_t *dest, int dstW,
int uvalpha, enum PixelFormat... | 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": "13a099799e89a76eb921ca452e1b04a7a28a9855",
"normalized_at": "2026-06-20T05:17:39.437416Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000020 | OWASP Benchmark Python | public_dataset | processed | 20 | 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/BenchmarkTest00020.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.681157Z",
"name_fixed_at": "2026-06-20T05:22:49.825052Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021507 | CodeXGLUE Defect Detection | public_dataset | train | 26889 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void qemu_clock_unregister_reset_notifier(QEMUClockType type,
Notifier *notifier)
{
notifier_remove(notifier);
}
| 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": "c2b38b277a7882a592f4f2ec955084b2b756daaa",
"normalized_at": "2026-06-20T05:17:39.482914Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001134 | CodeXGLUE Defect Detection | public_dataset | train | 1392 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void vfio_disable_interrupts(VFIOPCIDevice *vdev)
{
switch (vdev->interrupt) {
case VFIO_INT_INTx:
vfio_disable_intx(vdev);
break;
case VFIO_INT_MSI:
vfio_disable_msi(vdev);
break;
case VFIO_INT_MSIX:
vfio_disable_msix(vdev);
break;
... | 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": "b3e27c3aee8f5a96debfe0346e9c0e3a641a8516",
"normalized_at": "2026-06-20T05:17:38.948408Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006498 | CodeXGLUE Defect Detection | public_dataset | train | 8092 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int adpcm_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
ADPCMContext *c = avctx->priv_data;
ADPCMChannelStatus *cs;
int n, m, channel, i;
int block_predictor[2];
short *samples;
uint8_t *src;
int st; /* stereo */
... | 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": "5c69a4fd682ae479f0921361b7953e6163bd3064",
"normalized_at": "2026-06-20T05:17:39.089533Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011727 | CodeXGLUE Defect Detection | public_dataset | train | 14592 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static abi_long do_accept(int fd, abi_ulong target_addr,
abi_ulong target_addrlen_addr)
{
socklen_t addrlen;
void *addr;
abi_long ret;
if (get_user_u32(addrlen, target_addrlen_addr))
return -TARGET_EFAULT;
if (addrlen < 0)
return -TARGET_EINVAL;... | 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": "917507b01efea8017bfcb4188ac696612e363e72",
"normalized_at": "2026-06-20T05:17:39.222530Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011250 | CodeXGLUE Defect Detection | public_dataset | train | 14006 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void nvdimm_realize(PCDIMMDevice *dimm, Error **errp)
{
MemoryRegion *mr = host_memory_backend_get_memory(dimm->hostmem, errp);
NVDIMMDevice *nvdimm = NVDIMM(dimm);
uint64_t align, pmem_size, size = memory_region_size(mr);
align = memory_region_get_alignment(mr);
pmem_size = 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": true,
"project": "qemu",
"commit_id": "cdcab9d94101a6dd9ac8136c6f2cd15b6a997896",
"normalized_at": "2026-06-20T05:17:39.209982Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004091 | CodeXGLUE Defect Detection | public_dataset | train | 5047 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int local_set_mapped_file_attrat(int dirfd, const char *name,
FsCred *credp)
{
FILE *fp;
int ret;
char buf[ATTR_MAX];
int uid = -1, gid = -1, mode = -1, rdev = -1;
int map_dirfd;
ret = mkdirat(dirfd, VIRTFS_META_DIR, 0700);
if (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": "81ffbf5ab1458e357a761f1272105a55829b351e",
"normalized_at": "2026-06-20T05:17:39.028268Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014072 | CodeXGLUE Defect Detection | public_dataset | train | 17550 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_celp_lp_synthesis_filter(int16_t *out, const int16_t *filter_coeffs,
const int16_t *in, int buffer_length,
int filter_length, int stop_on_overflow,
int shift, int rounder)
{
int i,n;
for (n = 0; n < 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": "fb75ad79cb8a00d42857b252e0049a0bbe90da66",
"normalized_at": "2026-06-20T05:17:39.279766Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019622 | CodeXGLUE Defect Detection | public_dataset | train | 24520 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void colored_fputs(int level, int tint, const char *str)
{
if (!*str)
return;
if (use_color < 0)
check_color_terminal();
#if defined(_WIN32) && !defined(__MINGW32CE__) && HAVE_SETCONSOLETEXTATTRIBUTE
if (use_color && level != AV_LOG_INFO/8)
SetConsoleTextAttribute(... | 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": "7ac2f7e413051aa6ff735a8b9c47ca06dc4607d9",
"normalized_at": "2026-06-20T05:17:39.432294Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012532 | CodeXGLUE Defect Detection | public_dataset | train | 15606 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void scsi_block_class_initfn(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
sc->realize = scsi_block_realize;
sc->unrealize = scsi_unrealize;
sc->alloc_req = scsi_block_new_request;
sc->parse_cdb... | 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": "fb7b5c0df6e3c501973ce4d57eb2b1d4344a519d",
"normalized_at": "2026-06-20T05:17:39.241934Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012169 | CodeXGLUE Defect Detection | public_dataset | train | 15153 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int bdrv_pdiscard(BlockDriverState *bs, int64_t offset, int count)
{
Coroutine *co;
DiscardCo rwco = {
.bs = bs,
.offset = offset,
.count = count,
.ret = NOT_DONE,
};
if (qemu_in_coroutine()) {
/* Fast-path if already in coroutine context */
b... | 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": "e92f0e1910f0655a0edd8d87c5a7262d36517a89",
"normalized_at": "2026-06-20T05:17:39.232352Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021651 | CodeXGLUE Defect Detection | public_dataset | train | 27068 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int raw_close_decoder(AVCodecContext *avctx)
{
RawVideoContext *context = avctx->priv_data;
av_freep(&context->buffer);
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": "6184fa2067ccf88e68a7009442cf01440e59d99c",
"normalized_at": "2026-06-20T05:17:39.486970Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004855 | CodeXGLUE Defect Detection | public_dataset | train | 6023 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void decode_delta_j(uint8_t *dst,
const uint8_t *buf, const uint8_t *buf_end,
int w, int h, int bpp, int dst_size)
{
int32_t pitch;
uint8_t *end = dst + dst_size, *ptr;
uint32_t type, flag, cols, groups, rows, bytes;
uint32_t offset;
... | 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": "5350e0fc97a50de7cb387d1d5f07fe25c9c4a935",
"normalized_at": "2026-06-20T05:17:39.047174Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004086 | CodeXGLUE Defect Detection | public_dataset | train | 5040 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void sm501_init(MemoryRegion *address_space_mem, uint32_t base,
uint32_t local_mem_bytes, qemu_irq irq, CharDriverState *chr)
{
SM501State * s;
DeviceState *dev;
MemoryRegion *sm501_system_config = g_new(MemoryRegion, 1);
MemoryRegion *sm501_disp_ctrl = g_new(MemoryRegion, 1);
... | 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": "2c62f08ddbf3fa80dc7202eb9a2ea60ae44e2cc5",
"normalized_at": "2026-06-20T05:17:39.028192Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003826 | CodeXGLUE Defect Detection | public_dataset | train | 4712 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int vnc_display_connect(VncDisplay *vd,
SocketAddress **saddr,
size_t nsaddr,
SocketAddress **wsaddr,
size_t nwsaddr,
Error **errp)
{
/* connect to... | 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": "dfd100f242370886bb6732f70f1f7cbd8eb9fedc",
"normalized_at": "2026-06-20T05:17:39.021767Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003258 | CodeXGLUE Defect Detection | public_dataset | train | 3991 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int dxva2_device_create9ex(AVHWDeviceContext *ctx, UINT adapter)
{
DXVA2DevicePriv *priv = ctx->user_opaque;
D3DPRESENT_PARAMETERS d3dpp = dxva2_present_params;
D3DDISPLAYMODEEX modeex = {0};
IDirect3D9Ex *d3d9ex = NULL;
IDirect3DDevice9Ex *exdev = NULL;
HRESULT hr;
pDirect3DC... | 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": "59b126f92225316e0cd77bb952d630553801dc85",
"normalized_at": "2026-06-20T05:17:39.007226Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006773 | CodeXGLUE Defect Detection | public_dataset | train | 8437 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int mode_sense_page(SCSIRequest *req, int page, uint8_t *p)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
BlockDriverState *bdrv = s->bs;
int cylinders, heads, secs;
switch (page) {
case 4: /* Rigid disk device geometry page. */
p[0] = 4;
p[1] = 0x16... | 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": "282ab04eb1e6f4faa6c5d2827e3209c4a1eec40e",
"normalized_at": "2026-06-20T05:17:39.096301Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005214 | CodeXGLUE Defect Detection | public_dataset | train | 6466 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void adb_kbd_realizefn(DeviceState *dev, Error **errp)
{
ADBKeyboardClass *akc = ADB_KEYBOARD_GET_CLASS(dev);
akc->parent_realize(dev, errp);
qemu_input_handler_register(dev, &adb_keyboard_handler);
}
| 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": "77cb0f5aafc8e6d0c6d3c339f381c9b7921648e0",
"normalized_at": "2026-06-20T05:17:39.056791Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006152 | CodeXGLUE Defect Detection | public_dataset | train | 7646 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int stdio_get_fd(void *opaque)
{
QEMUFileStdio *s = opaque;
return fileno(s->stdio_file);
}
| 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": "60fe637bf0e4d7989e21e50f52526444765c63b4",
"normalized_at": "2026-06-20T05:17:39.080836Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015624 | CodeXGLUE Defect Detection | public_dataset | train | 19522 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void ioport_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
PCIQXLDevice *d = opaque;
uint32_t io_port = addr;
qxl_async_io async = QXL_SYNC;
#if SPICE_INTERFACE_QXL_MINOR >= 1
uint32_t orig_io_port = io_port;
#endif
switch (io_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": "qemu",
"commit_id": "4295e15aa730a95003a3639d6dad2eb1e65a59e2",
"normalized_at": "2026-06-20T05:17:39.320425Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004981 | CodeXGLUE Defect Detection | public_dataset | train | 6184 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | ssize_t nbd_receive_reply(int csock, struct nbd_reply *reply)
{
uint8_t buf[NBD_REPLY_SIZE];
uint32_t magic;
if (read_sync(csock, buf, sizeof(buf)) != sizeof(buf)) {
LOG("read failed");
errno = EINVAL;
return -1;
}
/* Reply
[ 0 .. 3] magic (NBD_REPL... | 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": "185b43386ad999c80bdc58e41b87f05e5b3e8463",
"normalized_at": "2026-06-20T05:17:39.050084Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010619 | CodeXGLUE Defect Detection | public_dataset | train | 13238 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static always_inline int get_segment (CPUState *env, mmu_ctx_t *ctx,
target_ulong eaddr, int rw, int type)
{
target_phys_addr_t sdr, hash, mask, sdr_mask, htab_mask;
target_ulong sr, vsid, vsid_mask, pgidx, page_mask;
#if defined(TARGET_PPC64)
int attr;
#endif
... | 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": "6f2d8978728c48ca46f5c01835438508aace5c64",
"normalized_at": "2026-06-20T05:17:39.193021Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021008 | CodeXGLUE Defect Detection | public_dataset | train | 26262 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int link_filter_inouts(AVFilterContext *filt_ctx,
AVFilterInOut **curr_inputs,
AVFilterInOut **open_inputs, void *log_ctx)
{
int pad, ret;
for (pad = 0; pad < filt_ctx->input_count; pad++) {
AVFilterInOut *p = *curr_inputs;
... | 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": "aff01de6415f1ba022f1a58e354ad6e4d0796e97",
"normalized_at": "2026-06-20T05:17:39.466288Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002973 | CodeXGLUE Defect Detection | public_dataset | train | 3642 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void cpu_request_exit(void *opaque, int irq, int level)
{
CPUState *cpu = current_cpu;
if (cpu && level) {
cpu_exit(cpu);
}
}
| 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": "5039d6e23586fe6bbedc5e4fe302b48a66890ade",
"normalized_at": "2026-06-20T05:17:38.999757Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019510 | CodeXGLUE Defect Detection | public_dataset | train | 24381 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int kvm_log_stop(target_phys_addr_t phys_addr, target_phys_addr_t end_addr)
{
return kvm_dirty_pages_log_change(phys_addr, end_addr,
0,
KVM_MEM_LOG_DIRTY_PAGES);
}
| 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": "d3f8d37fe2d0c24ec8bac9c94d5b0e2dc09c0d2a",
"normalized_at": "2026-06-20T05:17:39.429454Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013984 | CodeXGLUE Defect Detection | public_dataset | train | 17442 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void gem_write(void *opaque, hwaddr offset, uint64_t val,
unsigned size)
{
CadenceGEMState *s = (CadenceGEMState *)opaque;
uint32_t readonly;
int i;
DB_PRINT("offset: 0x%04x write: 0x%08x ", (unsigned)offset, (unsigned)val);
offset >>= 2;
/* Squash bits which are read ... | 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": "79b2ac8f28748b09816d09bd62a2b49ddc01ebeb",
"normalized_at": "2026-06-20T05:17:39.277299Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010626 | CodeXGLUE Defect Detection | public_dataset | train | 13245 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int qemu_rdma_exchange_recv(RDMAContext *rdma, RDMAControlHeader *head,
int expecting)
{
RDMAControlHeader ready = {
.len = 0,
.type = RDMA_CONTROL_READY,
.repeat = 1,
... | 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": "60fe637bf0e4d7989e21e50f52526444765c63b4",
"normalized_at": "2026-06-20T05:17:39.193272Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020558 | CodeXGLUE Defect Detection | public_dataset | train | 25701 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int scsi_disk_emulate_mode_sense(SCSIDiskReq *r, uint8_t *outbuf)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
uint64_t nb_sectors;
bool dbd;
int page, buflen, ret, page_control;
uint8_t *p;
uint8_t dev_specific_param;
dbd = (r->req.cmd.buf[1] & 0x8) != 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": "4be746345f13e99e468c60acbd3a355e8183e3ce",
"normalized_at": "2026-06-20T05:17:39.455071Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000850 | OWASP Benchmark Python | public_dataset | processed | 850 | python | generic | security_review | CWE-611 | A05: Security Misconfiguration | high | false | XML External Entity 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-611"
] | {
"raw_path": "testcode/BenchmarkTest00850.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.717997Z",
"name_fixed_at": "2026-06-20T05:22:49.839340Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011023 | CodeXGLUE Defect Detection | public_dataset | train | 13741 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void update_irq(struct HPETTimer *timer)
{
qemu_irq irq;
int route;
if (timer->tn <= 1 && hpet_in_legacy_mode()) {
/* if LegacyReplacementRoute bit is set, HPET specification requires
* timer0 be routed to IRQ0 in NON-APIC or IRQ2 in the I/O APIC,
* timer1 be routed... | 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": "27bb0b2d6f80f058bdb6fcc8fcdfa69b0c8a6d71",
"normalized_at": "2026-06-20T05:17:39.203048Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001784 | CodeXGLUE Defect Detection | public_dataset | train | 2177 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int mov_read_udta(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
{
uint64_t end = url_ftell(pb) + atom.size;
while (url_ftell(pb) + 8 < end) {
uint32_t tag_size = get_be32(pb);
uint32_t tag = get_le32(pb);
uint64_t next = url_ftell(pb) + tag_size - 8;
... | 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": "4e240985d8b856e62e4e0377283138cf51cc398e",
"normalized_at": "2026-06-20T05:17:38.965454Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018707 | CodeXGLUE Defect Detection | public_dataset | train | 23367 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int get_char(GDBState *s)
{
uint8_t ch;
int ret;
for(;;) {
ret = qemu_recv(s->fd, &ch, 1, 0);
if (ret < 0) {
if (errno == ECONNRESET)
s->fd = -1;
if (errno != EINTR && errno != EAGAIN)
return -1;
} else if (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": "qemu",
"commit_id": "5819e3e072f41cbf81ad80d822a5c468a91f54e0",
"normalized_at": "2026-06-20T05:17:39.406311Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006935 | CodeXGLUE Defect Detection | public_dataset | train | 8631 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void rtas_ibm_slot_error_detail(PowerPCCPU *cpu,
sPAPREnvironment *spapr,
uint32_t token, uint32_t nargs,
target_ulong args, uint32_t nret,
target_ulong ... | 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": "46c5874e9cd752ed8ded31af03472edd8fc3efc1",
"normalized_at": "2026-06-20T05:17:39.100587Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003876 | CodeXGLUE Defect Detection | public_dataset | train | 4776 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int iv_decode_frame(AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
Indeo3DecodeContext *s = avctx->priv_data;
unsigned int image_width, image_height,
chroma_width, chroma_height;
unsigned long flags, cb_offset, data_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": true,
"project": "FFmpeg",
"commit_id": "16c831851384ab59e73579fdd9913fbff3c0284a",
"normalized_at": "2026-06-20T05:17:39.022945Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007742 | CodeXGLUE Defect Detection | public_dataset | train | 9624 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int usbredir_handle_data(USBDevice *udev, USBPacket *p)
{
USBRedirDevice *dev = DO_UPCAST(USBRedirDevice, dev, udev);
uint8_t ep;
ep = p->devep;
if (p->pid == USB_TOKEN_IN) {
ep |= USB_DIR_IN;
}
switch (dev->endpoint[EP2I(ep)].type) {
case USB_ENDPOINT_XFER_CONTRO... | 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": "079d0b7f1eedcc634c371fe05b617fdc55c8b762",
"normalized_at": "2026-06-20T05:17:39.120670Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018963 | CodeXGLUE Defect Detection | public_dataset | train | 23691 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void timestamp_put(QDict *qdict)
{
int err;
QObject *obj;
qemu_timeval tv;
err = qemu_gettimeofday(&tv);
if (err < 0)
return;
obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
"'microseconds': %" PRId64 " }",
... | 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": "ba14414174b72fa231997243a9650feaa520d054",
"normalized_at": "2026-06-20T05:17:39.413100Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008347 | CodeXGLUE Defect Detection | public_dataset | train | 10392 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static bool addrrange_intersects(AddrRange r1, AddrRange r2)
{
return (r1.start >= r2.start && r1.start < r2.start + r2.size)
|| (r2.start >= r1.start && r2.start < r1.start + r1.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": true,
"project": "qemu",
"commit_id": "d2963631dd54ddf0f46c151b7e3013e39bb78d3b",
"normalized_at": "2026-06-20T05:17:39.134172Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000621 | CodeXGLUE Defect Detection | public_dataset | train | 765 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | theora_header (AVFormatContext * s, int idx)
{
struct ogg *ogg = s->priv_data;
struct ogg_stream *os = ogg->streams + idx;
AVStream *st = s->streams[idx];
struct theora_params *thp = os->private;
int cds = st->codec->extradata_size + os->psize + 2;
uint8_t *cdp;
if(!(os->buf[os->ps... | 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": "11d058b7b351db8fb73104c847c5cc43b91735c6",
"normalized_at": "2026-06-20T05:17:38.932367Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011926 | CodeXGLUE Defect Detection | public_dataset | train | 14845 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
{
BDRVQcow2State *s = bs->opaque;
int flags = s->flags;
QCryptoCipher *cipher = NULL;
QDict *options;
Error *local_err = NULL;
int ret;
/*
* Backing files are read-only which makes all of their metadata im... | 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": "c9e9e9c66cee9932fb28a41a4659aa421a7a3f78",
"normalized_at": "2026-06-20T05:17:39.226893Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007336 | CodeXGLUE Defect Detection | public_dataset | train | 9113 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void decodeplane8(uint8_t *dst, const uint8_t *const buf, int buf_size, int bps, int plane)
{
GetBitContext gb;
int i, b;
init_get_bits(&gb, buf, buf_size * 8);
for(i = 0; i < (buf_size * 8 + bps - 1) / bps; i++) {
for (b = 0; b < bps; b++) {
dst[ i*bps + b ] |= 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": "473147bed01c0c6c82d85fd79d3e1c1d65542663",
"normalized_at": "2026-06-20T05:17:39.110904Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000908 | OWASP Benchmark Python | public_dataset | processed | 908 | python | generic | security_review | CWE-22 | A01: Broken Access Control | medium | false | Path Traversal | '''
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-22"
] | {
"raw_path": "testcode/BenchmarkTest00908.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.720697Z",
"name_fixed_at": "2026-06-20T05:22:49.839984Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015510 | CodeXGLUE Defect Detection | public_dataset | train | 19384 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int usb_bt_handle_data(USBDevice *dev, USBPacket *p)
{
struct USBBtState *s = (struct USBBtState *) dev->opaque;
int ret = 0;
if (!s->config)
goto fail;
switch (p->pid) {
case USB_TOKEN_IN:
switch (p->devep & 0xf) {
case USB_EVT_EP:
ret = usb_... | 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": "079d0b7f1eedcc634c371fe05b617fdc55c8b762",
"normalized_at": "2026-06-20T05:17:39.317088Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007428 | CodeXGLUE Defect Detection | public_dataset | train | 9230 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length){
const uint8_t *end= buffer+length;
#if !CONFIG_SMALL
if(!ctx[256])
while(buffer<end-3){
crc ^= le2me_32(*(const uint32_t*)buffer); buffer+=4;
crc = ctx[3*256 + ( crc &0xFF)]
... | 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": "d468ff0fdfdd3ff8f54adea3dd1ef4b94cb8538d",
"normalized_at": "2026-06-20T05:17:39.113102Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016308 | CodeXGLUE Defect Detection | public_dataset | train | 20378 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int hdev_create(const char *filename, QEMUOptionParameter *options)
{
int fd;
int ret = 0;
struct stat stat_buf;
int64_t total_size = 0;
/* Read out options */
while (options && options->name) {
if (!strcmp(options->name, "size")) {
total_size = options->val... | 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": "4099df586a0f16522383c4e4a9613e7c2dcd2491",
"normalized_at": "2026-06-20T05:17:39.339709Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012560 | CodeXGLUE Defect Detection | public_dataset | train | 15640 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static ssize_t v9fs_synth_llistxattr(FsContext *ctx, V9fsPath *path,
void *value, size_t size)
{
errno = ENOTSUP;
return -1;
}
| 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": "364031f17932814484657e5551ba12957d993d7e",
"normalized_at": "2026-06-20T05:17:39.242528Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007512 | CodeXGLUE Defect Detection | public_dataset | train | 9329 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int vmdk_create_extent(const char *filename, int64_t filesize,
bool flat, bool compress, bool zeroed_grain,
Error **errp)
{
int ret, i;
BlockDriverState *bs = NULL;
VMDK4Header header;
Error *local_err;
uint32_t tmp, magic, g... | 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": "39a611a3e035e148257af314a522a6cd169c2d0e",
"normalized_at": "2026-06-20T05:17:39.115062Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005580 | CodeXGLUE Defect Detection | public_dataset | train | 6929 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void sdl_mouse_warp(int x, int y, int on)
{
if (on) {
if (!guest_cursor)
sdl_show_cursor();
if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
SDL_SetCursor(guest_sprite);
SDL_WarpMouse(x, y);
}
} else if (gui_grab)
... | 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": "08a2d4c4ffde60e48819449f461274c43ad6e2d3",
"normalized_at": "2026-06-20T05:17:39.066522Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007466 | CodeXGLUE Defect Detection | public_dataset | train | 9278 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static ssize_t mcf_fec_receive(NetClientState *nc, const uint8_t *buf, size_t size)
{
mcf_fec_state *s = qemu_get_nic_opaque(nc);
mcf_fec_bd bd;
uint32_t flags = 0;
uint32_t addr;
uint32_t crc;
uint32_t buf_addr;
uint8_t *crc_ptr;
unsigned int buf_len;
size_t retsize;
... | 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": "ff1d2ac949dc94d8a0e71fd46939fb69c2ef075b",
"normalized_at": "2026-06-20T05:17:39.113925Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004578 | CodeXGLUE Defect Detection | public_dataset | train | 5668 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
{
int l;
while (size > 0) {
l = IO_BUF_SIZE - f->buf_index;
if (l > size)
l = size;
memcpy(f->buf + f->buf_index, buf, l);
f->buf_index += l;
buf += l;
size -= l;
if (f-... | 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": "871d2f079661323a7645b388eb5ae8d7eeb3117c",
"normalized_at": "2026-06-20T05:17:39.040100Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007279 | CodeXGLUE Defect Detection | public_dataset | train | 9035 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void ncq_cb(void *opaque, int ret)
{
NCQTransferState *ncq_tfs = (NCQTransferState *)opaque;
IDEState *ide_state = &ncq_tfs->drive->port.ifs[0];
if (ret == -ECANCELED) {
return;
}
/* Clear bit for this tag in SActive */
ncq_tfs->drive->port_regs.scr_act &= ~(1 << ncq_tfs... | 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": "4be746345f13e99e468c60acbd3a355e8183e3ce",
"normalized_at": "2026-06-20T05:17:39.109271Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016145 | CodeXGLUE Defect Detection | public_dataset | train | 20177 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static inline void RENAME(uyvytoyv12)(const uint8_t *src, uint8_t *ydst, uint8_t *udst, uint8_t *vdst,
unsigned int width, unsigned int height,
int lumStride, int chromStride, int srcStride)
{
unsigned y;
const unsigned chromWidth= width>>1;
for(y=0; y<height; y+=2)
{
#ifdef HAVE_MMX
asm volatile(
... | 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": "7f526efd17973ec6d2204f7a47b6923e2be31363",
"normalized_at": "2026-06-20T05:17:39.335694Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013784 | CodeXGLUE Defect Detection | public_dataset | train | 17182 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
{
int ret;
/* find supported formats from sub-filters, and merge along links */
if ((ret = query_formats(graph, log_ctx)) < 0)
return ret;
/* Once everything is merged, it's possible that we'll still have
* m... | 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": "125acd215250ead008938266efcacd56743f3a2a",
"normalized_at": "2026-06-20T05:17:39.272401Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001441 | CodeXGLUE Defect Detection | public_dataset | train | 1762 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void test_hash_base64(void)
{
size_t i;
g_assert(qcrypto_init(NULL) == 0);
for (i = 0; i < G_N_ELEMENTS(expected_outputs) ; i++) {
int ret;
char *digest;
ret = qcrypto_hash_base64(i,
INPUT_TEXT,
... | 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": "0c16c056a4f9dec18fdd56feec82a5db9ff3c15e",
"normalized_at": "2026-06-20T05:17:38.956792Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019829 | CodeXGLUE Defect Detection | public_dataset | train | 24800 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
{
uint8_t rps_predict = 0;
int delta_poc;
int k0 = 0;
int k1 = 0;
int k = 0;
int i;
if (rps != sps->st_rps && ... | 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": "2b44dcbc44e99daf9515753e9fd4c2e1ea53a2fa",
"normalized_at": "2026-06-20T05:17:39.438311Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000114 | OWASP Benchmark Python | public_dataset | processed | 114 | 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/BenchmarkTest00114.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.685687Z",
"name_fixed_at": "2026-06-20T05:22:49.826676Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005540 | CodeXGLUE Defect Detection | public_dataset | train | 6883 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int mov_read_wide(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
{
int err;
uint32_t type;
#ifdef DEBUG
print_atom("wide", atom);
debug_indent++;
#endif
if (atom.size < 8)
return 0; /* continue */
if (get_be32(pb) != 0) { /* 0 sized mdat atom... use the 'wide' atom... | 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": "fd6e513ee1dc13174256de8adaeeb2c2691eee95",
"normalized_at": "2026-06-20T05:17:39.065396Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013026 | CodeXGLUE Defect Detection | public_dataset | train | 16218 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void visit_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp)
{
int64_t value;
if (!error_is_set(errp)) {
if (v->type_size) {
v->type_size(v, obj, name, errp);
} else if (v->type_uint64) {
v->type_uint64(v, obj, name, errp);
} else {
... | 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": "297a3646c2947ee64a6d42ca264039732c6218e0",
"normalized_at": "2026-06-20T05:17:39.254775Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016328 | CodeXGLUE Defect Detection | public_dataset | train | 20401 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static always_inline void gen_ext_l(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) {
tcg_gen_... | 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": "a7812ae412311d7d47f8aa85656faadac9d64b56",
"normalized_at": "2026-06-20T05:17:39.340160Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012883 | CodeXGLUE Defect Detection | public_dataset | train | 16037 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
{
AioHandler *node;
bool progress = false;
/*
* We have to walk very carefully in case aio_set_fd_handler is
* called while we're walking.
*/
node = QLIST_FIRST(&ctx->aio_handlers);
while (node) {
Aio... | 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": "b493317d344357f7ac56606246d09b5604e54ab6",
"normalized_at": "2026-06-20T05:17:39.250939Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013118 | CodeXGLUE Defect Detection | public_dataset | train | 16337 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int write_header(FlashSV2Context * s, uint8_t * buf, int buf_size)
{
PutBitContext pb;
int buf_pos, len;
if (buf_size < 5)
return -1;
init_put_bits(&pb, buf, buf_size * 8);
put_bits(&pb, 4, (s->block_width >> 4) - 1);
put_bits(&pb, 12, s->image_width);
put_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": true,
"project": "FFmpeg",
"commit_id": "50833c9f7b4e1922197a8955669f8ab3589c8cef",
"normalized_at": "2026-06-20T05:17:39.256953Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017080 | CodeXGLUE Defect Detection | public_dataset | train | 21340 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void handle_output(VirtIODevice *vdev, VirtQueue *vq)
{
VirtIOSerial *vser;
VirtIOSerialPort *port;
VirtIOSerialPortInfo *info;
vser = DO_UPCAST(VirtIOSerial, vdev, vdev);
port = find_port_by_vq(vser, vq);
info = port ? DO_UPCAST(VirtIOSerialPortInfo, qdev, port->dev.info) : 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": "03ecd2c80a64d030a22fe67cc7a60f24e17ff211",
"normalized_at": "2026-06-20T05:17:39.359698Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004923 | CodeXGLUE Defect Detection | public_dataset | train | 6115 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int bdrv_file_open(BlockDriverState **pbs, const char *filename,
const char *reference, QDict *options, int flags,
Error **errp)
{
BlockDriverState *bs = NULL;
BlockDriver *drv;
const char *drvname;
bool allow_protocol_prefix = false;
Error *local_err = ... | 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": "765003db029ed4660a09807958276e251de84fac",
"normalized_at": "2026-06-20T05:17:39.048783Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001274 | CodeXGLUE Defect Detection | public_dataset | train | 1566 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void test_visitor_in_errors(TestInputVisitorData *data,
const void *unused)
{
TestStruct *p = NULL;
Error *err = NULL;
Visitor *v;
strList *q = NULL;
UserDefTwo *r = NULL;
WrapAlternate *s = NULL;
v = visitor_input_test_init(data, "{ 'inte... | 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:38.952314Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002700 | CodeXGLUE Defect Detection | public_dataset | train | 3299 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void t_gen_cris_dstep(TCGv d, TCGv a, TCGv b)
{
int l1;
l1 = gen_new_label();
/*
* d <<= 1
* if (d >= s)
* d -= s;
*/
tcg_gen_shli_tl(d, a, 1);
tcg_gen_brcond_tl(TCG_COND_LTU, d, b, l1);
tcg_gen_sub_tl(d, d, b);
gen_set_label(l1);
}
| 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": "42a268c241183877192c376d03bd9b6d527407c7",
"normalized_at": "2026-06-20T05:17:38.991458Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013339 | CodeXGLUE Defect Detection | public_dataset | train | 16620 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void dwt_encode97_float(DWTContext *s, float *t)
{
int lev,
w = s->linelen[s->ndeclevels-1][0];
float *line = s->f_linebuf;
line += 5;
for (lev = s->ndeclevels-1; lev >= 0; lev--){
int lh = s->linelen[lev][0],
lv = s->linelen[lev][1],
mh = s->mod... | 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": "1c495b0bf690995c45f79f4f19500921e14ec78a",
"normalized_at": "2026-06-20T05:17:39.261655Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011077 | CodeXGLUE Defect Detection | public_dataset | train | 13805 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | MemoryRegion *address_space_translate(AddressSpace *as, hwaddr addr,
hwaddr *xlat, hwaddr *plen,
bool is_write)
{
IOMMUTLBEntry iotlb;
MemoryRegionSection *section;
MemoryRegion *mr;
hwaddr len = *plen;
for (;;) {
... | 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": "a87f39543a9259f671c5413723311180ee2ad2a8",
"normalized_at": "2026-06-20T05:17:39.205394Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002748 | CodeXGLUE Defect Detection | public_dataset | train | 3360 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void bitband_writew(void *opaque, target_phys_addr_t offset,
uint32_t value)
{
uint32_t addr;
uint16_t mask;
uint16_t v;
addr = bitband_addr(opaque, offset) & ~1;
mask = (1 << ((offset >> 2) & 15));
mask = tswap16(mask);
cpu_physical_memory_read(add... | 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": "a8170e5e97ad17ca169c64ba87ae2f53850dab4c",
"normalized_at": "2026-06-20T05:17:38.992945Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018249 | CodeXGLUE Defect Detection | public_dataset | train | 22790 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data, int size,
int64_t pos, uint64_t cluster_time,
int is_keyframe, int *ptrack, AVPacket **ppkt)
{
int res = 0;
int track;
AVPacket *pkt;
uint8_t *origdata = data;
int16_t block_time;
... | 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": "6bed20f45a484f5709fec4c97a238240161b1797",
"normalized_at": "2026-06-20T05:17:39.394825Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012175 | CodeXGLUE Defect Detection | public_dataset | train | 15160 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_xvid_rate_control_init(MpegEncContext *s){
char *tmp_name;
int fd, i;
xvid_plg_create_t xvid_plg_create = { 0 };
xvid_plugin_2pass2_t xvid_2pass2 = { 0 };
fd=av_tempfile("xvidrc.", &tmp_name, 0, s->avctx);
if (fd == -1) {
av_log(NULL, AV_LOG_ERROR, "Can't create temporar... | 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": "229ccce6cca7748f53cb4b6a8d035ddce5ac6b72",
"normalized_at": "2026-06-20T05:17:39.232441Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000474 | CodeXGLUE Defect Detection | public_dataset | train | 591 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int qcow2_open(BlockDriverState *bs, QDict *options, int flags)
{
BDRVQcowState *s = bs->opaque;
int len, i, ret = 0;
QCowHeader header;
QemuOpts *opts;
Error *local_err = NULL;
uint64_t ext_end;
uint64_t l1_vm_state_index;
ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
... | 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": "69c98726537627e708abb8fcb33e3a2b10e40bf1",
"normalized_at": "2026-06-20T05:17:38.929194Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001935 | CodeXGLUE Defect Detection | public_dataset | train | 2361 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static bool key_is_missing(const BlockInfo *bdev)
{
return (bdev->inserted && bdev->inserted->encryption_key_missing);
}
| 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": "788cf9f8c8cbda53843e060540f3e91a060eb744",
"normalized_at": "2026-06-20T05:17:38.968959Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010826 | CodeXGLUE Defect Detection | public_dataset | train | 13498 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void spr_read_tbl (DisasContext *ctx, int gprn, int sprn)
{
if (use_icount) {
gen_io_start();
}
gen_helper_load_tbl(cpu_gpr[gprn], cpu_env);
if (use_icount) {
gen_io_end();
gen_stop_exception(ctx);
}
}
| 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": "bd79255d2571a3c68820117caf94ea9afe1d527e",
"normalized_at": "2026-06-20T05:17:39.197956Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.