Dataset Viewer
Auto-converted to Parquet
project
stringclasses
788 values
commit_id
stringlengths
6
81
CVE ID
stringlengths
13
16
CWE ID
stringclasses
126 values
func
stringlengths
14
482k
vul
int8
0
1
linux
bcc5364bdcfe131e6379363f089e7b4108d35b70
NOT_APPLICABLE
NOT_APPLICABLE
static void prb_fill_curr_block(char *curr, struct tpacket_kbdq_core *pkc, struct tpacket_block_desc *pbd, unsigned int len) { struct tpacket3_hdr *ppd; ppd = (struct tpacket3_hdr *)curr; ppd->tp_next_offset = TOTAL_PKT_LEN_INCL_ALIGN(len); pkc->prev = curr; pkc->nxt_offset += TOTAL_PKT_LEN_INCL_ALIGN(len); BLOCK_LEN(pbd) += TOTAL_PKT_LEN_INCL_ALIGN(len); BLOCK_NUM_PKTS(pbd) += 1; atomic_inc(&pkc->blk_fill_in_prog); prb_run_all_ft_ops(pkc, ppd); }
0
linux
d3bd7413e0ca40b60cf60d4003246d067cafdeda
NOT_APPLICABLE
NOT_APPLICABLE
static bool reg_is_refcounted_or_null(const struct bpf_reg_state *reg) { return type_is_refcounted_or_null(reg->type); }
0
Chrome
eea3300239f0b53e172a320eb8de59d0bea65f27
NOT_APPLICABLE
NOT_APPLICABLE
void DevToolsUIBindings::FrontendWebContentsObserver::RenderProcessGone( base::TerminationStatus status) { bool crashed = true; switch (status) { case base::TERMINATION_STATUS_ABNORMAL_TERMINATION: case base::TERMINATION_STATUS_PROCESS_WAS_KILLED: #if defined(OS_CHROMEOS) case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM: #endif case base::TERMINATION_STATUS_PROCESS_CRASHED: case base::TERMINATION_STATUS_LAUNCH_FAILED: if (devtools_bindings_->agent_host_.get()) devtools_bindings_->Detach(); break; default: crashed = false; break; } devtools_bindings_->delegate_->RenderProcessGone(crashed); }
0
linux
9aacdd354d197ad64685941b36d28ea20ab88757
NOT_APPLICABLE
NOT_APPLICABLE
static inline void hugetlb_set_vma_policy(struct vm_area_struct *vma, struct inode *inode, pgoff_t index) { }
0
cups
afa80cb2b457bf8d64f775bed307588610476c41
NOT_APPLICABLE
NOT_APPLICABLE
write_file(cupsd_client_t *con, /* I - Client connection */ http_status_t code, /* I - HTTP status */ char *filename, /* I - Filename */ char *type, /* I - File type */ struct stat *filestats) /* O - File information */ { con->file = open(filename, O_RDONLY); cupsdLogClient(con, CUPSD_LOG_DEBUG2, "write_file: code=%d, filename=\"%s\" (%d), type=\"%s\", filestats=%p.", code, filename, con->file, type ? type : "(null)", filestats); if (con->file < 0) return (0); fcntl(con->file, F_SETFD, fcntl(con->file, F_GETFD) | FD_CLOEXEC); con->pipe_pid = 0; con->sent_header = 1; httpClearFields(con->http); httpSetLength(con->http, (size_t)filestats->st_size); httpSetField(con->http, HTTP_FIELD_LAST_MODIFIED, httpGetDateString(filestats->st_mtime)); if (!cupsdSendHeader(con, code, type, CUPSD_AUTH_NONE)) return (0); cupsdAddSelect(httpGetFd(con->http), NULL, (cupsd_selfunc_t)cupsdWriteClient, con); cupsdLogClient(con, CUPSD_LOG_DEBUG, "Sending file."); return (1); }
0
linux-2.6
194b3da873fd334ef183806db751473512af29ce
NOT_APPLICABLE
NOT_APPLICABLE
static int agp_return_size(void) { int current_size; void *temp; temp = agp_bridge->current_size; switch (agp_bridge->driver->size_type) { case U8_APER_SIZE: current_size = A_SIZE_8(temp)->size; break; case U16_APER_SIZE: current_size = A_SIZE_16(temp)->size; break; case U32_APER_SIZE: current_size = A_SIZE_32(temp)->size; break; case LVL2_APER_SIZE: current_size = A_SIZE_LVL2(temp)->size; break; case FIXED_APER_SIZE: current_size = A_SIZE_FIX(temp)->size; break; default: current_size = 0; break; } current_size -= (agp_memory_reserved / (1024*1024)); if (current_size <0) current_size = 0; return current_size; }
0
Chrome
d6cc2749d2f90acc2d92a526c1d2cbebbc101a19
NOT_APPLICABLE
NOT_APPLICABLE
void SyncManager::UpdateEnabledTypes() { DCHECK(thread_checker_.CalledOnValidThread()); data_->UpdateEnabledTypes(); }
0
OpenSC
c246f6f69a749d4f68626b40795a4f69168008f4
NOT_APPLICABLE
NOT_APPLICABLE
static int coolkey_write_binary(sc_card_t *card, unsigned int idx, const u8 *buf, size_t count, unsigned long flags) { SC_FUNC_CALLED(card->ctx, SC_LOG_DEBUG_VERBOSE); LOG_FUNC_RETURN(card->ctx, SC_ERROR_NOT_SUPPORTED); }
0
Chrome
bf6a6765d44b09c64b8c75d749efb84742a250e7
NOT_APPLICABLE
NOT_APPLICABLE
pp::Instance* PDFiumEngine::GetPluginInstance() { return client_->GetPluginInstance(); }
0
libgit2
4ac39c76c0153d1ee6889a0984c39e97731684b2
NOT_APPLICABLE
NOT_APPLICABLE
int git_pkt_buffer_done(git_buf *buf) { return git_buf_puts(buf, pkt_done_str); }
0
rpm
8f4b3c3cab8922a2022b9e47c71f1ecf906077ef
NOT_APPLICABLE
NOT_APPLICABLE
static uint64_t htonll(uint64_t n) { #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ uint32_t *i = (uint32_t*)&n; uint32_t b = i[0]; i[0] = htonl(i[1]); i[1] = htonl(b); #endif return n; }
0
mono
722f9890f09aadfc37ae479e7d946d5fc5ef7b91
NOT_APPLICABLE
NOT_APPLICABLE
static MonoException* mono_thread_execute_interruption (MonoInternalThread *thread) { ensure_synch_cs_set (thread); EnterCriticalSection (thread->synch_cs); /* MonoThread::interruption_requested can only be changed with atomics */ if (InterlockedCompareExchange (&thread->interruption_requested, FALSE, TRUE)) { /* this will consume pending APC calls */ WaitForSingleObjectEx (GetCurrentThread(), 0, TRUE); InterlockedDecrement (&thread_interruption_requested); #ifndef HOST_WIN32 /* Clear the interrupted flag of the thread so it can wait again */ wapi_clear_interruption (); #endif } if ((thread->state & ThreadState_AbortRequested) != 0) { LeaveCriticalSection (thread->synch_cs); if (thread->abort_exc == NULL) { /* * This might be racy, but it has to be called outside the lock * since it calls managed code. */ MONO_OBJECT_SETREF (thread, abort_exc, mono_get_exception_thread_abort ()); } return thread->abort_exc; } else if ((thread->state & ThreadState_SuspendRequested) != 0) { thread->state &= ~ThreadState_SuspendRequested; thread->state |= ThreadState_Suspended; thread->suspend_event = CreateEvent (NULL, TRUE, FALSE, NULL); if (thread->suspend_event == NULL) { LeaveCriticalSection (thread->synch_cs); return(NULL); } if (thread->suspended_event) SetEvent (thread->suspended_event); LeaveCriticalSection (thread->synch_cs); if (shutting_down) { /* After we left the lock, the runtime might shut down so everything becomes invalid */ for (;;) Sleep (1000); } WaitForSingleObject (thread->suspend_event, INFINITE); EnterCriticalSection (thread->synch_cs); CloseHandle (thread->suspend_event); thread->suspend_event = NULL; thread->state &= ~ThreadState_Suspended; /* The thread that requested the resume will have replaced this event * and will be waiting for it */ SetEvent (thread->resume_event); LeaveCriticalSection (thread->synch_cs); return NULL; } else if ((thread->state & ThreadState_StopRequested) != 0) { /* FIXME: do this through the JIT? */ LeaveCriticalSection (thread->synch_cs); mono_thread_exit (); return NULL; } else if (thread->thread_interrupt_requested) { thread->thread_interrupt_requested = FALSE; LeaveCriticalSection (thread->synch_cs); return(mono_get_exception_thread_interrupted ()); } LeaveCriticalSection (thread->synch_cs); return NULL; }
0
libxml2
92b9e8c8b3787068565a1820ba575d042f9eec66
NOT_APPLICABLE
NOT_APPLICABLE
xmlIsDocNameChar(xmlDocPtr doc, int c) { if ((doc == NULL) || (doc->properties & XML_DOC_OLD10) == 0) { /* * Use the new checks of production [4] [4a] amd [5] of the * Update 5 of XML-1.0 */ if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z')) || ((c >= '0') && (c <= '9')) || /* !start */ (c == '_') || (c == ':') || (c == '-') || (c == '.') || (c == 0xB7) || /* !start */ ((c >= 0xC0) && (c <= 0xD6)) || ((c >= 0xD8) && (c <= 0xF6)) || ((c >= 0xF8) && (c <= 0x2FF)) || ((c >= 0x300) && (c <= 0x36F)) || /* !start */ ((c >= 0x370) && (c <= 0x37D)) || ((c >= 0x37F) && (c <= 0x1FFF)) || ((c >= 0x200C) && (c <= 0x200D)) || ((c >= 0x203F) && (c <= 0x2040)) || /* !start */ ((c >= 0x2070) && (c <= 0x218F)) || ((c >= 0x2C00) && (c <= 0x2FEF)) || ((c >= 0x3001) && (c <= 0xD7FF)) || ((c >= 0xF900) && (c <= 0xFDCF)) || ((c >= 0xFDF0) && (c <= 0xFFFD)) || ((c >= 0x10000) && (c <= 0xEFFFF))) return(1); } else { if ((IS_LETTER(c)) || (IS_DIGIT(c)) || (c == '.') || (c == '-') || (c == '_') || (c == ':') || (IS_COMBINING(c)) || (IS_EXTENDER(c))) return(1); } return(0); }
0
php-src
e3133e4db70476fb7adfdedb738483e2255ce0e1
NOT_APPLICABLE
NOT_APPLICABLE
static size_t php_plain_files_dirstream_read(php_stream *stream, char *buf, size_t count) { DIR *dir = (DIR*)stream->abstract; /* avoid libc5 readdir problems */ char entry[sizeof(struct dirent)+MAXPATHLEN]; struct dirent *result = (struct dirent *)&entry; php_stream_dirent *ent = (php_stream_dirent*)buf; /* avoid problems if someone mis-uses the stream */ if (count != sizeof(php_stream_dirent)) return 0; if (php_readdir_r(dir, (struct dirent *)entry, &result) == 0 && result) { PHP_STRLCPY(ent->d_name, result->d_name, sizeof(ent->d_name), strlen(result->d_name)); return sizeof(php_stream_dirent); } return 0; }
0
linux
90481622d75715bfcb68501280a917dbfe516029
NOT_APPLICABLE
NOT_APPLICABLE
static void hugetlbfs_i_callback(struct rcu_head *head) { struct inode *inode = container_of(head, struct inode, i_rcu); kmem_cache_free(hugetlbfs_inode_cachep, HUGETLBFS_I(inode)); }
0
exif
eb84b0e3c5f2a86013b6fcfb800d187896a648fa
NOT_APPLICABLE
NOT_APPLICABLE
show_entry_list (ExifEntry *e, void *data) { const ExifParams *p = data; char v[TAG_VALUE_BUF]; ExifIfd ifd = exif_entry_get_ifd (e); const char *str; int fieldwidth, bytes; size_t width; if (p->use_ids) printf("0x%04x", e->tag); else { str = C(exif_tag_get_title_in_ifd (e->tag, ifd)); fieldwidth = width = 20; bytes = exif_mbstrlen(str, &width); printf ("%.*s%*s", bytes, str, fieldwidth-(int)width, ""); } printf ("|"); fieldwidth = width = p->use_ids ? p->width-8 : p->width-22; str = C(exif_entry_get_value (e, v, sizeof(v))); bytes = exif_mbstrlen(str, &width); printf("%.*s", bytes, str); fputc ('\n', stdout); }
0
vim
806d037671e133bd28a7864248763f643967973a
NOT_APPLICABLE
NOT_APPLICABLE
ins_bs( int c, int mode, int *inserted_space_p) { linenr_T lnum; int cc; int temp = 0; // init for GCC colnr_T save_col; colnr_T mincol; int did_backspace = FALSE; int in_indent; int oldState; int cpc[MAX_MCO]; // composing characters #if defined(FEAT_LISP) || defined(FEAT_CINDENT) int call_fix_indent = FALSE; #endif /* * can't delete anything in an empty file * can't backup past first character in buffer * can't backup past starting point unless 'backspace' > 1 * can backup to a previous line if 'backspace' == 0 */ if ( BUFEMPTY() || ( #ifdef FEAT_RIGHTLEFT !revins_on && #endif ((curwin->w_cursor.lnum == 1 && curwin->w_cursor.col == 0) || (!can_bs(BS_START) && ((arrow_used #ifdef FEAT_JOB_CHANNEL && !bt_prompt(curbuf) #endif ) || (curwin->w_cursor.lnum == Insstart_orig.lnum && curwin->w_cursor.col <= Insstart_orig.col))) || (!can_bs(BS_INDENT) && !arrow_used && ai_col > 0 && curwin->w_cursor.col <= ai_col) || (!can_bs(BS_EOL) && curwin->w_cursor.col == 0)))) { vim_beep(BO_BS); return FALSE; } if (stop_arrow() == FAIL) return FALSE; in_indent = inindent(0); #ifdef FEAT_CINDENT if (in_indent) can_cindent = FALSE; #endif end_comment_pending = NUL; // After BS, don't auto-end comment #ifdef FEAT_RIGHTLEFT if (revins_on) // put cursor after last inserted char inc_cursor(); #endif // Virtualedit: // BACKSPACE_CHAR eats a virtual space // BACKSPACE_WORD eats all coladd // BACKSPACE_LINE eats all coladd and keeps going if (curwin->w_cursor.coladd > 0) { if (mode == BACKSPACE_CHAR) { --curwin->w_cursor.coladd; return TRUE; } if (mode == BACKSPACE_WORD) { curwin->w_cursor.coladd = 0; return TRUE; } curwin->w_cursor.coladd = 0; } /* * Delete newline! */ if (curwin->w_cursor.col == 0) { lnum = Insstart.lnum; if (curwin->w_cursor.lnum == lnum #ifdef FEAT_RIGHTLEFT || revins_on #endif ) { if (u_save((linenr_T)(curwin->w_cursor.lnum - 2), (linenr_T)(curwin->w_cursor.lnum + 1)) == FAIL) return FALSE; --Insstart.lnum; Insstart.col = (colnr_T)STRLEN(ml_get(Insstart.lnum)); } /* * In replace mode: * cc < 0: NL was inserted, delete it * cc >= 0: NL was replaced, put original characters back */ cc = -1; if (State & REPLACE_FLAG) cc = replace_pop(); // returns -1 if NL was inserted /* * In replace mode, in the line we started replacing, we only move the * cursor. */ if ((State & REPLACE_FLAG) && curwin->w_cursor.lnum <= lnum) { dec_cursor(); } else { if (!(State & VREPLACE_FLAG) || curwin->w_cursor.lnum > orig_line_count) { temp = gchar_cursor(); // remember current char --curwin->w_cursor.lnum; // When "aw" is in 'formatoptions' we must delete the space at // the end of the line, otherwise the line will be broken // again when auto-formatting. if (has_format_option(FO_AUTO) && has_format_option(FO_WHITE_PAR)) { char_u *ptr = ml_get_buf(curbuf, curwin->w_cursor.lnum, TRUE); int len; len = (int)STRLEN(ptr); if (len > 0 && ptr[len - 1] == ' ') ptr[len - 1] = NUL; } (void)do_join(2, FALSE, FALSE, FALSE, FALSE); if (temp == NUL && gchar_cursor() != NUL) inc_cursor(); } else dec_cursor(); /* * In REPLACE mode we have to put back the text that was replaced * by the NL. On the replace stack is first a NUL-terminated * sequence of characters that were deleted and then the * characters that NL replaced. */ if (State & REPLACE_FLAG) { /* * Do the next ins_char() in NORMAL state, to * prevent ins_char() from replacing characters and * avoiding showmatch(). */ oldState = State; State = NORMAL; /* * restore characters (blanks) deleted after cursor */ while (cc > 0) { save_col = curwin->w_cursor.col; mb_replace_pop_ins(cc); curwin->w_cursor.col = save_col; cc = replace_pop(); } // restore the characters that NL replaced replace_pop_ins(); State = oldState; } } did_ai = FALSE; } else { /* * Delete character(s) before the cursor. */ #ifdef FEAT_RIGHTLEFT if (revins_on) // put cursor on last inserted char dec_cursor(); #endif mincol = 0; // keep indent if (mode == BACKSPACE_LINE && (curbuf->b_p_ai #ifdef FEAT_CINDENT || cindent_on() #endif ) #ifdef FEAT_RIGHTLEFT && !revins_on #endif ) { save_col = curwin->w_cursor.col; beginline(BL_WHITE); if (curwin->w_cursor.col < save_col) { mincol = curwin->w_cursor.col; #if defined(FEAT_LISP) || defined(FEAT_CINDENT) // should now fix the indent to match with the previous line call_fix_indent = TRUE; #endif } curwin->w_cursor.col = save_col; } /* * Handle deleting one 'shiftwidth' or 'softtabstop'. */ if ( mode == BACKSPACE_CHAR && ((p_sta && in_indent) || ((get_sts_value() != 0 #ifdef FEAT_VARTABS || tabstop_count(curbuf->b_p_vsts_array) #endif ) && curwin->w_cursor.col > 0 && (*(ml_get_cursor() - 1) == TAB || (*(ml_get_cursor() - 1) == ' ' && (!*inserted_space_p || arrow_used)))))) { int ts; colnr_T vcol; colnr_T want_vcol; colnr_T start_vcol; *inserted_space_p = FALSE; // Compute the virtual column where we want to be. Since // 'showbreak' may get in the way, need to get the last column of // the previous character. getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL); start_vcol = vcol; dec_cursor(); getvcol(curwin, &curwin->w_cursor, NULL, NULL, &want_vcol); inc_cursor(); #ifdef FEAT_VARTABS if (p_sta && in_indent) { ts = (int)get_sw_value(curbuf); want_vcol = (want_vcol / ts) * ts; } else want_vcol = tabstop_start(want_vcol, get_sts_value(), curbuf->b_p_vsts_array); #else if (p_sta && in_indent) ts = (int)get_sw_value(curbuf); else ts = (int)get_sts_value(); want_vcol = (want_vcol / ts) * ts; #endif // delete characters until we are at or before want_vcol while (vcol > want_vcol && (cc = *(ml_get_cursor() - 1), VIM_ISWHITE(cc))) ins_bs_one(&vcol); // insert extra spaces until we are at want_vcol while (vcol < want_vcol) { // Remember the first char we inserted if (curwin->w_cursor.lnum == Insstart_orig.lnum && curwin->w_cursor.col < Insstart_orig.col) Insstart_orig.col = curwin->w_cursor.col; if (State & VREPLACE_FLAG) ins_char(' '); else { ins_str((char_u *)" "); if ((State & REPLACE_FLAG)) replace_push(NUL); } getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL); } // If we are now back where we started delete one character. Can // happen when using 'sts' and 'linebreak'. if (vcol >= start_vcol) ins_bs_one(&vcol); } /* * Delete up to starting point, start of line or previous word. */ else { int cclass = 0, prev_cclass = 0; if (has_mbyte) cclass = mb_get_class(ml_get_cursor()); do { #ifdef FEAT_RIGHTLEFT if (!revins_on) // put cursor on char to be deleted #endif dec_cursor(); cc = gchar_cursor(); // look multi-byte character class if (has_mbyte) { prev_cclass = cclass; cclass = mb_get_class(ml_get_cursor()); } // start of word? if (mode == BACKSPACE_WORD && !vim_isspace(cc)) { mode = BACKSPACE_WORD_NOT_SPACE; temp = vim_iswordc(cc); } // end of word? else if (mode == BACKSPACE_WORD_NOT_SPACE && ((vim_isspace(cc) || vim_iswordc(cc) != temp) || prev_cclass != cclass)) { #ifdef FEAT_RIGHTLEFT if (!revins_on) #endif inc_cursor(); #ifdef FEAT_RIGHTLEFT else if (State & REPLACE_FLAG) dec_cursor(); #endif break; } if (State & REPLACE_FLAG) replace_do_bs(-1); else { if (enc_utf8 && p_deco) (void)utfc_ptr2char(ml_get_cursor(), cpc); (void)del_char(FALSE); /* * If there are combining characters and 'delcombine' is set * move the cursor back. Don't back up before the base * character. */ if (enc_utf8 && p_deco && cpc[0] != NUL) inc_cursor(); #ifdef FEAT_RIGHTLEFT if (revins_chars) { revins_chars--; revins_legal++; } if (revins_on && gchar_cursor() == NUL) break; #endif } // Just a single backspace?: if (mode == BACKSPACE_CHAR) break; } while ( #ifdef FEAT_RIGHTLEFT revins_on || #endif (curwin->w_cursor.col > mincol && (can_bs(BS_NOSTOP) || (curwin->w_cursor.lnum != Insstart_orig.lnum || curwin->w_cursor.col != Insstart_orig.col) ))); } did_backspace = TRUE; } #ifdef FEAT_SMARTINDENT did_si = FALSE; can_si = FALSE; can_si_back = FALSE; #endif if (curwin->w_cursor.col <= 1) did_ai = FALSE; #if defined(FEAT_LISP) || defined(FEAT_CINDENT) if (call_fix_indent) fix_indent(); #endif /* * It's a little strange to put backspaces into the redo * buffer, but it makes auto-indent a lot easier to deal * with. */ AppendCharToRedobuff(c); // If deleted before the insertion point, adjust it if (curwin->w_cursor.lnum == Insstart_orig.lnum && curwin->w_cursor.col < Insstart_orig.col) Insstart_orig.col = curwin->w_cursor.col; // vi behaviour: the cursor moves backward but the character that // was there remains visible // Vim behaviour: the cursor moves backward and the character that // was there is erased from the screen. // We can emulate the vi behaviour by pretending there is a dollar // displayed even when there isn't. // --pkv Sun Jan 19 01:56:40 EST 2003 if (vim_strchr(p_cpo, CPO_BACKSPACE) != NULL && dollar_vcol == -1) dollar_vcol = curwin->w_virtcol; #ifdef FEAT_FOLDING // When deleting a char the cursor line must never be in a closed fold. // E.g., when 'foldmethod' is indent and deleting the first non-white // char before a Tab. if (did_backspace) foldOpenCursor(); #endif return did_backspace; }
0
envoy
e9f936d85dc1edc34fabd0a1725ec180f2316353
NOT_APPLICABLE
NOT_APPLICABLE
TEST_P(SslSocketTest, FailedClientCertificateHashVerificationNoClientCertificate) { const std::string client_ctx_yaml = R"EOF( common_tls_context: )EOF"; const std::string server_ctx_yaml = absl::StrCat(R"EOF( common_tls_context: tls_certificates: certificate_chain: filename: "{{ test_rundir }}/test/extensions/transport_sockets/tls/test_data/unittest_cert.pem" private_key: filename: "{{ test_rundir }}/test/extensions/transport_sockets/tls/test_data/unittest_key.pem" validation_context: trusted_ca: filename: "{{ test_rundir }}/test/extensions/transport_sockets/tls/test_data/ca_cert.pem" verify_certificate_hash: ")EOF", TEST_SAN_URI_CERT_256_HASH, "\""); TestUtilOptions test_options(client_ctx_yaml, server_ctx_yaml, false, GetParam()); testUtil(test_options.setExpectedServerStats("ssl.fail_verify_no_cert")); }
0
Chrome
c7e50b5ef454efd6ab9527d795442c213eeb6afa
NOT_APPLICABLE
NOT_APPLICABLE
bool PopupContainer::handleKeyEvent(const PlatformKeyboardEvent& event) { UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture); return m_listBox->handleKeyEvent(event); }
0
winscp
49d876f2c5fc00bcedaa986a7cf6dedd6bf16f54
NOT_APPLICABLE
NOT_APPLICABLE
UnicodeString __fastcall TCommandSet::GetCommands(TFSCommand Cmd) { CHECK_CMD; return CommandSet[Cmd].Command; }
0
glib
d553d92d6e9f53cbe5a34166fcb919ba652c6a8e
NOT_APPLICABLE
NOT_APPLICABLE
g_socket_client_connect_to_service (GSocketClient *client, const gchar *domain, const gchar *service, GCancellable *cancellable, GError **error) { GSocketConnectable *connectable; GSocketConnection *connection; connectable = g_network_service_new (service, "tcp", domain); connection = g_socket_client_connect (client, connectable, cancellable, error); g_object_unref (connectable); return connection; }
0
linux
ae7b4e1f213aa659aedf9c6ecad0bf5f0476e1e2
NOT_APPLICABLE
NOT_APPLICABLE
static int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb) { struct net *net = sock_net(skb->sk); unsigned int h, s_h; unsigned int e = 0, s_e; struct rt6_rtnl_dump_arg arg; struct fib6_walker_t *w; struct fib6_table *tb; struct hlist_head *head; int res = 0; s_h = cb->args[0]; s_e = cb->args[1]; w = (void *)cb->args[2]; if (!w) { /* New dump: * * 1. hook callback destructor. */ cb->args[3] = (long)cb->done; cb->done = fib6_dump_done; /* * 2. allocate and initialize walker. */ w = kzalloc(sizeof(*w), GFP_ATOMIC); if (!w) return -ENOMEM; w->func = fib6_dump_node; cb->args[2] = (long)w; } arg.skb = skb; arg.cb = cb; arg.net = net; w->args = &arg; rcu_read_lock(); for (h = s_h; h < FIB6_TABLE_HASHSZ; h++, s_e = 0) { e = 0; head = &net->ipv6.fib_table_hash[h]; hlist_for_each_entry_rcu(tb, head, tb6_hlist) { if (e < s_e) goto next; res = fib6_dump_table(tb, skb, cb); if (res != 0) goto out; next: e++; } } out: rcu_read_unlock(); cb->args[1] = e; cb->args[0] = h; res = res < 0 ? res : skb->len; if (res <= 0) fib6_dump_end(cb); return res; }
0
linux
5d81de8e8667da7135d3a32a964087c0faf5483f
NOT_APPLICABLE
NOT_APPLICABLE
static int cifs_writepage(struct page *page, struct writeback_control *wbc) { int rc = cifs_writepage_locked(page, wbc); unlock_page(page); return rc; }
0
libmodbus
5ccdf5ef79d742640355d1132fa9e2abc7fbaefc
NOT_APPLICABLE
NOT_APPLICABLE
int modbus_set_slave(modbus_t *ctx, int slave) { if (ctx == NULL) { errno = EINVAL; return -1; } return ctx->backend->set_slave(ctx, slave); }
0
openssl
34628967f1e65dc8f34e000f0f5518e21afbfc7b
NOT_APPLICABLE
NOT_APPLICABLE
int tls1_final_finish_mac(SSL *s, const char *str, int slen, unsigned char *out) { unsigned int i; EVP_MD_CTX ctx; unsigned char buf[2*EVP_MAX_MD_SIZE]; unsigned char *q,buf2[12]; int idx; long mask; int err=0; const EVP_MD *md; q=buf; if (s->s3->handshake_buffer) if (!ssl3_digest_cached_records(s)) return 0; EVP_MD_CTX_init(&ctx); for (idx=0;ssl_get_handshake_digest(idx,&mask,&md);idx++) { if (mask & ssl_get_algorithm2(s)) { int hashsize = EVP_MD_size(md); EVP_MD_CTX *hdgst = s->s3->handshake_dgst[idx]; if (!hdgst || hashsize < 0 || hashsize > (int)(sizeof buf - (size_t)(q-buf))) { /* internal error: 'buf' is too small for this cipersuite! */ err = 1; } else { if (!EVP_MD_CTX_copy_ex(&ctx, hdgst) || !EVP_DigestFinal_ex(&ctx,q,&i) || (i != (unsigned int)hashsize)) err = 1; q+=hashsize; } } } if (!tls1_PRF(ssl_get_algorithm2(s), str,slen, buf,(int)(q-buf), NULL,0, NULL,0, NULL,0, s->session->master_key,s->session->master_key_length, out,buf2,sizeof buf2)) err = 1; EVP_MD_CTX_cleanup(&ctx); if (err) return 0; else return sizeof buf2; }
0
linux
c2183d1e9b3f313dd8ba2b1b0197c8d9fb86a7ae
NOT_APPLICABLE
NOT_APPLICABLE
void fuse_request_free(struct fuse_req *req) { kmem_cache_free(fuse_req_cachep, req); }
0
cpio
dd96882877721703e19272fe25034560b794061b
NOT_APPLICABLE
NOT_APPLICABLE
process_copy_pass (void) { dynamic_string input_name = DYNAMIC_STRING_INITIALIZER; /* Name of file from stdin. */ dynamic_string output_name = DYNAMIC_STRING_INITIALIZER; /* Name of new file. */ size_t dirname_len; /* Length of `directory_name'. */ int res; /* Result of functions. */ char *slash; /* For moving past slashes in input name. */ struct stat in_file_stat; /* Stat record for input file. */ struct stat out_file_stat; /* Stat record for output file. */ int in_file_des; /* Input file descriptor. */ int out_file_des; /* Output file descriptor. */ int existing_dir; /* True if file is a dir & already exists. */ newdir_umask = umask (0); /* Reset umask to preserve modes of created files */ /* Initialize the copy pass. */ dirname_len = strlen (directory_name); if (change_directory_option && !ISSLASH (directory_name[0])) { char *pwd = xgetcwd (); ds_concat (&output_name, pwd); ds_append (&output_name, '/'); } ds_concat (&output_name, directory_name); ds_append (&output_name, '/'); dirname_len = ds_len (&output_name); output_is_seekable = true; change_dir (); /* Copy files with names read from stdin. */ while (ds_fgetstr (stdin, &input_name, name_end) != NULL) { int link_res = -1; /* Check for blank line and ignore it if found. */ if (input_name.ds_string[0] == '\0') { error (0, 0, _("blank line ignored")); continue; } /* Check for current directory and ignore it if found. */ if (input_name.ds_string[0] == '.' && (input_name.ds_string[1] == '\0' || (input_name.ds_string[1] == '/' && input_name.ds_string[2] == '\0'))) continue; if ((*xstat) (input_name.ds_string, &in_file_stat) < 0) { stat_error (input_name.ds_string); continue; } /* Make the name of the new file. */ for (slash = input_name.ds_string; *slash == '/'; ++slash) ; ds_reset (&output_name, dirname_len); ds_concat (&output_name, slash); existing_dir = false; if (lstat (output_name.ds_string, &out_file_stat) == 0) { if (S_ISDIR (out_file_stat.st_mode) && S_ISDIR (in_file_stat.st_mode)) { /* If there is already a directory there that we are trying to create, don't complain about it. */ existing_dir = true; } else if (!unconditional_flag && in_file_stat.st_mtime <= out_file_stat.st_mtime) { error (0, 0, _("%s not created: newer or same age version exists"), output_name.ds_string); continue; /* Go to the next file. */ } else if (S_ISDIR (out_file_stat.st_mode) ? rmdir (output_name.ds_string) : unlink (output_name.ds_string)) { error (0, errno, _("cannot remove current %s"), output_name.ds_string); continue; /* Go to the next file. */ } } /* Do the real copy or link. */ if (S_ISREG (in_file_stat.st_mode)) { /* Can the current file be linked to a another file? Set link_name to the original file name. */ if (link_flag) /* User said to link it if possible. Try and link to the original copy. If that fails we'll still try and link to a copy we've already made. */ link_res = link_to_name (output_name.ds_string, input_name.ds_string); if ( (link_res < 0) && (in_file_stat.st_nlink > 1) ) link_res = link_to_maj_min_ino (output_name.ds_string, major (in_file_stat.st_dev), minor (in_file_stat.st_dev), in_file_stat.st_ino); /* If the file was not linked, copy contents of file. */ if (link_res < 0) { in_file_des = open (input_name.ds_string, O_RDONLY | O_BINARY, 0); if (in_file_des < 0) { open_error (input_name.ds_string); continue; } out_file_des = open (output_name.ds_string, O_CREAT | O_WRONLY | O_BINARY, 0600); if (out_file_des < 0 && create_dir_flag) { create_all_directories (output_name.ds_string); out_file_des = open (output_name.ds_string, O_CREAT | O_WRONLY | O_BINARY, 0600); } if (out_file_des < 0) { open_error (output_name.ds_string); close (in_file_des); continue; } copy_files_disk_to_disk (in_file_des, out_file_des, in_file_stat.st_size, input_name.ds_string); disk_empty_output_buffer (out_file_des, true); set_copypass_perms (out_file_des, output_name.ds_string, &in_file_stat); if (reset_time_flag) { set_file_times (in_file_des, input_name.ds_string, in_file_stat.st_atime, in_file_stat.st_mtime); set_file_times (out_file_des, output_name.ds_string, in_file_stat.st_atime, in_file_stat.st_mtime); } if (close (in_file_des) < 0) close_error (input_name.ds_string); if (close (out_file_des) < 0) close_error (output_name.ds_string); warn_if_file_changed(input_name.ds_string, in_file_stat.st_size, in_file_stat.st_mtime); } } else if (S_ISDIR (in_file_stat.st_mode)) { struct cpio_file_stat file_stat; stat_to_cpio (&file_stat, &in_file_stat); file_stat.c_name = output_name.ds_string; cpio_create_dir (&file_stat, existing_dir); } else if (S_ISCHR (in_file_stat.st_mode) || S_ISBLK (in_file_stat.st_mode) || #ifdef S_ISFIFO S_ISFIFO (in_file_stat.st_mode) || #endif #ifdef S_ISSOCK S_ISSOCK (in_file_stat.st_mode) || #endif 0) { /* Can the current file be linked to a another file? Set link_name to the original file name. */ if (link_flag) /* User said to link it if possible. */ link_res = link_to_name (output_name.ds_string, input_name.ds_string); if ( (link_res < 0) && (in_file_stat.st_nlink > 1) ) link_res = link_to_maj_min_ino (output_name.ds_string, major (in_file_stat.st_dev), minor (in_file_stat.st_dev), in_file_stat.st_ino); if (link_res < 0) { res = mknod (output_name.ds_string, in_file_stat.st_mode, in_file_stat.st_rdev); if (res < 0 && create_dir_flag) { create_all_directories (output_name.ds_string); res = mknod (output_name.ds_string, in_file_stat.st_mode, in_file_stat.st_rdev); } if (res < 0) { mknod_error (output_name.ds_string); continue; } set_copypass_perms (-1, output_name.ds_string, &in_file_stat); } } #ifdef S_ISLNK else if (S_ISLNK (in_file_stat.st_mode)) { char *link_name; int link_size; link_name = (char *) xmalloc ((unsigned int) in_file_stat.st_size + 1); link_size = readlink (input_name.ds_string, link_name, in_file_stat.st_size); if (link_size < 0) { readlink_error (input_name.ds_string); free (link_name); continue; } link_name[link_size] = '\0'; res = UMASKED_SYMLINK (link_name, output_name.ds_string, in_file_stat.st_mode); if (res < 0 && create_dir_flag) { create_all_directories (output_name.ds_string); res = UMASKED_SYMLINK (link_name, output_name.ds_string, in_file_stat.st_mode); } if (res < 0) { symlink_error (output_name.ds_string, link_name); free (link_name); continue; } /* Set the attributes of the new link. */ if (!no_chown_flag) { uid_t uid = set_owner_flag ? set_owner : in_file_stat.st_uid; gid_t gid = set_group_flag ? set_group : in_file_stat.st_gid; if ((lchown (output_name.ds_string, uid, gid) < 0) && errno != EPERM) chown_error_details (output_name.ds_string, uid, gid); } free (link_name); } #endif else { error (0, 0, _("%s: unknown file type"), input_name.ds_string); } if (verbose_flag) fprintf (stderr, "%s\n", output_name.ds_string); if (dot_flag) fputc ('.', stderr); } if (dot_flag) fputc ('\n', stderr); apply_delayed_set_stat (); if (!quiet_flag) { size_t blocks = (output_bytes + io_block_size - 1) / io_block_size; fprintf (stderr, ngettext ("%lu block\n", "%lu blocks\n", (unsigned long) blocks), (unsigned long) blocks); } ds_free (&input_name); ds_free (&output_name); }
0
tcpdump
29e5470e6ab84badbc31f4532bb7554a796d9d52
NOT_APPLICABLE
NOT_APPLICABLE
cmu_print(netdissect_options *ndo, register const u_char *bp) { register const struct cmu_vend *cmu; #define PRINTCMUADDR(m, s) { ND_TCHECK(cmu->m); \ if (cmu->m.s_addr != 0) \ ND_PRINT((ndo, " %s:%s", s, ipaddr_string(ndo, &cmu->m.s_addr))); } ND_PRINT((ndo, " vend-cmu")); cmu = (const struct cmu_vend *)bp; /* Only print if there are unknown bits */ ND_TCHECK(cmu->v_flags); if ((cmu->v_flags & ~(VF_SMASK)) != 0) ND_PRINT((ndo, " F:0x%x", cmu->v_flags)); PRINTCMUADDR(v_dgate, "DG"); PRINTCMUADDR(v_smask, cmu->v_flags & VF_SMASK ? "SM" : "SM*"); PRINTCMUADDR(v_dns1, "NS1"); PRINTCMUADDR(v_dns2, "NS2"); PRINTCMUADDR(v_ins1, "IEN1"); PRINTCMUADDR(v_ins2, "IEN2"); PRINTCMUADDR(v_ts1, "TS1"); PRINTCMUADDR(v_ts2, "TS2"); return; trunc: ND_PRINT((ndo, "%s", tstr)); #undef PRINTCMUADDR }
0
Chrome
5788690fb1395dc672ff9b3385dbfb1180ed710a
NOT_APPLICABLE
NOT_APPLICABLE
void DelegatedFrameHost::DidNotProduceFrame(const viz::BeginFrameAck& ack) { DCHECK(!ack.has_damage); support_->DidNotProduceFrame(ack); }
0
Android
a30d7d90c4f718e46fb41a99b3d52800e1011b73
NOT_APPLICABLE
NOT_APPLICABLE
virtual void setConsumerName(const String8& name) { Parcel data, reply; data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor()); data.writeString8(name); remote()->transact(SET_CONSUMER_NAME, data, &reply); }
0
Android
e68cbc3e9e66df4231e70efa3e9c41abc12aea20
NOT_APPLICABLE
NOT_APPLICABLE
status_t unflatten_binder(const sp<ProcessState>& proc, const Parcel& in, wp<IBinder>* out) { const flat_binder_object* flat = in.readObject(false); if (flat) { switch (flat->type) { case BINDER_TYPE_BINDER: *out = reinterpret_cast<IBinder*>(flat->cookie); return finish_unflatten_binder(NULL, *flat, in); case BINDER_TYPE_WEAK_BINDER: if (flat->binder != 0) { out->set_object_and_refs( reinterpret_cast<IBinder*>(flat->cookie), reinterpret_cast<RefBase::weakref_type*>(flat->binder)); } else { *out = NULL; } return finish_unflatten_binder(NULL, *flat, in); case BINDER_TYPE_HANDLE: case BINDER_TYPE_WEAK_HANDLE: *out = proc->getWeakProxyForHandle(flat->handle); return finish_unflatten_binder( static_cast<BpBinder*>(out->unsafe_get()), *flat, in); } } return BAD_TYPE; }
0
Chrome
ad103a1564365c95f4ee4f10261f9604f91f686a
NOT_APPLICABLE
NOT_APPLICABLE
PP_Resource PPB_ImageData_Impl::CreatePlatform(PP_Instance instance, PP_ImageDataFormat format, const PP_Size& size, PP_Bool init_to_zero) { scoped_refptr<PPB_ImageData_Impl> data(new PPB_ImageData_Impl(instance, PLATFORM)); if (!data->Init(format, size.width, size.height, !!init_to_zero)) return 0; return data->GetReference(); }
0
Chrome
ef97ce340c462d5212336f09bf8075d1cb10faa4
NOT_APPLICABLE
NOT_APPLICABLE
bool PluginInfoMessageFilter::OnMessageReceived(const IPC::Message& message, bool* message_was_ok) { IPC_BEGIN_MESSAGE_MAP_EX(PluginInfoMessageFilter, message, *message_was_ok) IPC_MESSAGE_HANDLER_DELAY_REPLY(ChromeViewHostMsg_GetPluginInfo, OnGetPluginInfo) IPC_MESSAGE_UNHANDLED(return false) IPC_END_MESSAGE_MAP() return true; }
0
linux
d88d05a9e0b6d9356e97129d4ff9942d765f46ea
NOT_APPLICABLE
NOT_APPLICABLE
void intel_pmu_pebs_sched_task(struct perf_event_context *ctx, bool sched_in) { struct cpu_hw_events *cpuc = this_cpu_ptr(&cpu_hw_events); if (!sched_in && pebs_needs_sched_cb(cpuc)) intel_pmu_drain_pebs_buffer(); }
0
php
88412772d295ebf7dd34409534507dc9bcac726e
NOT_APPLICABLE
NOT_APPLICABLE
XMLRPC_VALUE_TYPE XMLRPC_GetValueType(XMLRPC_VALUE value) { return value ? value->type : xmlrpc_empty; }
0
FreeRDP
6b485b146a1b9d6ce72dfd7b5f36456c166e7a16
NOT_APPLICABLE
NOT_APPLICABLE
static UINT drive_process_irp(DRIVE_DEVICE* drive, IRP* irp) { UINT error; if (!drive || !irp) return ERROR_INVALID_PARAMETER; irp->IoStatus = STATUS_SUCCESS; switch (irp->MajorFunction) { case IRP_MJ_CREATE: error = drive_process_irp_create(drive, irp); break; case IRP_MJ_CLOSE: error = drive_process_irp_close(drive, irp); break; case IRP_MJ_READ: error = drive_process_irp_read(drive, irp); break; case IRP_MJ_WRITE: error = drive_process_irp_write(drive, irp); break; case IRP_MJ_QUERY_INFORMATION: error = drive_process_irp_query_information(drive, irp); break; case IRP_MJ_SET_INFORMATION: error = drive_process_irp_set_information(drive, irp); break; case IRP_MJ_QUERY_VOLUME_INFORMATION: error = drive_process_irp_query_volume_information(drive, irp); break; case IRP_MJ_LOCK_CONTROL: error = drive_process_irp_silent_ignore(drive, irp); break; case IRP_MJ_DIRECTORY_CONTROL: error = drive_process_irp_directory_control(drive, irp); break; case IRP_MJ_DEVICE_CONTROL: error = drive_process_irp_device_control(drive, irp); break; default: irp->IoStatus = STATUS_NOT_SUPPORTED; error = irp->Complete(irp); break; } return error; }
0
linux
fbd40ea0180a2d328c5adc61414dc8bab9335ce2
NOT_APPLICABLE
NOT_APPLICABLE
static void devinet_copy_dflt_conf(struct net *net, int i) { struct net_device *dev; rcu_read_lock(); for_each_netdev_rcu(net, dev) { struct in_device *in_dev; in_dev = __in_dev_get_rcu(dev); if (in_dev && !test_bit(i, in_dev->cnf.state)) in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i]; } rcu_read_unlock(); }
0
php-src
7245bff300d3fa8bacbef7897ff080a6f1c23eba?w=1
CVE-2016-5770
CWE-190
static void spl_filesystem_tree_it_move_forward(zend_object_iterator *iter TSRMLS_DC) { spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter; spl_filesystem_object *object = spl_filesystem_iterator_to_object(iterator); object->u.dir.index++; do { spl_filesystem_dir_read(object TSRMLS_CC); } while (spl_filesystem_is_dot(object->u.dir.entry.d_name)); if (object->file_name) { efree(object->file_name); object->file_name = NULL; } if (iterator->current) { zval_ptr_dtor(&iterator->current); iterator->current = NULL; } }
1
server
8c34eab9688b4face54f15f89f5d62bdfd93b8a7
NOT_APPLICABLE
NOT_APPLICABLE
copy_fields(TMP_TABLE_PARAM *param) { Copy_field *ptr=param->copy_field; Copy_field *end=param->copy_field_end; DBUG_ASSERT((ptr != NULL && end >= ptr) || (ptr == NULL && end == NULL)); for (; ptr != end; ptr++) (*ptr->do_copy)(ptr); List_iterator_fast<Item> it(param->copy_funcs); Item_copy *item; while ((item= (Item_copy*) it++)) item->copy(); }
0
linux-nfs
1c77f7a869bdea2a34799d774460d1f9983d45f0
NOT_APPLICABLE
NOT_APPLICABLE
__rpc_get_local_uid(SVCXPRT *transp, uid_t *uid) { int sock, ret; gid_t egid; uid_t euid; struct sockaddr *sa; sock = transp->xp_fd; sa = (struct sockaddr *)transp->xp_rtaddr.buf; if (sa->sa_family == AF_LOCAL) { ret = getpeereid(sock, &euid, &egid); if (ret == 0) *uid = euid; return (ret); } else return (-1); }
0
Chrome
b399a05453d7b3e2dfdec67865fefe6953bcc59e
NOT_APPLICABLE
NOT_APPLICABLE
void RenderWidgetHostViewAura::RemovingFromRootWindow() { aura::client::CursorClient* cursor_client = aura::client::GetCursorClient(window_->GetRootWindow()); if (cursor_client) cursor_client->RemoveObserver(this); DetachFromInputMethod(); window_->GetHost()->RemoveObserver(this); if (delegated_frame_host_) delegated_frame_host_->ResetCompositor(); #if defined(OS_WIN) if (legacy_render_widget_host_HWND_) legacy_render_widget_host_HWND_->UpdateParent(ui::GetHiddenWindow()); #endif }
0
cxxtools
142bb2589dc184709857c08c1e10570947c444e3
NOT_APPLICABLE
NOT_APPLICABLE
const std::string& QueryParams::param(const std::string& name, size_type n) const { for (size_type nn = 0; nn < _values.size(); ++nn) { if (_values[nn].name == name) { if (n == 0) return _values[nn].value; --n; } } static std::string emptyValue; return emptyValue; }
0
Android
a24543157ae2cdd25da43e20f4e48a07481e6ceb
CVE-2018-9490
CWE-704
static Maybe<bool> CollectValuesOrEntriesImpl( Isolate* isolate, Handle<JSObject> object, Handle<FixedArray> values_or_entries, bool get_entries, int* nof_items, PropertyFilter filter) { int count = 0; KeyAccumulator accumulator(isolate, KeyCollectionMode::kOwnOnly, ALL_PROPERTIES); Subclass::CollectElementIndicesImpl( object, handle(object->elements(), isolate), &accumulator); Handle<FixedArray> keys = accumulator.GetKeys(); for (int i = 0; i < keys->length(); ++i) { Handle<Object> key(keys->get(i), isolate); Handle<Object> value; uint32_t index; if (!key->ToUint32(&index)) continue; uint32_t entry = Subclass::GetEntryForIndexImpl( isolate, *object, object->elements(), index, filter); if (entry == kMaxUInt32) continue; PropertyDetails details = Subclass::GetDetailsImpl(*object, entry); if (details.kind() == kData) { value = Subclass::GetImpl(isolate, object->elements(), entry); } else { LookupIterator it(isolate, object, index, LookupIterator::OWN); ASSIGN_RETURN_ON_EXCEPTION_VALUE( isolate, value, Object::GetProperty(&it), Nothing<bool>()); } if (get_entries) { value = MakeEntryPair(isolate, index, value); } values_or_entries->set(count++, *value); } *nof_items = count; return Just(true); }
1
gpac
35ab4475a7df9b2a4bcab235e379c0c3ec543658
NOT_APPLICABLE
NOT_APPLICABLE
static void gf_sm_delete_stream(GF_StreamContext *sc) { gf_sm_reset_stream(sc); gf_list_del(sc->AUs); if (sc->name) gf_free(sc->name); if (sc->dec_cfg) gf_free(sc->dec_cfg); gf_free(sc); }
0
Android
d07f5c14e811951ff9b411ceb84e7288e0d04aaf
NOT_APPLICABLE
NOT_APPLICABLE
sp<MetaData> OggSource::getFormat() { return mExtractor->mImpl->getFormat(); }
0
LuaJIT
e296f56b825c688c3530a981dc6b495d972f3d01
NOT_APPLICABLE
NOT_APPLICABLE
int lj_trace_flushall(lua_State *L) { jit_State *J = L2J(L); ptrdiff_t i; if ((J2G(J)->hookmask & HOOK_GC)) return 1; for (i = (ptrdiff_t)J->sizetrace-1; i > 0; i--) { GCtrace *T = traceref(J, i); if (T) { if (T->root == 0) trace_flushroot(J, T); lj_gdbjit_deltrace(J, T); T->traceno = 0; setgcrefnull(J->trace[i]); } } J->cur.traceno = 0; J->freetrace = 0; /* Clear penalty cache. */ memset(J->penalty, 0, sizeof(J->penalty)); /* Free the whole machine code and invalidate all exit stub groups. */ lj_mcode_free(J); memset(J->exitstubgroup, 0, sizeof(J->exitstubgroup)); lj_vmevent_send(L, TRACE, setstrV(L, L->top++, lj_str_newlit(L, "flush")); ); return 0; }
0
Chrome
2f81d000fdb5331121cba7ff81dfaaec25b520a5
CVE-2019-5822
CWE-284
bool DownloadManagerImpl::InterceptDownload( const download::DownloadCreateInfo& info) { WebContents* web_contents = WebContentsImpl::FromRenderFrameHostID( info.render_process_id, info.render_frame_id); if (info.is_new_download && info.result == download::DOWNLOAD_INTERRUPT_REASON_SERVER_CROSS_ORIGIN_REDIRECT) { if (web_contents) { std::vector<GURL> url_chain(info.url_chain); GURL url = url_chain.back(); url_chain.pop_back(); NavigationController::LoadURLParams params(url); params.has_user_gesture = info.has_user_gesture; params.referrer = Referrer( info.referrer_url, Referrer::NetReferrerPolicyToBlinkReferrerPolicy( info.referrer_policy)); params.redirect_chain = url_chain; web_contents->GetController().LoadURLWithParams(params); } if (info.request_handle) info.request_handle->CancelRequest(false); return true; } if (!delegate_ || !delegate_->InterceptDownloadIfApplicable( info.url(), info.mime_type, info.request_origin, web_contents)) { return false; } if (info.request_handle) info.request_handle->CancelRequest(false); return true; }
1
linux
ef85b67385436ddc1998f45f1d6a210f935b3388
NOT_APPLICABLE
NOT_APPLICABLE
static void vmx_handle_external_intr(struct kvm_vcpu *vcpu) { u32 exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); register void *__sp asm(_ASM_SP); if ((exit_intr_info & (INTR_INFO_VALID_MASK | INTR_INFO_INTR_TYPE_MASK)) == (INTR_INFO_VALID_MASK | INTR_TYPE_EXT_INTR)) { unsigned int vector; unsigned long entry; gate_desc *desc; struct vcpu_vmx *vmx = to_vmx(vcpu); #ifdef CONFIG_X86_64 unsigned long tmp; #endif vector = exit_intr_info & INTR_INFO_VECTOR_MASK; desc = (gate_desc *)vmx->host_idt_base + vector; entry = gate_offset(*desc); asm volatile( #ifdef CONFIG_X86_64 "mov %%" _ASM_SP ", %[sp]\n\t" "and $0xfffffffffffffff0, %%" _ASM_SP "\n\t" "push $%c[ss]\n\t" "push %[sp]\n\t" #endif "pushf\n\t" __ASM_SIZE(push) " $%c[cs]\n\t" "call *%[entry]\n\t" : #ifdef CONFIG_X86_64 [sp]"=&r"(tmp), #endif "+r"(__sp) : [entry]"r"(entry), [ss]"i"(__KERNEL_DS), [cs]"i"(__KERNEL_CS) ); } }
0
openvpn
1394192b210cb3c6624a7419bcf3ff966742e79b
NOT_APPLICABLE
NOT_APPLICABLE
RegisterDNS(LPVOID unused) { DWORD err; DWORD i; WCHAR sys_path[MAX_PATH]; DWORD timeout = RDNS_TIMEOUT * 1000; /* in milliseconds */ /* default path of ipconfig command */ WCHAR ipcfg[MAX_PATH] = L"C:\\Windows\\system32\\ipconfig.exe"; struct { WCHAR *argv0; WCHAR *cmdline; DWORD timeout; } cmds [] = { { ipcfg, L"ipconfig /flushdns", timeout }, { ipcfg, L"ipconfig /registerdns", timeout }, }; int ncmds = sizeof(cmds) / sizeof(cmds[0]); HANDLE wait_handles[2] = {rdns_semaphore, exit_event}; if (GetSystemDirectory(sys_path, MAX_PATH)) { swprintf(ipcfg, MAX_PATH, L"%s\\%s", sys_path, L"ipconfig.exe"); ipcfg[MAX_PATH-1] = L'\0'; } if (WaitForMultipleObjects(2, wait_handles, FALSE, timeout) == WAIT_OBJECT_0) { /* Semaphore locked */ for (i = 0; i < ncmds; ++i) { ExecCommand(cmds[i].argv0, cmds[i].cmdline, cmds[i].timeout); } err = 0; if (!ReleaseSemaphore(rdns_semaphore, 1, NULL) ) { err = MsgToEventLog(M_SYSERR, TEXT("RegisterDNS: Failed to release regsiter-dns semaphore:")); } } else { MsgToEventLog(M_ERR, TEXT("RegisterDNS: Failed to lock register-dns semaphore")); err = ERROR_SEM_TIMEOUT; /* Windows error code 0x79 */ } return err; }
0
xdelta-devel
ef93ff74203e030073b898c05e8b4860b5d09ef2
NOT_APPLICABLE
NOT_APPLICABLE
main_file_read (main_file *ifile, uint8_t *buf, size_t size, size_t *nread, const char *msg) { int ret = 0; #if XD3_STDIO size_t result; result = fread (buf, 1, size, ifile->file); if (result < size && ferror (ifile->file)) { ret = get_errno (); } else { *nread = result; } #elif XD3_POSIX ret = xd3_posix_io (ifile->file, buf, size, (xd3_posix_func*) &read, nread); #elif XD3_WIN32 ret = xd3_win32_io (ifile->file, buf, size, 1 /* is_read */, nread); #endif if (ret) { XPR(NT "%s: %s: %s\n", msg, ifile->filename, xd3_mainerror (ret)); } else { if (option_verbose > 4) { XPR(NT "read %s: %zu bytes\n", ifile->filename, (*nread)); } ifile->nread += (*nread); } return ret; }
0
qemu
26f670a244982335cc08943fb1ec099a2c81e42d
NOT_APPLICABLE
NOT_APPLICABLE
static void ohci_detach(USBPort *port1) { OHCIState *s = port1->opaque; OHCIPort *port = &s->rhport[port1->index]; uint32_t old_state = port->ctrl; ohci_async_cancel_device(s, port1->dev); /* set connect status */ if (port->ctrl & OHCI_PORT_CCS) { port->ctrl &= ~OHCI_PORT_CCS; port->ctrl |= OHCI_PORT_CSC; } /* disable port */ if (port->ctrl & OHCI_PORT_PES) { port->ctrl &= ~OHCI_PORT_PES; port->ctrl |= OHCI_PORT_PESC; } trace_usb_ohci_port_detach(port1->index); if (old_state != port->ctrl) { ohci_set_interrupt(s, OHCI_INTR_RHSC); } }
0
Chrome
e99cc8e5a48ff4978d401c48a64f06649f647f3f
NOT_APPLICABLE
NOT_APPLICABLE
void TextTrackLoader::newRegionsParsed() { m_client->newRegionsAvailable(this); }
0
linux
d6d86830705f173fca6087a3e67ceaf68db80523
NOT_APPLICABLE
NOT_APPLICABLE
static bool tsk_conn_cong(struct tipc_sock *tsk) { return tsk->snt_unacked > tsk->snd_win; }
0
php-src
58006537fc5f133ae8549efe5118cde418b3ace9
NOT_APPLICABLE
NOT_APPLICABLE
static void MYSQLND_METHOD(mysqlnd_protocol, init_change_auth_response_packet)(struct st_mysqlnd_packet_change_auth_response *packet) { DBG_ENTER("mysqlnd_protocol::init_change_auth_response_packet"); memset(packet, 0, sizeof(*packet)); packet->header.m = &packet_methods[PROT_CHANGE_AUTH_RESP_PACKET]; DBG_VOID_RETURN;
0
php
b061fa909de77085d3822a89ab901b934d0362c4
NOT_APPLICABLE
NOT_APPLICABLE
PHP_FUNCTION(get_headers) { char *url; int url_len; php_stream_context *context; php_stream *stream; zval **prev_val, **hdr = NULL, **h; HashPosition pos; HashTable *hashT; long format = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &url, &url_len, &format) == FAILURE) { return; } context = FG(default_context) ? FG(default_context) : (FG(default_context) = php_stream_context_alloc(TSRMLS_C)); if (!(stream = php_stream_open_wrapper_ex(url, "r", REPORT_ERRORS | STREAM_USE_URL | STREAM_ONLY_GET_HEADERS, NULL, context))) { RETURN_FALSE; } if (!stream->wrapperdata || Z_TYPE_P(stream->wrapperdata) != IS_ARRAY) { php_stream_close(stream); RETURN_FALSE; } array_init(return_value); /* check for curl-wrappers that provide headers via a special "headers" element */ if (zend_hash_find(HASH_OF(stream->wrapperdata), "headers", sizeof("headers"), (void **)&h) != FAILURE && Z_TYPE_PP(h) == IS_ARRAY) { /* curl-wrappers don't load data until the 1st read */ if (!Z_ARRVAL_PP(h)->nNumOfElements) { php_stream_getc(stream); } zend_hash_find(HASH_OF(stream->wrapperdata), "headers", sizeof("headers"), (void **)&h); hashT = Z_ARRVAL_PP(h); } else { hashT = HASH_OF(stream->wrapperdata); } zend_hash_internal_pointer_reset_ex(hashT, &pos); while (zend_hash_get_current_data_ex(hashT, (void**)&hdr, &pos) != FAILURE) { if (!hdr || Z_TYPE_PP(hdr) != IS_STRING) { zend_hash_move_forward_ex(hashT, &pos); continue; } if (!format) { no_name_header: add_next_index_stringl(return_value, Z_STRVAL_PP(hdr), Z_STRLEN_PP(hdr), 1); } else { char c; char *s, *p; if ((p = strchr(Z_STRVAL_PP(hdr), ':'))) { c = *p; *p = '\0'; s = p + 1; while (isspace((int)*(unsigned char *)s)) { s++; } if (zend_hash_find(HASH_OF(return_value), Z_STRVAL_PP(hdr), (p - Z_STRVAL_PP(hdr) + 1), (void **) &prev_val) == FAILURE) { add_assoc_stringl_ex(return_value, Z_STRVAL_PP(hdr), (p - Z_STRVAL_PP(hdr) + 1), s, (Z_STRLEN_PP(hdr) - (s - Z_STRVAL_PP(hdr))), 1); } else { /* some headers may occur more then once, therefor we need to remake the string into an array */ convert_to_array(*prev_val); add_next_index_stringl(*prev_val, s, (Z_STRLEN_PP(hdr) - (s - Z_STRVAL_PP(hdr))), 1); } *p = c; } else { goto no_name_header; } } zend_hash_move_forward_ex(hashT, &pos); } php_stream_close(stream); }
0
pacemaker
5ec24a2642bd0854b884d1a9b51d12371373b410
CVE-2016-7797
CWE-254
lrmd_remote_listen(gpointer data) { int csock = 0; int flag = 0; unsigned laddr = 0; struct sockaddr addr; gnutls_session_t *session = NULL; crm_client_t *new_client = NULL; static struct mainloop_fd_callbacks lrmd_remote_fd_cb = { .dispatch = lrmd_remote_client_msg, .destroy = lrmd_remote_client_destroy, }; laddr = sizeof(addr); memset(&addr, 0, sizeof(addr)); getsockname(ssock, &addr, &laddr); /* accept the connection */ if (addr.sa_family == AF_INET6) { struct sockaddr_in6 sa; char addr_str[INET6_ADDRSTRLEN]; laddr = sizeof(sa); memset(&sa, 0, sizeof(sa)); csock = accept(ssock, &sa, &laddr); get_ip_str((struct sockaddr *)&sa, addr_str, INET6_ADDRSTRLEN); crm_info("New remote connection from %s", addr_str); } else { struct sockaddr_in sa; char addr_str[INET_ADDRSTRLEN]; laddr = sizeof(sa); memset(&sa, 0, sizeof(sa)); csock = accept(ssock, &sa, &laddr); get_ip_str((struct sockaddr *)&sa, addr_str, INET_ADDRSTRLEN); crm_info("New remote connection from %s", addr_str); } if (csock == -1) { crm_err("accept socket failed"); return TRUE; } if ((flag = fcntl(csock, F_GETFL)) >= 0) { if (fcntl(csock, F_SETFL, flag | O_NONBLOCK) < 0) { crm_err("fcntl() write failed"); close(csock); return TRUE; } } else { crm_err("fcntl() read failed"); close(csock); return TRUE; } session = create_psk_tls_session(csock, GNUTLS_SERVER, psk_cred_s); if (session == NULL) { crm_err("TLS session creation failed"); close(csock); return TRUE; } new_client = calloc(1, sizeof(crm_client_t)); new_client->remote = calloc(1, sizeof(crm_remote_t)); new_client->kind = CRM_CLIENT_TLS; new_client->remote->tls_session = session; new_client->id = crm_generate_uuid(); new_client->remote->auth_timeout = g_timeout_add(LRMD_REMOTE_AUTH_TIMEOUT, lrmd_auth_timeout_cb, new_client); crm_notice("LRMD client connection established. %p id: %s", new_client, new_client->id); new_client->remote->source = mainloop_add_fd("lrmd-remote-client", G_PRIORITY_DEFAULT, csock, new_client, &lrmd_remote_fd_cb); g_hash_table_insert(client_connections, new_client->id, new_client); /* Alert other clients of the new connection */ notify_of_new_client(new_client); return TRUE; }
1
Chrome
e89cfcb9090e8c98129ae9160c513f504db74599
CVE-2012-5148
CWE-20
void Browser::TabDetachedAtImpl(TabContents* contents, int index, DetachType type) { if (type == DETACH_TYPE_DETACH) { if (contents == chrome::GetActiveTabContents(this)) { LocationBar* location_bar = window()->GetLocationBar(); if (location_bar) location_bar->SaveStateToContents(contents->web_contents()); } if (!tab_strip_model_->closing_all()) SyncHistoryWithTabs(0); } SetAsDelegate(contents->web_contents(), NULL); RemoveScheduledUpdatesFor(contents->web_contents()); if (find_bar_controller_.get() && index == active_index()) { find_bar_controller_->ChangeWebContents(NULL); } search_delegate_->OnTabDetached(contents->web_contents()); registrar_.Remove(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED, content::Source<WebContents>(contents->web_contents())); registrar_.Remove(this, content::NOTIFICATION_INTERSTITIAL_DETACHED, content::Source<WebContents>(contents->web_contents())); }
1
pango
4de30e5500eaeb49f4bf0b7a07f718e149a2ed5e
NOT_APPLICABLE
NOT_APPLICABLE
pango_glyph_string_new (void) { PangoGlyphString *string = g_slice_new (PangoGlyphString); string->num_glyphs = 0; string->space = 0; string->glyphs = NULL; string->log_clusters = NULL; return string; }
0
php
6aeee47b2cd47915ccfa3b41433a3f57aea24dd5
NOT_APPLICABLE
NOT_APPLICABLE
PHP_FUNCTION(strrpos) { zval *zneedle; char *needle; zend_string *haystack; size_t needle_len; zend_long offset = 0; char *p, *e, ord_needle[2]; char *found; #ifndef FAST_ZPP if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz|l", &haystack, &zneedle, &offset) == FAILURE) { RETURN_FALSE; } #else ZEND_PARSE_PARAMETERS_START(2, 3) Z_PARAM_STR(haystack) Z_PARAM_ZVAL(zneedle) Z_PARAM_OPTIONAL Z_PARAM_LONG(offset) ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE); #endif if (Z_TYPE_P(zneedle) == IS_STRING) { needle = Z_STRVAL_P(zneedle); needle_len = Z_STRLEN_P(zneedle); } else { if (php_needle_char(zneedle, ord_needle) != SUCCESS) { RETURN_FALSE; } ord_needle[1] = '\0'; needle = ord_needle; needle_len = 1; } if ((ZSTR_LEN(haystack) == 0) || (needle_len == 0)) { RETURN_FALSE; } if (offset >= 0) { if ((size_t)offset > ZSTR_LEN(haystack)) { php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string"); RETURN_FALSE; } p = ZSTR_VAL(haystack) + (size_t)offset; e = ZSTR_VAL(haystack) + ZSTR_LEN(haystack); } else { if (offset < -INT_MAX || (size_t)(-offset) > ZSTR_LEN(haystack)) { php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string"); RETURN_FALSE; } p = ZSTR_VAL(haystack); if (-offset < needle_len) { e = ZSTR_VAL(haystack) + ZSTR_LEN(haystack); } else { e = ZSTR_VAL(haystack) + ZSTR_LEN(haystack) + offset + needle_len; } } if ((found = (char *)zend_memnrstr(p, needle, needle_len, e))) { RETURN_LONG(found - ZSTR_VAL(haystack)); } RETURN_FALSE; }
0
poppler
e853106b58d6b4b0467dbd6436c9bb1cfbd372cf
NOT_APPLICABLE
NOT_APPLICABLE
void Gfx::pushStateGuard() { stateGuards.push_back(stackHeight); }
0
FFmpeg
454a11a1c9c686c78aa97954306fb63453299760
NOT_APPLICABLE
NOT_APPLICABLE
static int pix_norm1_c(uint8_t * pix, int line_size) { int s, i, j; uint32_t *sq = ff_squareTbl + 256; s = 0; for (i = 0; i < 16; i++) { for (j = 0; j < 16; j += 8) { #if 0 s += sq[pix[0]]; s += sq[pix[1]]; s += sq[pix[2]]; s += sq[pix[3]]; s += sq[pix[4]]; s += sq[pix[5]]; s += sq[pix[6]]; s += sq[pix[7]]; #else #if HAVE_FAST_64BIT register uint64_t x=*(uint64_t*)pix; s += sq[x&0xff]; s += sq[(x>>8)&0xff]; s += sq[(x>>16)&0xff]; s += sq[(x>>24)&0xff]; s += sq[(x>>32)&0xff]; s += sq[(x>>40)&0xff]; s += sq[(x>>48)&0xff]; s += sq[(x>>56)&0xff]; #else register uint32_t x=*(uint32_t*)pix; s += sq[x&0xff]; s += sq[(x>>8)&0xff]; s += sq[(x>>16)&0xff]; s += sq[(x>>24)&0xff]; x=*(uint32_t*)(pix+4); s += sq[x&0xff]; s += sq[(x>>8)&0xff]; s += sq[(x>>16)&0xff]; s += sq[(x>>24)&0xff]; #endif #endif pix += 8; } pix += line_size - 16; } return s; }
0
linux
0305cd5f7fca85dae392b9ba85b116896eb7c1c7
NOT_APPLICABLE
NOT_APPLICABLE
static void btrfs_retry_endio(struct bio *bio) { struct btrfs_retry_complete *done = bio->bi_private; struct btrfs_io_bio *io_bio = btrfs_io_bio(bio); struct bio_vec *bvec; int uptodate; int ret; int i; if (bio->bi_error) goto end; uptodate = 1; bio_for_each_segment_all(bvec, bio, i) { ret = __readpage_endio_check(done->inode, io_bio, i, bvec->bv_page, 0, done->start, bvec->bv_len); if (!ret) clean_io_failure(done->inode, done->start, bvec->bv_page, 0); else uptodate = 0; } done->uptodate = uptodate; end: complete(&done->done); bio_put(bio); }
0
cinnamon-screensaver
da7af55f1fa966c52e15cc288d4f8928eca8cc9f
NOT_APPLICABLE
NOT_APPLICABLE
gs_window_real_get_preferred_height (GtkWidget *widget, gint *minimal_height, gint *natural_height) { GtkRequisition requisition; gs_window_real_size_request (widget, &requisition); *minimal_height = *natural_height = requisition.height; }
0
Pillow
3fee28eb9479bf7d59e0fa08068f9cc4a6e2f04c
NOT_APPLICABLE
NOT_APPLICABLE
_tiffNullMapProc(thandle_t hdata, tdata_t *pbase, toff_t *psize) { (void)hdata; (void)pbase; (void)psize; return (0); }
0
libx11
8d2e02ae650f00c4a53deb625211a0527126c605
NOT_APPLICABLE
NOT_APPLICABLE
XSetWMHints ( Display *dpy, Window w, XWMHints *wmhints) { xPropWMHints prop; memset(&prop, 0, sizeof(prop)); prop.flags = wmhints->flags; if (wmhints->flags & InputHint) prop.input = (wmhints->input == True ? 1 : 0); if (wmhints->flags & StateHint) prop.initialState = wmhints->initial_state; if (wmhints->flags & IconPixmapHint) prop.iconPixmap = wmhints->icon_pixmap; if (wmhints->flags & IconWindowHint) prop.iconWindow = wmhints->icon_window; if (wmhints->flags & IconPositionHint) { prop.iconX = wmhints->icon_x; prop.iconY = wmhints->icon_y; } if (wmhints->flags & IconMaskHint) prop.iconMask = wmhints->icon_mask; if (wmhints->flags & WindowGroupHint) prop.windowGroup = wmhints->window_group; return XChangeProperty (dpy, w, XA_WM_HINTS, XA_WM_HINTS, 32, PropModeReplace, (unsigned char *) &prop, NumPropWMHintsElements); }
0
Chrome
fff450abc4e2fb330ba700547a8e6a7b0fb90a6e
NOT_APPLICABLE
NOT_APPLICABLE
void OutOfProcessInstance::SearchString(const base::char16* string, const base::char16* term, bool case_sensitive, std::vector<SearchStringResult>* results) { PP_PrivateFindResult* pp_results; int count = 0; pp::PDF::SearchString( this, reinterpret_cast<const unsigned short*>(string), reinterpret_cast<const unsigned short*>(term), case_sensitive, &pp_results, &count); results->resize(count); for (int i = 0; i < count; ++i) { (*results)[i].start_index = pp_results[i].start_index; (*results)[i].length = pp_results[i].length; } pp::Memory_Dev memory; memory.MemFree(pp_results); }
0
mysql-wsrep
4ea4b0c6a318209ac09b15aaa906c7b4a13b988c
NOT_APPLICABLE
NOT_APPLICABLE
bool wsrep_before_SE() { return (wsrep_provider != NULL && strcmp (wsrep_provider, WSREP_NONE) && strcmp (wsrep_sst_method, WSREP_SST_SKIP) && strcmp (wsrep_sst_method, WSREP_SST_MYSQLDUMP)); }
0
ruby
1c2ef610358af33f9ded3086aa2d70aac03dcac5
NOT_APPLICABLE
NOT_APPLICABLE
str_strlen(VALUE str, rb_encoding *enc) { const char *p, *e; long n; int cr; if (single_byte_optimizable(str)) return RSTRING_LEN(str); if (!enc) enc = STR_ENC_GET(str); p = RSTRING_PTR(str); e = RSTRING_END(str); cr = ENC_CODERANGE(str); #ifdef NONASCII_MASK if (ENC_CODERANGE(str) == ENC_CODERANGE_VALID && enc == rb_utf8_encoding()) { VALUE len = 0; if ((int)sizeof(VALUE) * 2 < e - p) { const VALUE *s, *t; const VALUE lowbits = sizeof(VALUE) - 1; s = (const VALUE*)(~lowbits & ((VALUE)p + lowbits)); t = (const VALUE*)(~lowbits & (VALUE)e); while (p < (const char *)s) { if (is_utf8_lead_byte(*p)) len++; p++; } while (s < t) { len += count_utf8_lead_bytes_with_word(s); s++; } p = (const char *)s; } while (p < e) { if (is_utf8_lead_byte(*p)) len++; p++; } return (long)len; } #endif n = rb_enc_strlen_cr(p, e, enc, &cr); if (cr) { ENC_CODERANGE_SET(str, cr); } return n; }
0
jdk11u
132745902a4601dc64b2c8ca112ca30292feccb4
NOT_APPLICABLE
NOT_APPLICABLE
void CallInfo::set_handle(const methodHandle& resolved_method, Handle resolved_appendix, Handle resolved_method_type, TRAPS) { set_handle(SystemDictionary::MethodHandle_klass(), resolved_method, resolved_appendix, resolved_method_type, CHECK); }
0
openssl
fb8d9ddb9dc19d84dffa84932f75e607c8a3ffe6
CVE-2014-0224
CWE-326
int ssl3_get_server_hello(SSL *s) { STACK_OF(SSL_CIPHER) *sk; const SSL_CIPHER *c; CERT *ct = s->cert; unsigned char *p,*d; int i,al=SSL_AD_INTERNAL_ERROR,ok; unsigned int j; long n; #ifndef OPENSSL_NO_COMP SSL_COMP *comp; #endif /* Hello verify request and/or server hello version may not * match so set first packet if we're negotiating version. */ if (SSL_IS_DTLS(s)) s->first_packet = 1; n=s->method->ssl_get_message(s, SSL3_ST_CR_SRVR_HELLO_A, SSL3_ST_CR_SRVR_HELLO_B, -1, 20000, /* ?? */ &ok); if (!ok) return((int)n); if (SSL_IS_DTLS(s)) { s->first_packet = 0; if ( s->s3->tmp.message_type == DTLS1_MT_HELLO_VERIFY_REQUEST) { if ( s->d1->send_cookie == 0) { s->s3->tmp.reuse_message = 1; return 1; } else /* already sent a cookie */ { al=SSL_AD_UNEXPECTED_MESSAGE; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_BAD_MESSAGE_TYPE); goto f_err; } } } if ( s->s3->tmp.message_type != SSL3_MT_SERVER_HELLO) { al=SSL_AD_UNEXPECTED_MESSAGE; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_BAD_MESSAGE_TYPE); goto f_err; } d=p=(unsigned char *)s->init_msg; if (s->method->version == DTLS_ANY_VERSION) { /* Work out correct protocol version to use */ int hversion = (p[0] << 8)|p[1]; int options = s->options; if (hversion == DTLS1_2_VERSION && !(options & SSL_OP_NO_DTLSv1_2)) s->method = DTLSv1_2_client_method(); else if (tls1_suiteb(s)) { SSLerr(SSL_F_SSL3_GET_SERVER_HELLO, SSL_R_ONLY_DTLS_1_2_ALLOWED_IN_SUITEB_MODE); s->version = hversion; al = SSL_AD_PROTOCOL_VERSION; goto f_err; } else if (hversion == DTLS1_VERSION && !(options & SSL_OP_NO_DTLSv1)) s->method = DTLSv1_client_method(); else { SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_WRONG_SSL_VERSION); s->version = hversion; al = SSL_AD_PROTOCOL_VERSION; goto f_err; } s->version = s->client_version = s->method->version; } if ((p[0] != (s->version>>8)) || (p[1] != (s->version&0xff))) { SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_WRONG_SSL_VERSION); s->version=(s->version&0xff00)|p[1]; al=SSL_AD_PROTOCOL_VERSION; goto f_err; } p+=2; /* load the server hello data */ /* load the server random */ memcpy(s->s3->server_random,p,SSL3_RANDOM_SIZE); p+=SSL3_RANDOM_SIZE; /* get the session-id */ j= *(p++); if ((j > sizeof s->session->session_id) || (j > SSL3_SESSION_ID_SIZE)) { al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_SSL3_SESSION_ID_TOO_LONG); goto f_err; } #ifndef OPENSSL_NO_TLSEXT /* check if we want to resume the session based on external pre-shared secret */ if (s->version >= TLS1_VERSION && s->tls_session_secret_cb) { SSL_CIPHER *pref_cipher=NULL; s->session->master_key_length=sizeof(s->session->master_key); if (s->tls_session_secret_cb(s, s->session->master_key, &s->session->master_key_length, NULL, &pref_cipher, s->tls_session_secret_cb_arg)) { s->session->cipher = pref_cipher ? pref_cipher : ssl_get_cipher_by_char(s, p+j); } } #endif /* OPENSSL_NO_TLSEXT */ if (j != 0 && j == s->session->session_id_length && memcmp(p,s->session->session_id,j) == 0) { if(s->sid_ctx_length != s->session->sid_ctx_length || memcmp(s->session->sid_ctx,s->sid_ctx,s->sid_ctx_length)) { /* actually a client application bug */ al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT); goto f_err; } s->s3->flags |= SSL3_FLAGS_CCS_OK; s->hit=1; } else /* a miss or crap from the other end */ { /* If we were trying for session-id reuse, make a new * SSL_SESSION so we don't stuff up other people */ s->hit=0; if (s->session->session_id_length > 0) { if (!ssl_get_new_session(s,0)) { goto f_err; } } s->session->session_id_length=j; memcpy(s->session->session_id,p,j); /* j could be 0 */ } p+=j; c=ssl_get_cipher_by_char(s,p); if (c == NULL) { /* unknown cipher */ al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_UNKNOWN_CIPHER_RETURNED); goto f_err; } /* Set version disabled mask now we know version */ if (!SSL_USE_TLS1_2_CIPHERS(s)) ct->mask_ssl = SSL_TLSV1_2; else ct->mask_ssl = 0; /* If it is a disabled cipher we didn't send it in client hello, * so return an error. */ if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_CHECK)) { al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_WRONG_CIPHER_RETURNED); goto f_err; } p+=ssl_put_cipher_by_char(s,NULL,NULL); sk=ssl_get_ciphers_by_id(s); i=sk_SSL_CIPHER_find(sk,c); if (i < 0) { /* we did not say we would use this cipher */ al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_WRONG_CIPHER_RETURNED); goto f_err; } /* Depending on the session caching (internal/external), the cipher and/or cipher_id values may not be set. Make sure that cipher_id is set and use it for comparison. */ if (s->session->cipher) s->session->cipher_id = s->session->cipher->id; if (s->hit && (s->session->cipher_id != c->id)) { /* Workaround is now obsolete */ #if 0 if (!(s->options & SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG)) #endif { al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED); goto f_err; } } s->s3->tmp.new_cipher=c; /* Don't digest cached records if no sigalgs: we may need them for * client authentication. */ if (!SSL_USE_SIGALGS(s) && !ssl3_digest_cached_records(s)) goto f_err; /* lets get the compression algorithm */ /* COMPRESSION */ #ifdef OPENSSL_NO_COMP if (*(p++) != 0) { al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM); goto f_err; } /* If compression is disabled we'd better not try to resume a session * using compression. */ if (s->session->compress_meth != 0) { SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_INCONSISTENT_COMPRESSION); goto f_err; } #else j= *(p++); if (s->hit && j != s->session->compress_meth) { al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED); goto f_err; } if (j == 0) comp=NULL; else if (!ssl_allow_compression(s)) { al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_COMPRESSION_DISABLED); goto f_err; } else comp=ssl3_comp_find(s->ctx->comp_methods,j); if ((j != 0) && (comp == NULL)) { al=SSL_AD_ILLEGAL_PARAMETER; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM); goto f_err; } else { s->s3->tmp.new_compression=comp; } #endif #ifndef OPENSSL_NO_TLSEXT /* TLS extensions*/ if (!ssl_parse_serverhello_tlsext(s,&p,d,n)) { SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_PARSE_TLSEXT); goto err; } #endif if (p != (d+n)) { /* wrong packet length */ al=SSL_AD_DECODE_ERROR; SSLerr(SSL_F_SSL3_GET_SERVER_HELLO,SSL_R_BAD_PACKET_LENGTH); goto f_err; } return(1); f_err: ssl3_send_alert(s,SSL3_AL_FATAL,al); err: return(-1); }
1
mbedtls
298a43a77ec0ed2c19a8c924ddd8571ef3e65dfd
NOT_APPLICABLE
NOT_APPLICABLE
void mbedtls_ecp_point_free( mbedtls_ecp_point *pt ) { if( pt == NULL ) return; mbedtls_mpi_free( &( pt->X ) ); mbedtls_mpi_free( &( pt->Y ) ); mbedtls_mpi_free( &( pt->Z ) ); }
0
Chrome
eb4d5d9ab41449b79fcf6f84d8983be2b12bd490
NOT_APPLICABLE
NOT_APPLICABLE
void ContainerNode::focusStateChanged() { if (!layoutObject()) return; if (styleChangeType() < SubtreeStyleChange) { if (computedStyle()->affectedByFocus() && computedStyle()->hasPseudoStyle(FIRST_LETTER)) setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::createWithExtraData(StyleChangeReason::PseudoClass, StyleChangeExtraData::Focus)); else if (isElementNode() && toElement(this)->childrenOrSiblingsAffectedByFocus()) document().styleEngine().pseudoStateChangedForElement(CSSSelector::PseudoFocus, *toElement(this)); else if (computedStyle()->affectedByFocus()) setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::createWithExtraData(StyleChangeReason::PseudoClass, StyleChangeExtraData::Focus)); } LayoutTheme::theme().controlStateChanged(*layoutObject(), FocusControlState); }
0
savannah
8b281f83e8516535756f92dbf90940ac44bd45e1
NOT_APPLICABLE
NOT_APPLICABLE
cid_load_keyword( CID_Face face, CID_Loader* loader, const T1_Field keyword ) { FT_Error error; CID_Parser* parser = &loader->parser; FT_Byte* object; void* dummy_object; CID_FaceInfo cid = &face->cid; /* if the keyword has a dedicated callback, call it */ if ( keyword->type == T1_FIELD_TYPE_CALLBACK ) { keyword->reader( (FT_Face)face, parser ); error = parser->root.error; goto Exit; } /* we must now compute the address of our target object */ switch ( keyword->location ) { case T1_FIELD_LOCATION_CID_INFO: object = (FT_Byte*)cid; break; case T1_FIELD_LOCATION_FONT_INFO: object = (FT_Byte*)&cid->font_info; break; case T1_FIELD_LOCATION_FONT_EXTRA: object = (FT_Byte*)&face->font_extra; break; case T1_FIELD_LOCATION_BBOX: object = (FT_Byte*)&cid->font_bbox; break; default: { CID_FaceDict dict; if ( parser->num_dict < 0 || parser->num_dict >= cid->num_dicts ) { FT_ERROR(( "cid_load_keyword: invalid use of `%s'\n", keyword->ident )); error = FT_THROW( Syntax_Error ); goto Exit; } dict = cid->font_dicts + parser->num_dict; switch ( keyword->location ) { case T1_FIELD_LOCATION_PRIVATE: object = (FT_Byte*)&dict->private_dict; break; default: object = (FT_Byte*)dict; } } } dummy_object = object; /* now, load the keyword data in the object's field(s) */ if ( keyword->type == T1_FIELD_TYPE_INTEGER_ARRAY || keyword->type == T1_FIELD_TYPE_FIXED_ARRAY ) error = cid_parser_load_field_table( &loader->parser, keyword, &dummy_object ); else error = cid_parser_load_field( &loader->parser, keyword, &dummy_object ); Exit: return error; }
0
linux
af3ff8045bbf3e32f1a448542e73abb4c8ceb6f1
NOT_APPLICABLE
NOT_APPLICABLE
static int shash_update_unaligned(struct shash_desc *desc, const u8 *data, unsigned int len) { struct crypto_shash *tfm = desc->tfm; struct shash_alg *shash = crypto_shash_alg(tfm); unsigned long alignmask = crypto_shash_alignmask(tfm); unsigned int unaligned_len = alignmask + 1 - ((unsigned long)data & alignmask); u8 ubuf[shash_align_buffer_size(unaligned_len, alignmask)] __aligned_largest; u8 *buf = PTR_ALIGN(&ubuf[0], alignmask + 1); int err; if (unaligned_len > len) unaligned_len = len; memcpy(buf, data, unaligned_len); err = shash->update(desc, buf, unaligned_len); memset(buf, 0, unaligned_len); return err ?: shash->update(desc, data + unaligned_len, len - unaligned_len); }
0
qemu
5193be3be35f29a35bc465036cd64ad60d43385f
NOT_APPLICABLE
NOT_APPLICABLE
static uint16_t tsc2102_data_register_read(TSC210xState *s, int reg) { switch (reg) { case 0x00: /* X */ s->dav &= 0xfbff; return TSC_CUT_RESOLUTION(X_TRANSFORM(s), s->precision) + (s->noise & 3); case 0x01: /* Y */ s->noise ++; s->dav &= 0xfdff; return TSC_CUT_RESOLUTION(Y_TRANSFORM(s), s->precision) ^ (s->noise & 3); case 0x02: /* Z1 */ s->dav &= 0xfeff; return TSC_CUT_RESOLUTION(Z1_TRANSFORM(s), s->precision) - (s->noise & 3); case 0x03: /* Z2 */ s->dav &= 0xff7f; return TSC_CUT_RESOLUTION(Z2_TRANSFORM(s), s->precision) | (s->noise & 3); case 0x04: /* KPData */ if ((s->model & 0xff00) == 0x2300) { if (s->kb.intr && (s->kb.mode & 2)) { s->kb.intr = 0; qemu_irq_raise(s->kbint); } return s->kb.down; } return 0xffff; case 0x05: /* BAT1 */ s->dav &= 0xffbf; return TSC_CUT_RESOLUTION(BAT1_VAL, s->precision) + (s->noise & 6); case 0x06: /* BAT2 */ s->dav &= 0xffdf; return TSC_CUT_RESOLUTION(BAT2_VAL, s->precision); case 0x07: /* AUX1 */ s->dav &= 0xffef; return TSC_CUT_RESOLUTION(AUX1_VAL, s->precision); case 0x08: /* AUX2 */ s->dav &= 0xfff7; return 0xffff; case 0x09: /* TEMP1 */ s->dav &= 0xfffb; return TSC_CUT_RESOLUTION(TEMP1_VAL, s->precision) - (s->noise & 5); case 0x0a: /* TEMP2 */ s->dav &= 0xfffd; return TSC_CUT_RESOLUTION(TEMP2_VAL, s->precision) ^ (s->noise & 3); case 0x0b: /* DAC */ s->dav &= 0xfffe; return 0xffff; default: #ifdef TSC_VERBOSE fprintf(stderr, "tsc2102_data_register_read: " "no such register: 0x%02x\n", reg); #endif return 0xffff; } }
0
cracklib
33d7fa4585247cd2247a1ffa032ad245836c6edb
NOT_APPLICABLE
NOT_APPLICABLE
Debug(val, a, b, c, d, e, f, g) int val; char *a, *b, *c, *d, *e, *f, *g; { fprintf(stderr, a, b, c, d, e, f, g); }
0
mysql-server
5ac61b2af0cf37eeed5050a91819d6d273f037a5
NOT_APPLICABLE
NOT_APPLICABLE
get_one_option(int optid, const struct my_option *opt __attribute__((unused)), char *argument) { switch(optid) { case OPT_CHARSETS_DIR: strmake(mysql_charsets_dir, argument, sizeof(mysql_charsets_dir) - 1); charsets_dir = mysql_charsets_dir; break; case OPT_DELIMITER: if (argument == disabled_my_option) { strmov(delimiter, DEFAULT_DELIMITER); } else { /* Check that delimiter does not contain a backslash */ if (!strstr(argument, "\\")) { strmake(delimiter, argument, sizeof(delimiter) - 1); } else { put_info("DELIMITER cannot contain a backslash character", INFO_ERROR); return 0; } } delimiter_length= (uint)strlen(delimiter); delimiter_str= delimiter; break; case OPT_LOCAL_INFILE: using_opt_local_infile=1; break; case OPT_ENABLE_CLEARTEXT_PLUGIN: using_opt_enable_cleartext_plugin= TRUE; break; case OPT_TEE: if (argument == disabled_my_option) { if (opt_outfile) end_tee(); } else init_tee(argument); break; case OPT_PAGER: if (argument == disabled_my_option) opt_nopager= 1; else { opt_nopager= 0; if (argument && strlen(argument)) { default_pager_set= 1; strmake(pager, argument, sizeof(pager) - 1); strmov(default_pager, pager); } else if (default_pager_set) strmov(pager, default_pager); else opt_nopager= 1; } break; case OPT_MYSQL_PROTOCOL: #ifndef EMBEDDED_LIBRARY opt_protocol= find_type_or_exit(argument, &sql_protocol_typelib, opt->name); #endif break; case OPT_SERVER_ARG: #ifdef EMBEDDED_LIBRARY /* When the embedded server is being tested, the client needs to be able to pass command-line arguments to the embedded server so it can locate the language files and data directory. */ if (!embedded_server_arg_count) { embedded_server_arg_count= 1; embedded_server_args[0]= (char*) ""; } if (embedded_server_arg_count == MAX_SERVER_ARGS-1 || !(embedded_server_args[embedded_server_arg_count++]= my_strdup(argument, MYF(MY_FAE)))) { put_info("Can't use server argument", INFO_ERROR); return 0; } #else /*EMBEDDED_LIBRARY */ printf("WARNING: --server-arg option not supported in this configuration.\n"); #endif break; case 'A': opt_rehash= 0; break; case 'N': column_names= 0; break; case 'e': status.batch= 1; status.add_to_history= 0; if (!status.line_buff) ignore_errors= 0; // do it for the first -e only if (!(status.line_buff= batch_readline_command(status.line_buff, argument))) return 1; break; case 'o': if (argument == disabled_my_option) one_database= 0; else one_database= skip_updates= 1; break; case 'p': if (argument == disabled_my_option) argument= (char*) ""; // Don't require password if (argument) { char *start= argument; my_free(opt_password); opt_password= my_strdup(argument, MYF(MY_FAE)); while (*argument) *argument++= 'x'; // Destroy argument if (*start) start[1]=0 ; tty_password= 0; } else tty_password= 1; break; case '#': DBUG_PUSH(argument ? argument : default_dbug_option); debug_info_flag= 1; break; case 's': if (argument == disabled_my_option) opt_silent= 0; else opt_silent++; break; case 'v': if (argument == disabled_my_option) verbose= 0; else verbose++; break; case 'B': status.batch= 1; status.add_to_history= 0; set_if_bigger(opt_silent,1); // more silent break; case 'W': #ifdef __WIN__ opt_protocol = MYSQL_PROTOCOL_PIPE; #endif break; #include <sslopt-case.h> case 'V': usage(1); exit(0); case 'I': case '?': usage(0); exit(0); } return 0; }
0
scylladb
1c2eef384da439b0457b6d71c7e37d7268e471cb
NOT_APPLICABLE
NOT_APPLICABLE
void cql_server::connection::write_response(foreign_ptr<std::unique_ptr<cql_server::response>>&& response, service_permit permit, cql_compression compression) { _ready_to_respond = _ready_to_respond.then([this, compression, response = std::move(response), permit = std::move(permit)] () mutable { auto message = response->make_message(_version, compression); message.on_delete([response = std::move(response)] { }); return _write_buf.write(std::move(message)).then([this] { return _write_buf.flush(); }); }); }
0
php-src
996faf964bba1aec06b153b370a7f20d3dd2bb8b?w=1
NOT_APPLICABLE
NOT_APPLICABLE
static int sapi_extract_response_code(const char *header_line) { int code = 200; const char *ptr; for (ptr = header_line; *ptr; ptr++) { if (*ptr == ' ' && *(ptr + 1) != ' ') { code = atoi(ptr + 1); break; } } return code; }
0
Chrome
957973753ec4159003ff7930d946b7e89c7e09f3
NOT_APPLICABLE
NOT_APPLICABLE
void BlobURLRequestJob::SetExtraRequestHeaders( const net::HttpRequestHeaders& headers) { std::string range_header; if (headers.GetHeader(net::HttpRequestHeaders::kRange, &range_header)) { std::vector<net::HttpByteRange> ranges; if (net::HttpUtil::ParseRangeHeader(range_header, &ranges)) { if (ranges.size() == 1) { byte_range_set_ = true; byte_range_ = ranges[0]; } else { NotifyFailure(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE); } } } }
0
haproxy
3b69886f7dcc3cfb3d166309018e6cfec9ce2c95
NOT_APPLICABLE
NOT_APPLICABLE
static inline void htx_reset(struct htx *htx) { htx->tail = htx->head = htx->first = -1; htx->data = 0; htx->tail_addr = htx->head_addr = htx->end_addr = 0; htx->extra = 0; htx->flags = HTX_FL_NONE; }
0
linux
1ee0a224bc9aad1de496c795f96bc6ba2c394811
NOT_APPLICABLE
NOT_APPLICABLE
static void edge_close(struct usb_serial_port *port) { struct edgeport_serial *edge_serial; struct edgeport_port *edge_port; struct usb_serial *serial = port->serial; int port_number; edge_serial = usb_get_serial_data(port->serial); edge_port = usb_get_serial_port_data(port); if (edge_serial == NULL || edge_port == NULL) return; /* The bulkreadcompletion routine will check * this flag and dump add read data */ edge_port->close_pending = 1; /* chase the port close and flush */ chase_port(edge_port, (HZ * closing_wait) / 100, 1); usb_kill_urb(port->read_urb); usb_kill_urb(port->write_urb); edge_port->ep_write_urb_in_use = 0; /* assuming we can still talk to the device, * send a close port command to it */ dev_dbg(&port->dev, "%s - send umpc_close_port\n", __func__); port_number = port->number - port->serial->minor; mutex_lock(&serial->disc_mutex); if (!serial->disconnected) { send_cmd(serial->dev, UMPC_CLOSE_PORT, (__u8)(UMPM_UART1_PORT + port_number), 0, NULL, 0); } mutex_unlock(&serial->disc_mutex); mutex_lock(&edge_serial->es_lock); --edge_port->edge_serial->num_ports_open; if (edge_port->edge_serial->num_ports_open <= 0) { /* last port is now closed, let's shut down our interrupt urb */ usb_kill_urb(port->serial->port[0]->interrupt_in_urb); edge_port->edge_serial->num_ports_open = 0; } mutex_unlock(&edge_serial->es_lock); edge_port->close_pending = 0; }
0
linux
12d6e7538e2d418c08f082b1b44ffa5fb7270ed8
NOT_APPLICABLE
NOT_APPLICABLE
pfn_t gfn_to_pfn_memslot(struct kvm_memory_slot *slot, gfn_t gfn) { return __gfn_to_pfn_memslot(slot, gfn, false, NULL, true, NULL); }
0
FFmpeg
821a5938d100458f4d09d634041b05c860554ce0
CVE-2013-7013
CWE-189
static int g2m_init_buffers(G2MContext *c) { int aligned_height; if (!c->framebuf || c->old_width < c->width || c->old_height < c->height) { c->framebuf_stride = FFALIGN(c->width * 3, 16); aligned_height = FFALIGN(c->height, 16); av_free(c->framebuf); c->framebuf = av_mallocz(c->framebuf_stride * aligned_height); if (!c->framebuf) return AVERROR(ENOMEM); } if (!c->synth_tile || !c->jpeg_tile || c->old_tile_w < c->tile_width || c->old_tile_h < c->tile_height) { c->tile_stride = FFALIGN(c->tile_width * 3, 16); aligned_height = FFALIGN(c->tile_height, 16); av_free(c->synth_tile); av_free(c->jpeg_tile); av_free(c->kempf_buf); av_free(c->kempf_flags); c->synth_tile = av_mallocz(c->tile_stride * aligned_height); c->jpeg_tile = av_mallocz(c->tile_stride * aligned_height); c->kempf_buf = av_mallocz((c->tile_width + 1) * aligned_height + FF_INPUT_BUFFER_PADDING_SIZE); c->kempf_flags = av_mallocz( c->tile_width * aligned_height); if (!c->synth_tile || !c->jpeg_tile || !c->kempf_buf || !c->kempf_flags) return AVERROR(ENOMEM); } return 0; }
1
php-src
4605d536d23b00813d11cc906bb48d39bdcf5f25
NOT_APPLICABLE
NOT_APPLICABLE
static int multipart_buffer_eof(multipart_buffer *self TSRMLS_DC) { if ( (self->bytes_in_buffer == 0 && fill_buffer(self TSRMLS_CC) < 1) ) { return 1; } else { return 0; } }
0
Chrome
6b96dd532af164a73f2aac757bafff58211aca2c
NOT_APPLICABLE
NOT_APPLICABLE
ScopedJavaLocalRef<jstring> WebContentsAndroid::GetTitle( JNIEnv* env, jobject obj) const { return base::android::ConvertUTF16ToJavaString(env, web_contents_->GetTitle()); }
0
Chrome
5925dff83699508b5e2735afb0297dfb310e159d
NOT_APPLICABLE
NOT_APPLICABLE
bool Browser::TakeFocus(bool reverse) { NotificationService::current()->Notify( chrome::NOTIFICATION_FOCUS_RETURNED_TO_BROWSER, Source<Browser>(this), NotificationService::NoDetails()); return false; }
0
linux-2.6
822191a2fa1584a29c3224ab328507adcaeac1ab
NOT_APPLICABLE
NOT_APPLICABLE
asmlinkage long compat_sys_utime(char __user *filename, struct compat_utimbuf __user *t) { struct timeval tv[2]; if (t) { if (get_user(tv[0].tv_sec, &t->actime) || get_user(tv[1].tv_sec, &t->modtime)) return -EFAULT; tv[0].tv_usec = 0; tv[1].tv_usec = 0; } return do_utimes(AT_FDCWD, filename, t ? tv : NULL); }
0
linux
999653786df6954a31044528ac3f7a5dadca08f4
NOT_APPLICABLE
NOT_APPLICABLE
static inline void allow_bits(struct posix_ace_state *astate, u32 mask) { /* Allow all bits in the mask not already denied: */ astate->allow |= mask & ~astate->deny; }
0
nanopb
aa9d0d1ca78d6adec3adfeecf3a706c7f9df81f2
NOT_APPLICABLE
NOT_APPLICABLE
static bool checkreturn decode_callback_field(pb_istream_t *stream, pb_wire_type_t wire_type, pb_field_iter_t *iter) { pb_callback_t *pCallback = (pb_callback_t*)iter->pData; #ifdef PB_OLD_CALLBACK_STYLE void *arg; #else void **arg; #endif if (pCallback == NULL || pCallback->funcs.decode == NULL) return pb_skip_field(stream, wire_type); #ifdef PB_OLD_CALLBACK_STYLE arg = pCallback->arg; #else arg = &(pCallback->arg); #endif if (wire_type == PB_WT_STRING) { pb_istream_t substream; if (!pb_make_string_substream(stream, &substream)) return false; do { if (!pCallback->funcs.decode(&substream, iter->pos, arg)) PB_RETURN_ERROR(stream, "callback failed"); } while (substream.bytes_left); if (!pb_close_string_substream(stream, &substream)) return false; return true; } else { /* Copy the single scalar value to stack. * This is required so that we can limit the stream length, * which in turn allows to use same callback for packed and * not-packed fields. */ pb_istream_t substream; pb_byte_t buffer[10]; size_t size = sizeof(buffer); if (!read_raw_value(stream, wire_type, buffer, &size)) return false; substream = pb_istream_from_buffer(buffer, size); return pCallback->funcs.decode(&substream, iter->pos, arg); } }
0
ovs
0befd1f3745055c32940f5faf9559be6a14395e6
NOT_APPLICABLE
NOT_APPLICABLE
handle_port_desc_stats_request(struct ofconn *ofconn, const struct ofp_header *request) { ofp_port_t port_no; enum ofperr error; error = ofputil_decode_port_desc_stats_request(request, &port_no); if (!error) { handle_port_request(ofconn, request, port_no, append_port_desc); } return error; }
0
linux
51ebd3181572af8d5076808dab2682d800f6da5d
NOT_APPLICABLE
NOT_APPLICABLE
static struct rt6_info *ip6_pol_route_lookup(struct net *net, struct fib6_table *table, struct flowi6 *fl6, int flags) { struct fib6_node *fn; struct rt6_info *rt; read_lock_bh(&table->tb6_lock); fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr); restart: rt = fn->leaf; rt = rt6_device_match(net, rt, &fl6->saddr, fl6->flowi6_oif, flags); if (rt->rt6i_nsiblings && fl6->flowi6_oif == 0) rt = rt6_multipath_select(rt, fl6); BACKTRACK(net, &fl6->saddr); out: dst_use(&rt->dst, jiffies); read_unlock_bh(&table->tb6_lock); return rt; }
0
Chrome
e21bdfb9c758ac411012ad84f83d26d3f7dd69fb
NOT_APPLICABLE
NOT_APPLICABLE
EventRouter* TestExtensionSystem::event_router() { return NULL; }
0
linux
c2183d1e9b3f313dd8ba2b1b0197c8d9fb86a7ae
NOT_APPLICABLE
NOT_APPLICABLE
static int request_pending(struct fuse_conn *fc) { return !list_empty(&fc->pending) || !list_empty(&fc->interrupts) || forget_pending(fc); }
0
ceph
be7679007c3dfab3e19c22c38c36ccac91828e3b
CVE-2020-1760
CWE-79
int RGWGetObj_ObjStore_S3::send_response_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) { const char *content_type = NULL; string content_type_str; map<string, string> response_attrs; map<string, string>::iterator riter; bufferlist metadata_bl; string expires = get_s3_expiration_header(s, lastmod); if (sent_header) goto send_data; if (custom_http_ret) { set_req_state_err(s, 0); dump_errno(s, custom_http_ret); } else { set_req_state_err(s, (partial_content && !op_ret) ? STATUS_PARTIAL_CONTENT : op_ret); dump_errno(s); } if (op_ret) goto done; if (range_str) dump_range(s, start, end, s->obj_size); if (s->system_request && s->info.args.exists(RGW_SYS_PARAM_PREFIX "prepend-metadata")) { dump_header(s, "Rgwx-Object-Size", (long long)total_len); if (rgwx_stat) { /* * in this case, we're not returning the object's content, only the prepended * extra metadata */ total_len = 0; } /* JSON encode object metadata */ JSONFormatter jf; jf.open_object_section("obj_metadata"); encode_json("attrs", attrs, &jf); utime_t ut(lastmod); encode_json("mtime", ut, &jf); jf.close_section(); stringstream ss; jf.flush(ss); metadata_bl.append(ss.str()); dump_header(s, "Rgwx-Embedded-Metadata-Len", metadata_bl.length()); total_len += metadata_bl.length(); } if (s->system_request && !real_clock::is_zero(lastmod)) { /* we end up dumping mtime in two different methods, a bit redundant */ dump_epoch_header(s, "Rgwx-Mtime", lastmod); uint64_t pg_ver = 0; int r = decode_attr_bl_single_value(attrs, RGW_ATTR_PG_VER, &pg_ver, (uint64_t)0); if (r < 0) { ldpp_dout(this, 0) << "ERROR: failed to decode pg ver attr, ignoring" << dendl; } dump_header(s, "Rgwx-Obj-PG-Ver", pg_ver); uint32_t source_zone_short_id = 0; r = decode_attr_bl_single_value(attrs, RGW_ATTR_SOURCE_ZONE, &source_zone_short_id, (uint32_t)0); if (r < 0) { ldpp_dout(this, 0) << "ERROR: failed to decode pg ver attr, ignoring" << dendl; } if (source_zone_short_id != 0) { dump_header(s, "Rgwx-Source-Zone-Short-Id", source_zone_short_id); } } for (auto &it : crypt_http_responses) dump_header(s, it.first, it.second); dump_content_length(s, total_len); dump_last_modified(s, lastmod); dump_header_if_nonempty(s, "x-amz-version-id", version_id); dump_header_if_nonempty(s, "x-amz-expiration", expires); if (attrs.find(RGW_ATTR_APPEND_PART_NUM) != attrs.end()) { dump_header(s, "x-rgw-object-type", "Appendable"); dump_header(s, "x-rgw-next-append-position", s->obj_size); } else { dump_header(s, "x-rgw-object-type", "Normal"); } if (! op_ret) { if (! lo_etag.empty()) { /* Handle etag of Swift API's large objects (DLO/SLO). It's entirerly * legit to perform GET on them through S3 API. In such situation, * a client should receive the composited content with corresponding * etag value. */ dump_etag(s, lo_etag); } else { auto iter = attrs.find(RGW_ATTR_ETAG); if (iter != attrs.end()) { dump_etag(s, iter->second.to_str()); } } for (struct response_attr_param *p = resp_attr_params; p->param; p++) { bool exists; string val = s->info.args.get(p->param, &exists); if (exists) { /* reject unauthenticated response header manipulation, see * https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html */ if (s->auth.identity->is_anonymous()) { return -ERR_INVALID_REQUEST; } if (strcmp(p->param, "response-content-type") != 0) { response_attrs[p->http_attr] = val; } else { content_type_str = val; content_type = content_type_str.c_str(); } } } for (auto iter = attrs.begin(); iter != attrs.end(); ++iter) { const char *name = iter->first.c_str(); map<string, string>::iterator aiter = rgw_to_http_attrs.find(name); if (aiter != rgw_to_http_attrs.end()) { if (response_attrs.count(aiter->second) == 0) { /* Was not already overridden by a response param. */ size_t len = iter->second.length(); string s(iter->second.c_str(), len); while (len && !s[len - 1]) { --len; s.resize(len); } response_attrs[aiter->second] = s; } } else if (iter->first.compare(RGW_ATTR_CONTENT_TYPE) == 0) { /* Special handling for content_type. */ if (!content_type) { content_type_str = rgw_bl_str(iter->second); content_type = content_type_str.c_str(); } } else if (strcmp(name, RGW_ATTR_SLO_UINDICATOR) == 0) { // this attr has an extra length prefix from encode() in prior versions dump_header(s, "X-Object-Meta-Static-Large-Object", "True"); } else if (strncmp(name, RGW_ATTR_META_PREFIX, sizeof(RGW_ATTR_META_PREFIX)-1) == 0) { /* User custom metadata. */ name += sizeof(RGW_ATTR_PREFIX) - 1; dump_header(s, name, iter->second); } else if (iter->first.compare(RGW_ATTR_TAGS) == 0) { RGWObjTags obj_tags; try{ auto it = iter->second.cbegin(); obj_tags.decode(it); } catch (buffer::error &err) { ldpp_dout(this,0) << "Error caught buffer::error couldn't decode TagSet " << dendl; } dump_header(s, RGW_AMZ_TAG_COUNT, obj_tags.count()); } else if (iter->first.compare(RGW_ATTR_OBJECT_RETENTION) == 0 && get_retention){ RGWObjectRetention retention; try { decode(retention, iter->second); dump_header(s, "x-amz-object-lock-mode", retention.get_mode()); dump_time_header(s, "x-amz-object-lock-retain-until-date", retention.get_retain_until_date()); } catch (buffer::error& err) { ldpp_dout(this, 0) << "ERROR: failed to decode RGWObjectRetention" << dendl; } } else if (iter->first.compare(RGW_ATTR_OBJECT_LEGAL_HOLD) == 0 && get_legal_hold) { RGWObjectLegalHold legal_hold; try { decode(legal_hold, iter->second); dump_header(s, "x-amz-object-lock-legal-hold",legal_hold.get_status()); } catch (buffer::error& err) { ldpp_dout(this, 0) << "ERROR: failed to decode RGWObjectLegalHold" << dendl; } } } } done: for (riter = response_attrs.begin(); riter != response_attrs.end(); ++riter) { dump_header(s, riter->first, riter->second); } if (op_ret == -ERR_NOT_MODIFIED) { end_header(s, this); } else { if (!content_type) content_type = "binary/octet-stream"; end_header(s, this, content_type); } if (metadata_bl.length()) { dump_body(s, metadata_bl); } sent_header = true; send_data: if (get_data && !op_ret) { int r = dump_body(s, bl.c_str() + bl_ofs, bl_len); if (r < 0) return r; } return 0; }
1
openjpeg
baf0c1ad4572daa89caa3b12985bdd93530f0dd7
NOT_APPLICABLE
NOT_APPLICABLE
static void bmp24toimage(const OPJ_UINT8* pData, OPJ_UINT32 stride, opj_image_t* image) { int index; OPJ_UINT32 width, height; OPJ_UINT32 x, y; const OPJ_UINT8 *pSrc = NULL; width = image->comps[0].w; height = image->comps[0].h; index = 0; pSrc = pData + (height - 1U) * stride; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { image->comps[0].data[index] = (OPJ_INT32)pSrc[3 * x + 2]; /* R */ image->comps[1].data[index] = (OPJ_INT32)pSrc[3 * x + 1]; /* G */ image->comps[2].data[index] = (OPJ_INT32)pSrc[3 * x + 0]; /* B */ index++; } pSrc -= stride; } }
0
linux
4edbe1d7bcffcd6269f3b5eb63f710393ff2ec7a
NOT_APPLICABLE
NOT_APPLICABLE
static int validate_params(uint cmd, struct dm_ioctl *param) { /* Always clear this flag */ param->flags &= ~DM_BUFFER_FULL_FLAG; param->flags &= ~DM_UEVENT_GENERATED_FLAG; param->flags &= ~DM_SECURE_DATA_FLAG; param->flags &= ~DM_DATA_OUT_FLAG; /* Ignores parameters */ if (cmd == DM_REMOVE_ALL_CMD || cmd == DM_LIST_DEVICES_CMD || cmd == DM_LIST_VERSIONS_CMD) return 0; if (cmd == DM_DEV_CREATE_CMD) { if (!*param->name) { DMWARN("name not supplied when creating device"); return -EINVAL; } } else if (*param->uuid && *param->name) { DMWARN("only supply one of name or uuid, cmd(%u)", cmd); return -EINVAL; } /* Ensure strings are terminated */ param->name[DM_NAME_LEN - 1] = '\0'; param->uuid[DM_UUID_LEN - 1] = '\0'; return 0; }
0
core
8b716828c4a4ba11f2189ce002b80bf62a74538e
CVE-2021-29157
CWE-22
static const char *escape_identifier(const char *identifier) { size_t pos = strcspn(identifier, "./%"); if (pos < strlen(identifier)) { /* sanitize identifier, cannot allow dots or / in it, so we encode them */ string_t *new_id = t_str_new(strlen(identifier)); /* put initial data */ str_append_data(new_id, identifier, pos); for (const char *c = identifier+pos; *c != '\0'; c++) { switch (*c) { case '.': str_append(new_id, "%2e"); break; case '/': str_append(new_id, "%2f"); break; case '%': str_append(new_id, "%25"); break; default: str_append_c(new_id, *c); break; } } return str_c(new_id); } return identifier; }
1
linux
5233252fce714053f0151680933571a2da9cbfb4
NOT_APPLICABLE
NOT_APPLICABLE
static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags) { DEFINE_WAIT_FUNC(wait, woken_wake_function); struct sock *sk = sock->sk, *ch; long timeo; int err = 0; lock_sock(sk); timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); BT_DBG("sk %p timeo %ld", sk, timeo); /* Wait for an incoming connection. (wake-one). */ add_wait_queue_exclusive(sk_sleep(sk), &wait); while (1) { if (sk->sk_state != BT_LISTEN) { err = -EBADFD; break; } ch = bt_accept_dequeue(sk, newsock); if (ch) break; if (!timeo) { err = -EAGAIN; break; } if (signal_pending(current)) { err = sock_intr_errno(timeo); break; } release_sock(sk); timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo); lock_sock(sk); } remove_wait_queue(sk_sleep(sk), &wait); if (err) goto done; newsock->state = SS_CONNECTED; BT_DBG("new socket %p", ch); done: release_sock(sk); return err; }
0
ImageMagick6
ae3eecad2f59e27123c1a6c891be75d06fc03656
NOT_APPLICABLE
NOT_APPLICABLE
static Image *ReadMIFFImage(const ImageInfo *image_info, ExceptionInfo *exception) { #define BZipMaxExtent(x) ((x)+((x)/100)+600) #define LZMAMaxExtent(x) ((x)+((x)/3)+128) #define ThrowMIFFException(exception,message) \ { \ if (quantum_info != (QuantumInfo *) NULL) \ quantum_info=DestroyQuantumInfo(quantum_info); \ if (compress_pixels != (unsigned char *) NULL) \ compress_pixels=(unsigned char *) RelinquishMagickMemory(compress_pixels); \ ThrowReaderException((exception),(message)); \ } #define ZipMaxExtent(x) ((x)+(((x)+7) >> 3)+(((x)+63) >> 6)+11) #if defined(MAGICKCORE_BZLIB_DELEGATE) bz_stream bzip_info; #endif char id[MaxTextExtent], keyword[MaxTextExtent], *options; const unsigned char *p; double version; GeometryInfo geometry_info; Image *image; IndexPacket index; int c; LinkedListInfo *profiles; #if defined(MAGICKCORE_LZMA_DELEGATE) lzma_stream initialize_lzma = LZMA_STREAM_INIT, lzma_info; lzma_allocator allocator; #endif MagickBooleanType status; MagickStatusType flags; PixelPacket pixel; QuantumFormatType quantum_format; QuantumInfo *quantum_info; QuantumType quantum_type; register ssize_t i; size_t compress_extent, length, packet_size; ssize_t count; unsigned char *compress_pixels, *pixels; size_t colors; ssize_t y; #if defined(MAGICKCORE_ZLIB_DELEGATE) z_stream zip_info; #endif /* Open image file. */ assert(image_info != (const ImageInfo *) NULL); assert(image_info->signature == MagickCoreSignature); if (image_info->debug != MagickFalse) (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s", image_info->filename); assert(exception != (ExceptionInfo *) NULL); assert(exception->signature == MagickCoreSignature); image=AcquireImage(image_info); status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception); if (status == MagickFalse) { image=DestroyImageList(image); return((Image *) NULL); } /* Decode image header; header terminates one character beyond a ':'. */ c=ReadBlobByte(image); if (c == EOF) ThrowReaderException(CorruptImageError,"ImproperImageHeader"); *id='\0'; compress_pixels=(unsigned char *) NULL; quantum_info=(QuantumInfo *) NULL; (void) memset(keyword,0,sizeof(keyword)); version=0.0; (void) version; do { /* Decode image header; header terminates one character beyond a ':'. */ SetGeometryInfo(&geometry_info); length=MaxTextExtent; options=AcquireString((char *) NULL); quantum_format=UndefinedQuantumFormat; profiles=(LinkedListInfo *) NULL; colors=0; image->depth=8UL; image->compression=NoCompression; while ((isgraph(c) != MagickFalse) && (c != (int) ':')) { register char *p; if (c == (int) '{') { char *comment; /* Read comment-- any text between { }. */ length=MaxTextExtent; comment=AcquireString((char *) NULL); for (p=comment; comment != (char *) NULL; p++) { c=ReadBlobByte(image); if (c == (int) '\\') c=ReadBlobByte(image); else if ((c == EOF) || (c == (int) '}')) break; if ((size_t) (p-comment+1) >= length) { *p='\0'; length<<=1; comment=(char *) ResizeQuantumMemory(comment,length+ MaxTextExtent,sizeof(*comment)); if (comment == (char *) NULL) break; p=comment+strlen(comment); } *p=(char) c; } if (comment == (char *) NULL) { options=DestroyString(options); ThrowMIFFException(ResourceLimitError,"MemoryAllocationFailed"); } *p='\0'; (void) SetImageProperty(image,"comment",comment); comment=DestroyString(comment); c=ReadBlobByte(image); } else if (isalnum(c) != MagickFalse) { /* Get the keyword. */ length=MaxTextExtent-1; p=keyword; do { if (c == (int) '=') break; if ((size_t) (p-keyword) < (MaxTextExtent-1)) *p++=(char) c; c=ReadBlobByte(image); } while (c != EOF); *p='\0'; p=options; while ((isspace((int) ((unsigned char) c)) != 0) && (c != EOF)) c=ReadBlobByte(image); if (c == (int) '=') { /* Get the keyword value. */ c=ReadBlobByte(image); while ((c != (int) '}') && (c != EOF)) { if ((size_t) (p-options+1) >= length) { *p='\0'; length<<=1; options=(char *) ResizeQuantumMemory(options,length+ MaxTextExtent,sizeof(*options)); if (options == (char *) NULL) break; p=options+strlen(options); } *p++=(char) c; c=ReadBlobByte(image); if (c == '\\') { c=ReadBlobByte(image); if (c == (int) '}') { *p++=(char) c; c=ReadBlobByte(image); } } if (*options != '{') if (isspace((int) ((unsigned char) c)) != 0) break; } if (options == (char *) NULL) ThrowMIFFException(ResourceLimitError, "MemoryAllocationFailed"); } *p='\0'; if (*options == '{') (void) CopyMagickString(options,options+1,strlen(options)); /* Assign a value to the specified keyword. */ switch (*keyword) { case 'b': case 'B': { if (LocaleCompare(keyword,"background-color") == 0) { (void) QueryColorDatabase(options,&image->background_color, exception); break; } if (LocaleCompare(keyword,"blue-primary") == 0) { flags=ParseGeometry(options,&geometry_info); image->chromaticity.blue_primary.x=geometry_info.rho; image->chromaticity.blue_primary.y=geometry_info.sigma; if ((flags & SigmaValue) == 0) image->chromaticity.blue_primary.y= image->chromaticity.blue_primary.x; break; } if (LocaleCompare(keyword,"border-color") == 0) { (void) QueryColorDatabase(options,&image->border_color, exception); break; } (void) SetImageProperty(image,keyword,options); break; } case 'c': case 'C': { if (LocaleCompare(keyword,"class") == 0) { ssize_t storage_class; storage_class=ParseCommandOption(MagickClassOptions, MagickFalse,options); if (storage_class < 0) break; image->storage_class=(ClassType) storage_class; break; } if (LocaleCompare(keyword,"colors") == 0) { colors=StringToUnsignedLong(options); break; } if (LocaleCompare(keyword,"colorspace") == 0) { ssize_t colorspace; colorspace=ParseCommandOption(MagickColorspaceOptions, MagickFalse,options); if (colorspace < 0) break; image->colorspace=(ColorspaceType) colorspace; break; } if (LocaleCompare(keyword,"compression") == 0) { ssize_t compression; compression=ParseCommandOption(MagickCompressOptions, MagickFalse,options); if (compression < 0) break; image->compression=(CompressionType) compression; break; } if (LocaleCompare(keyword,"columns") == 0) { image->columns=StringToUnsignedLong(options); break; } (void) SetImageProperty(image,keyword,options); break; } case 'd': case 'D': { if (LocaleCompare(keyword,"delay") == 0) { image->delay=StringToUnsignedLong(options); break; } if (LocaleCompare(keyword,"depth") == 0) { image->depth=StringToUnsignedLong(options); break; } if (LocaleCompare(keyword,"dispose") == 0) { ssize_t dispose; dispose=ParseCommandOption(MagickDisposeOptions,MagickFalse, options); if (dispose < 0) break; image->dispose=(DisposeType) dispose; break; } (void) SetImageProperty(image,keyword,options); break; } case 'e': case 'E': { if (LocaleCompare(keyword,"endian") == 0) { ssize_t endian; endian=ParseCommandOption(MagickEndianOptions,MagickFalse, options); if (endian < 0) break; image->endian=(EndianType) endian; break; } (void) SetImageProperty(image,keyword,options); break; } case 'g': case 'G': { if (LocaleCompare(keyword,"gamma") == 0) { image->gamma=StringToDouble(options,(char **) NULL); break; } if (LocaleCompare(keyword,"gravity") == 0) { ssize_t gravity; gravity=ParseCommandOption(MagickGravityOptions,MagickFalse, options); if (gravity < 0) break; image->gravity=(GravityType) gravity; break; } if (LocaleCompare(keyword,"green-primary") == 0) { flags=ParseGeometry(options,&geometry_info); image->chromaticity.green_primary.x=geometry_info.rho; image->chromaticity.green_primary.y=geometry_info.sigma; if ((flags & SigmaValue) == 0) image->chromaticity.green_primary.y= image->chromaticity.green_primary.x; break; } (void) SetImageProperty(image,keyword,options); break; } case 'i': case 'I': { if (LocaleCompare(keyword,"id") == 0) { (void) CopyMagickString(id,options,MaxTextExtent); break; } if (LocaleCompare(keyword,"iterations") == 0) { image->iterations=StringToUnsignedLong(options); break; } (void) SetImageProperty(image,keyword,options); break; } case 'm': case 'M': { if (LocaleCompare(keyword,"matte") == 0) { ssize_t matte; matte=ParseCommandOption(MagickBooleanOptions,MagickFalse, options); if (matte < 0) break; image->matte=(MagickBooleanType) matte; break; } if (LocaleCompare(keyword,"matte-color") == 0) { (void) QueryColorDatabase(options,&image->matte_color, exception); break; } if (LocaleCompare(keyword,"montage") == 0) { (void) CloneString(&image->montage,options); break; } (void) SetImageProperty(image,keyword,options); break; } case 'o': case 'O': { if (LocaleCompare(keyword,"opaque") == 0) { ssize_t matte; matte=ParseCommandOption(MagickBooleanOptions,MagickFalse, options); if (matte < 0) break; image->matte=(MagickBooleanType) matte; break; } if (LocaleCompare(keyword,"orientation") == 0) { ssize_t orientation; orientation=ParseCommandOption(MagickOrientationOptions, MagickFalse,options); if (orientation < 0) break; image->orientation=(OrientationType) orientation; break; } (void) SetImageProperty(image,keyword,options); break; } case 'p': case 'P': { if (LocaleCompare(keyword,"page") == 0) { char *geometry; geometry=GetPageGeometry(options); (void) ParseAbsoluteGeometry(geometry,&image->page); geometry=DestroyString(geometry); break; } if (LocaleCompare(keyword,"pixel-intensity") == 0) { ssize_t intensity; intensity=ParseCommandOption(MagickPixelIntensityOptions, MagickFalse,options); if (intensity < 0) break; image->intensity=(PixelIntensityMethod) intensity; break; } if (LocaleCompare(keyword,"profile") == 0) { if (profiles == (LinkedListInfo *) NULL) profiles=NewLinkedList(0); (void) AppendValueToLinkedList(profiles, AcquireString(options)); break; } (void) SetImageProperty(image,keyword,options); break; } case 'q': case 'Q': { if (LocaleCompare(keyword,"quality") == 0) { image->quality=StringToUnsignedLong(options); break; } if ((LocaleCompare(keyword,"quantum-format") == 0) || (LocaleCompare(keyword,"quantum:format") == 0)) { ssize_t format; format=ParseCommandOption(MagickQuantumFormatOptions, MagickFalse,options); if (format < 0) break; quantum_format=(QuantumFormatType) format; break; } (void) SetImageProperty(image,keyword,options); break; } case 'r': case 'R': { if (LocaleCompare(keyword,"red-primary") == 0) { flags=ParseGeometry(options,&geometry_info); image->chromaticity.red_primary.x=geometry_info.rho; image->chromaticity.red_primary.y=geometry_info.sigma; if ((flags & SigmaValue) == 0) image->chromaticity.red_primary.y= image->chromaticity.red_primary.x; break; } if (LocaleCompare(keyword,"rendering-intent") == 0) { ssize_t rendering_intent; rendering_intent=ParseCommandOption(MagickIntentOptions, MagickFalse,options); if (rendering_intent < 0) break; image->rendering_intent=(RenderingIntent) rendering_intent; break; } if (LocaleCompare(keyword,"resolution") == 0) { flags=ParseGeometry(options,&geometry_info); image->x_resolution=geometry_info.rho; image->y_resolution=geometry_info.sigma; if ((flags & SigmaValue) == 0) image->y_resolution=image->x_resolution; break; } if (LocaleCompare(keyword,"rows") == 0) { image->rows=StringToUnsignedLong(options); break; } (void) SetImageProperty(image,keyword,options); break; } case 's': case 'S': { if (LocaleCompare(keyword,"scene") == 0) { image->scene=StringToUnsignedLong(options); break; } (void) SetImageProperty(image,keyword,options); break; } case 't': case 'T': { if (LocaleCompare(keyword,"ticks-per-second") == 0) { image->ticks_per_second=(ssize_t) StringToLong(options); break; } if (LocaleCompare(keyword,"tile-offset") == 0) { char *geometry; geometry=GetPageGeometry(options); (void) ParseAbsoluteGeometry(geometry,&image->tile_offset); geometry=DestroyString(geometry); break; } if (LocaleCompare(keyword,"type") == 0) { ssize_t type; type=ParseCommandOption(MagickTypeOptions,MagickFalse, options); if (type < 0) break; image->type=(ImageType) type; break; } (void) SetImageProperty(image,keyword,options); break; } case 'u': case 'U': { if (LocaleCompare(keyword,"units") == 0) { ssize_t units; units=ParseCommandOption(MagickResolutionOptions, MagickFalse,options); if (units < 0) break; image->units=(ResolutionType) units; break; } (void) SetImageProperty(image,keyword,options); break; } case 'v': case 'V': { if (LocaleCompare(keyword,"version") == 0) { version=StringToDouble(options,(char **) NULL); break; } (void) SetImageProperty(image,keyword,options); break; } case 'w': case 'W': { if (LocaleCompare(keyword,"white-point") == 0) { flags=ParseGeometry(options,&geometry_info); image->chromaticity.white_point.x=geometry_info.rho; image->chromaticity.white_point.y=geometry_info.sigma; if ((flags & SigmaValue) == 0) image->chromaticity.white_point.y= image->chromaticity.white_point.x; break; } (void) SetImageProperty(image,keyword,options); break; } default: { (void) SetImageProperty(image,keyword,options); break; } } } else c=ReadBlobByte(image); while (isspace((int) ((unsigned char) c)) != 0) c=ReadBlobByte(image); } options=DestroyString(options); (void) ReadBlobByte(image); /* Verify that required image information is defined. */ if ((LocaleCompare(id,"ImageMagick") != 0) || (image->depth > 128) || (image->storage_class == UndefinedClass) || (image->compression == UndefinedCompression) || (image->colorspace == UndefinedColorspace) || (image->columns == 0) || (image->rows == 0)) { if (profiles != (LinkedListInfo *) NULL) profiles=DestroyLinkedList(profiles,RelinquishMagickMemory); if (image->previous == (Image *) NULL) ThrowMIFFException(CorruptImageError,"ImproperImageHeader"); DeleteImageFromList(&image); (void) ThrowMagickException(&image->exception,GetMagickModule(), CorruptImageError,"ImproperImageHeader","`%s'",image->filename); break; } if (image->montage != (char *) NULL) { register char *p; /* Image directory. */ length=MaxTextExtent; image->directory=AcquireString((char *) NULL); p=image->directory; do { *p='\0'; if ((strlen(image->directory)+MaxTextExtent) >= length) { /* Allocate more memory for the image directory. */ length<<=1; image->directory=(char *) ResizeQuantumMemory(image->directory, length+MaxTextExtent,sizeof(*image->directory)); if (image->directory == (char *) NULL) ThrowMIFFException(CorruptImageError,"UnableToReadImageData"); p=image->directory+strlen(image->directory); } c=ReadBlobByte(image); if (c == EOF) break; *p++=(char) c; } while (c != (int) '\0'); } if (profiles != (LinkedListInfo *) NULL) { const char *name; StringInfo *profile; /* Read image profile blobs. */ ResetLinkedListIterator(profiles); name=(const char *) GetNextValueInLinkedList(profiles); while (name != (const char *) NULL) { ssize_t count; length=ReadBlobMSBLong(image); if ((MagickSizeType) length > GetBlobSize(image)) break; profile=AcquireStringInfo(length); if (profile == (StringInfo *) NULL) break; count=ReadBlob(image,length,GetStringInfoDatum(profile)); if (count != (ssize_t) length) { profile=DestroyStringInfo(profile); break; } status=SetImageProfile(image,name,profile); profile=DestroyStringInfo(profile); if (status == MagickFalse) break; name=(const char *) GetNextValueInLinkedList(profiles); } profiles=DestroyLinkedList(profiles,RelinquishMagickMemory); } image->depth=GetImageQuantumDepth(image,MagickFalse); if (image->storage_class == PseudoClass) { size_t packet_size; unsigned char *colormap; /* Create image colormap. */ packet_size=(size_t) (3UL*image->depth/8UL); if ((MagickSizeType) colors > GetBlobSize(image)) ThrowMIFFException(CorruptImageError,"InsufficientImageDataInFile"); if (((MagickSizeType) packet_size*colors) > GetBlobSize(image)) ThrowMIFFException(CorruptImageError,"InsufficientImageDataInFile"); status=AcquireImageColormap(image,colors != 0 ? colors : 256); if (status == MagickFalse) { InheritException(exception,&image->exception); return(DestroyImageList(image)); } if (colors != 0) { /* Read image colormap from file. */ colormap=(unsigned char *) AcquireQuantumMemory(image->colors, packet_size*sizeof(*colormap)); if (colormap == (unsigned char *) NULL) ThrowMIFFException(ResourceLimitError,"MemoryAllocationFailed"); (void) ReadBlob(image,packet_size*image->colors,colormap); p=colormap; switch (image->depth) { default: colormap=(unsigned char *) RelinquishMagickMemory(colormap); ThrowMIFFException(CorruptImageError,"ImageDepthNotSupported"); case 8: { unsigned char pixel; for (i=0; i < (ssize_t) image->colors; i++) { p=PushCharPixel(p,&pixel); image->colormap[i].red=ScaleCharToQuantum(pixel); p=PushCharPixel(p,&pixel); image->colormap[i].green=ScaleCharToQuantum(pixel); p=PushCharPixel(p,&pixel); image->colormap[i].blue=ScaleCharToQuantum(pixel); } break; } case 16: { unsigned short pixel; for (i=0; i < (ssize_t) image->colors; i++) { p=PushShortPixel(MSBEndian,p,&pixel); image->colormap[i].red=ScaleShortToQuantum(pixel); p=PushShortPixel(MSBEndian,p,&pixel); image->colormap[i].green=ScaleShortToQuantum(pixel); p=PushShortPixel(MSBEndian,p,&pixel); image->colormap[i].blue=ScaleShortToQuantum(pixel); } break; } case 32: { unsigned int pixel; for (i=0; i < (ssize_t) image->colors; i++) { p=PushLongPixel(MSBEndian,p,&pixel); image->colormap[i].red=ScaleLongToQuantum(pixel); p=PushLongPixel(MSBEndian,p,&pixel); image->colormap[i].green=ScaleLongToQuantum(pixel); p=PushLongPixel(MSBEndian,p,&pixel); image->colormap[i].blue=ScaleLongToQuantum(pixel); } break; } } colormap=(unsigned char *) RelinquishMagickMemory(colormap); } } if ((image_info->ping != MagickFalse) && (image_info->number_scenes != 0)) if (image->scene >= (image_info->scene+image_info->number_scenes-1)) break; status=SetImageExtent(image,image->columns,image->rows); if (status == MagickFalse) { InheritException(exception,&image->exception); return(DestroyImageList(image)); } status=ResetImagePixels(image,exception); if (status == MagickFalse) { InheritException(exception,&image->exception); return(DestroyImageList(image)); } /* Allocate image pixels. */ quantum_info=AcquireQuantumInfo(image_info,image); if (quantum_info == (QuantumInfo *) NULL) ThrowMIFFException(ResourceLimitError,"MemoryAllocationFailed"); if (quantum_format != UndefinedQuantumFormat) { status=SetQuantumFormat(image,quantum_info,quantum_format); if (status == MagickFalse) ThrowMIFFException(ResourceLimitError,"MemoryAllocationFailed"); } packet_size=(size_t) (quantum_info->depth/8); if (image->storage_class == DirectClass) packet_size=(size_t) (3*quantum_info->depth/8); if (IsGrayColorspace(image->colorspace) != MagickFalse) packet_size=quantum_info->depth/8; if (image->matte != MagickFalse) packet_size+=quantum_info->depth/8; if (image->colorspace == CMYKColorspace) packet_size+=quantum_info->depth/8; if (image->compression == RLECompression) packet_size++; compress_extent=MagickMax(MagickMax(BZipMaxExtent(packet_size* image->columns),LZMAMaxExtent(packet_size*image->columns)), ZipMaxExtent(packet_size*image->columns)); compress_pixels=(unsigned char *) AcquireQuantumMemory(compress_extent, sizeof(*compress_pixels)); if (compress_pixels == (unsigned char *) NULL) ThrowMIFFException(ResourceLimitError,"MemoryAllocationFailed"); /* Read image pixels. */ quantum_type=RGBQuantum; if (image->matte != MagickFalse) quantum_type=RGBAQuantum; if (image->colorspace == CMYKColorspace) { quantum_type=CMYKQuantum; if (image->matte != MagickFalse) quantum_type=CMYKAQuantum; } if (IsGrayColorspace(image->colorspace) != MagickFalse) { quantum_type=GrayQuantum; if (image->matte != MagickFalse) quantum_type=GrayAlphaQuantum; } if (image->storage_class == PseudoClass) { quantum_type=IndexQuantum; if (image->matte != MagickFalse) quantum_type=IndexAlphaQuantum; } status=MagickTrue; (void) memset(&pixel,0,sizeof(pixel)); #if defined(MAGICKCORE_BZLIB_DELEGATE) (void) memset(&bzip_info,0,sizeof(bzip_info)); #endif #if defined(MAGICKCORE_LZMA_DELEGATE) (void) memset(&allocator,0,sizeof(allocator)); #endif #if defined(MAGICKCORE_ZLIB_DELEGATE) (void) memset(&zip_info,0,sizeof(zip_info)); #endif switch (image->compression) { #if defined(MAGICKCORE_BZLIB_DELEGATE) case BZipCompression: { int code; bzip_info.bzalloc=AcquireBZIPMemory; bzip_info.bzfree=RelinquishBZIPMemory; bzip_info.opaque=(void *) image; code=BZ2_bzDecompressInit(&bzip_info,(int) image_info->verbose, MagickFalse); if (code != BZ_OK) status=MagickFalse; break; } #endif #if defined(MAGICKCORE_LZMA_DELEGATE) case LZMACompression: { int code; allocator.alloc=AcquireLZMAMemory; allocator.free=RelinquishLZMAMemory; allocator.opaque=(void *) image; lzma_info=initialize_lzma; lzma_info.allocator=(&allocator); code=lzma_auto_decoder(&lzma_info,-1,0); if (code != LZMA_OK) status=MagickFalse; break; } #endif #if defined(MAGICKCORE_ZLIB_DELEGATE) case LZWCompression: case ZipCompression: { int code; zip_info.zalloc=AcquireZIPMemory; zip_info.zfree=RelinquishZIPMemory; zip_info.opaque=(voidpf) image; code=inflateInit(&zip_info); if (code != Z_OK) status=MagickFalse; break; } #endif case RLECompression: { pixel.opacity=(Quantum) TransparentOpacity; index=(IndexPacket) 0; break; } default: break; } pixels=GetQuantumPixels(quantum_info); index=(IndexPacket) 0; length=0; for (y=0; y < (ssize_t) image->rows; y++) { register IndexPacket *magick_restrict indexes; register ssize_t x; register PixelPacket *magick_restrict q; if (status == MagickFalse) break; q=QueueAuthenticPixels(image,0,y,image->columns,1,exception); if (q == (PixelPacket *) NULL) break; indexes=GetAuthenticIndexQueue(image); switch (image->compression) { #if defined(MAGICKCORE_BZLIB_DELEGATE) case BZipCompression: { bzip_info.next_out=(char *) pixels; bzip_info.avail_out=(unsigned int) (packet_size*image->columns); do { int code; if (bzip_info.avail_in == 0) { bzip_info.next_in=(char *) compress_pixels; length=(size_t) BZipMaxExtent(packet_size*image->columns); if (version != 0.0) length=(size_t) ReadBlobMSBLong(image); if (length < compress_extent) bzip_info.avail_in=(unsigned int) ReadBlob(image,length, (unsigned char *) bzip_info.next_in); if ((length > compress_extent) || ((size_t) bzip_info.avail_in != length)) { (void) BZ2_bzDecompressEnd(&bzip_info); ThrowMIFFException(CorruptImageError, "UnableToReadImageData"); } } code=BZ2_bzDecompress(&bzip_info); if ((code != BZ_OK) && (code != BZ_STREAM_END)) { status=MagickFalse; break; } if (code == BZ_STREAM_END) break; } while (bzip_info.avail_out != 0); (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info, quantum_type,pixels,exception); break; } #endif #if defined(MAGICKCORE_LZMA_DELEGATE) case LZMACompression: { lzma_info.next_out=pixels; lzma_info.avail_out=packet_size*image->columns; do { int code; if (lzma_info.avail_in == 0) { lzma_info.next_in=compress_pixels; length=(size_t) ReadBlobMSBLong(image); if (length <= compress_extent) lzma_info.avail_in=(unsigned int) ReadBlob(image,length, (unsigned char *) lzma_info.next_in); if ((length > compress_extent) || (lzma_info.avail_in != length)) { lzma_end(&lzma_info); ThrowMIFFException(CorruptImageError, "UnableToReadImageData"); } } code=lzma_code(&lzma_info,LZMA_RUN); if ((code != LZMA_OK) && (code != LZMA_STREAM_END)) { status=MagickFalse; break; } if (code == LZMA_STREAM_END) break; } while (lzma_info.avail_out != 0); (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info, quantum_type,pixels,exception); break; } #endif #if defined(MAGICKCORE_ZLIB_DELEGATE) case LZWCompression: case ZipCompression: { zip_info.next_out=pixels; zip_info.avail_out=(uInt) (packet_size*image->columns); do { int code; if (zip_info.avail_in == 0) { zip_info.next_in=compress_pixels; length=(size_t) ZipMaxExtent(packet_size*image->columns); if (version != 0.0) length=(size_t) ReadBlobMSBLong(image); if (length <= compress_extent) zip_info.avail_in=(unsigned int) ReadBlob(image,length, zip_info.next_in); if ((length > compress_extent) || ((size_t) zip_info.avail_in != length)) { (void) inflateEnd(&zip_info); ThrowMIFFException(CorruptImageError, "UnableToReadImageData"); } } code=inflate(&zip_info,Z_SYNC_FLUSH); if ((code != Z_OK) && (code != Z_STREAM_END)) { status=MagickFalse; break; } if (code == Z_STREAM_END) break; } while (zip_info.avail_out != 0); (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info, quantum_type,pixels,exception); break; } #endif case RLECompression: { for (x=0; x < (ssize_t) image->columns; x++) { if (length == 0) { count=ReadBlob(image,packet_size,pixels); if (count != packet_size) ThrowMIFFException(CorruptImageError,"UnableToReadImageData"); PushRunlengthPacket(image,pixels,&length,&pixel,&index); } length--; if ((image->storage_class == PseudoClass) || (image->colorspace == CMYKColorspace)) SetPixelIndex(indexes+x,index); SetPixelRed(q,pixel.red); SetPixelGreen(q,pixel.green); SetPixelBlue(q,pixel.blue); SetPixelOpacity(q,pixel.opacity); q++; } break; } default: { count=ReadBlob(image,packet_size*image->columns,pixels); if (count != (packet_size*image->columns)) ThrowMIFFException(CorruptImageError,"UnableToReadImageData"); (void) ImportQuantumPixels(image,(CacheView *) NULL,quantum_info, quantum_type,pixels,exception); break; } } if (SyncAuthenticPixels(image,exception) == MagickFalse) break; } SetQuantumImageType(image,quantum_type); switch (image->compression) { #if defined(MAGICKCORE_BZLIB_DELEGATE) case BZipCompression: { int code; if (version == 0.0) { MagickOffsetType offset; offset=SeekBlob(image,-((MagickOffsetType) bzip_info.avail_in), SEEK_CUR); if (offset < 0) { (void) BZ2_bzDecompressEnd(&bzip_info); ThrowMIFFException(CorruptImageError,"ImproperImageHeader"); } } code=BZ2_bzDecompressEnd(&bzip_info); if (code != BZ_OK) status=MagickFalse; break; } #endif #if defined(MAGICKCORE_LZMA_DELEGATE) case LZMACompression: { int code; code=lzma_code(&lzma_info,LZMA_FINISH); if ((code != LZMA_STREAM_END) && (code != LZMA_OK)) status=MagickFalse; lzma_end(&lzma_info); break; } #endif #if defined(MAGICKCORE_ZLIB_DELEGATE) case LZWCompression: case ZipCompression: { int code; if (version == 0.0) { MagickOffsetType offset; offset=SeekBlob(image,-((MagickOffsetType) zip_info.avail_in), SEEK_CUR); if (offset < 0) { (void) inflateEnd(&zip_info); ThrowMIFFException(CorruptImageError,"ImproperImageHeader"); } } code=inflateEnd(&zip_info); if (code != Z_OK) status=MagickFalse; break; } #endif default: break; } quantum_info=DestroyQuantumInfo(quantum_info); compress_pixels=(unsigned char *) RelinquishMagickMemory(compress_pixels); if (((y != (ssize_t) image->rows)) || (status == MagickFalse)) { image=DestroyImageList(image); return((Image *) NULL); } if (EOFBlob(image) != MagickFalse) { ThrowFileException(exception,CorruptImageError,"UnexpectedEndOfFile", image->filename); break; } /* Proceed to next image. */ if (image_info->number_scenes != 0) if (image->scene >= (image_info->scene+image_info->number_scenes-1)) break; do { c=ReadBlobByte(image); } while ((isgraph(c) == MagickFalse) && (c != EOF)); if (c != EOF) { /* Allocate next image structure. */ AcquireNextImage(image_info,image); if (GetNextImageInList(image) == (Image *) NULL) { status=MagickFalse; break; } image=SyncNextImageInList(image); status=SetImageProgress(image,LoadImagesTag,TellBlob(image), GetBlobSize(image)); if (status == MagickFalse) break; } } while (c != EOF); (void) CloseBlob(image); if (status == MagickFalse) return(DestroyImageList(image)); return(GetFirstImageInList(image)); }
0
End of preview. Expand in Data Studio
README.md exists but content is empty.
Downloads last month
55

Models trained or fine-tuned on mahdin70/balanced_merged_bigvul_primevul