project
stringclasses 791
values | commit_id
stringlengths 6
81
| CVE ID
stringlengths 13
16
| CWE ID
stringclasses 127
values | func
stringlengths 5
484k
| vul
int8 0
1
|
|---|---|---|---|---|---|
oniguruma | 6eb4aca6a7f2f60f473580576d86686ed6a6ebec | NOT_APPLICABLE | NOT_APPLICABLE | is_allowed_callout_name(OnigEncoding enc, UChar* name, UChar* name_end)
{
UChar* p;
OnigCodePoint c;
if (name >= name_end) return 0;
p = name;
while (p < name_end) {
c = ONIGENC_MBC_TO_CODE(enc, p, name_end);
if (! IS_ALLOWED_CODE_IN_CALLOUT_NAME(c))
return 0;
if (p == name) {
if (c >= '0' && c <= '9') return 0;
}
p += ONIGENC_MBC_ENC_LEN(enc, p);
}
return 1;
} | 0 |
gpac | f19668964bf422cf5a63e4dbe1d3c6c75edadcbb | NOT_APPLICABLE | NOT_APPLICABLE | GF_Err schi_on_child_box(GF_Box *s, GF_Box *a, Bool is_rem)
{
GF_SchemeInformationBox *ptr = (GF_SchemeInformationBox *)s;
switch (a->type) {
case GF_ISOM_BOX_TYPE_IKMS:
BOX_FIELD_ASSIGN(ikms, GF_ISMAKMSBox)
return GF_OK;
case GF_ISOM_BOX_TYPE_ISFM:
BOX_FIELD_ASSIGN(isfm, GF_ISMASampleFormatBox)
return GF_OK;
case GF_ISOM_BOX_TYPE_ISLT:
BOX_FIELD_ASSIGN(islt, GF_ISMACrypSaltBox)
return GF_OK;
case GF_ISOM_BOX_TYPE_ODKM:
BOX_FIELD_ASSIGN(odkm, GF_OMADRMKMSBox)
return GF_OK;
case GF_ISOM_BOX_TYPE_TENC:
BOX_FIELD_ASSIGN(tenc, GF_TrackEncryptionBox)
return GF_OK;
case GF_ISOM_BOX_TYPE_ADKM:
BOX_FIELD_ASSIGN(adkm, GF_AdobeDRMKeyManagementSystemBox)
return GF_OK;
case GF_ISOM_BOX_TYPE_UUID:
if (((GF_UUIDBox*)a)->internal_4cc==GF_ISOM_BOX_UUID_TENC) {
BOX_FIELD_ASSIGN(piff_tenc, GF_PIFFTrackEncryptionBox)
return GF_OK;
} else {
return GF_OK;
}
}
return GF_OK;
} | 0 |
Chrome | 282f53ffdc3b1902da86f6a0791af736837efbf8 | NOT_APPLICABLE | NOT_APPLICABLE | views::View* ProfileChooserView::CreateSyncErrorViewIfNeeded(
const AvatarMenu::Item& avatar_item) {
int content_string_id, button_string_id;
SigninManagerBase* signin_manager =
SigninManagerFactory::GetForProfile(browser_->profile());
sync_ui_util::AvatarSyncErrorType error =
sync_ui_util::GetMessagesForAvatarSyncError(
browser_->profile(), *signin_manager, &content_string_id,
&button_string_id);
if (error == sync_ui_util::NO_SYNC_ERROR)
return nullptr;
ChromeLayoutProvider* provider = ChromeLayoutProvider::Get();
if (error != sync_ui_util::SUPERVISED_USER_AUTH_ERROR && dice_enabled_)
return CreateDiceSyncErrorView(avatar_item, error, button_string_id);
views::View* view = new views::View();
auto layout = std::make_unique<views::BoxLayout>(
views::BoxLayout::kHorizontal, gfx::Insets(kMenuEdgeMargin),
provider->GetDistanceMetric(DISTANCE_UNRELATED_CONTROL_HORIZONTAL));
layout->set_cross_axis_alignment(
views::BoxLayout::CROSS_AXIS_ALIGNMENT_START);
view->SetLayoutManager(std::move(layout));
views::ImageView* sync_problem_icon = new views::ImageView();
sync_problem_icon->SetImage(
gfx::CreateVectorIcon(kSyncProblemIcon, kIconSize, gfx::kGoogleRed700));
view->AddChildView(sync_problem_icon);
views::View* vertical_view = new views::View();
const int small_vertical_spacing =
provider->GetDistanceMetric(DISTANCE_RELATED_CONTROL_VERTICAL_SMALL);
auto vertical_layout = std::make_unique<views::BoxLayout>(
views::BoxLayout::kVertical, gfx::Insets(), small_vertical_spacing);
vertical_layout->set_cross_axis_alignment(
views::BoxLayout::CROSS_AXIS_ALIGNMENT_START);
vertical_view->SetLayoutManager(std::move(vertical_layout));
views::Label* title_label = new views::Label(
l10n_util::GetStringUTF16(IDS_SYNC_ERROR_USER_MENU_TITLE));
title_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
title_label->SetEnabledColor(gfx::kGoogleRed700);
vertical_view->AddChildView(title_label);
views::Label* content_label =
new views::Label(l10n_util::GetStringUTF16(content_string_id));
content_label->SetMultiLine(true);
content_label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
vertical_view->AddChildView(content_label);
if (button_string_id) {
auto* padding = new views::View;
padding->SetPreferredSize(gfx::Size(
0,
provider->GetDistanceMetric(views::DISTANCE_RELATED_CONTROL_VERTICAL)));
vertical_view->AddChildView(padding);
sync_error_button_ = views::MdTextButton::CreateSecondaryUiBlueButton(
this, l10n_util::GetStringUTF16(button_string_id));
sync_error_button_->set_id(error);
vertical_view->AddChildView(sync_error_button_);
view->SetBorder(views::CreateEmptyBorder(0, 0, small_vertical_spacing, 0));
}
view->AddChildView(vertical_view);
return view;
}
| 0 |
linux | 6f442be2fb22be02cafa606f1769fa1e6f894441 | NOT_APPLICABLE | NOT_APPLICABLE | static inline void conditional_sti(struct pt_regs *regs)
{
if (regs->flags & X86_EFLAGS_IF)
local_irq_enable();
}
| 0 |
linux | 36e4ad0316c017d5b271378ed9a1c9a4b77fab5f | NOT_APPLICABLE | NOT_APPLICABLE | static int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
{
u32 rl_flags;
if (rgd->rd_flags & GFS2_RDF_UPTODATE)
return 0;
if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
return gfs2_rgrp_bh_get(rgd);
rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
rl_flags &= ~GFS2_RDF_MASK;
rgd->rd_flags &= GFS2_RDF_MASK;
rgd->rd_flags |= (rl_flags | GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
if (rgd->rd_rgl->rl_unlinked == 0)
rgd->rd_flags &= ~GFS2_RDF_CHECK;
rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
rgd->rd_free_clone = rgd->rd_free;
rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
return 0;
} | 0 |
Chrome | c13e1da62b5f5f0e6fe8c1f769a5a28415415244 | NOT_APPLICABLE | NOT_APPLICABLE | GLenum GLES2DecoderImpl::GetGLError() {
GLenum error = glGetError();
if (error == GL_NO_ERROR && error_bits_ != 0) {
for (uint32 mask = 1; mask != 0; mask = mask << 1) {
if ((error_bits_ & mask) != 0) {
error = GLES2Util::GLErrorBitToGLError(mask);
break;
}
}
}
if (error != GL_NO_ERROR) {
error_bits_ &= ~GLES2Util::GLErrorToErrorBit(error);
}
return error;
}
| 0 |
nasm | e996d28c70d45008085322b442b44a9224308548 | NOT_APPLICABLE | NOT_APPLICABLE | static bool skip_this_pass(int severity)
{
/*
* See if it's a pass-specific error or warning which should be skipped.
* We cannot skip errors stronger than ERR_NONFATAL as by definition
* they cannot be resumed from.
*/
if ((severity & ERR_MASK) > ERR_NONFATAL)
return false;
/*
* passn is 1 on the very first pass only.
* pass0 is 2 on the code-generation (final) pass only.
* These are the passes we care about in this case.
*/
return (((severity & ERR_PASS1) && passn != 1) ||
((severity & ERR_PASS2) && pass0 != 2));
} | 0 |
Chrome | 20b65d00ca3d8696430e22efad7485366f8c3a21 | NOT_APPLICABLE | NOT_APPLICABLE | NormalPage::NormalPage(PageMemory* storage, BaseArena* arena)
: BasePage(storage, arena), object_start_bit_map_(Payload()) {
#if DCHECK_IS_ON()
DCHECK(IsPageHeaderAddress(reinterpret_cast<Address>(this)));
#endif // DCHECK_IS_ON()
}
| 0 |
sqlite | e41fd72acc7a06ce5a6a7d28154db1ffe8ba37a8 | NOT_APPLICABLE | NOT_APPLICABLE | static RtreeNode *rtreeNodeOfFirstSearchPoint(RtreeCursor *pCur, int *pRC){
sqlite3_int64 id;
int ii = 1 - pCur->bPoint;
assert( ii==0 || ii==1 );
assert( pCur->bPoint || pCur->nPoint );
if( pCur->aNode[ii]==0 ){
assert( pRC!=0 );
id = ii ? pCur->aPoint[0].id : pCur->sPoint.id;
*pRC = nodeAcquire(RTREE_OF_CURSOR(pCur), id, 0, &pCur->aNode[ii]);
}
return pCur->aNode[ii];
} | 0 |
git | 34fa79a6cde56d6d428ab0d3160cb094ebad3305 | NOT_APPLICABLE | NOT_APPLICABLE | void mark_tree_uninteresting(struct tree *tree)
{
struct object *obj = &tree->object;
if (!tree)
return;
if (obj->flags & UNINTERESTING)
return;
obj->flags |= UNINTERESTING;
mark_tree_contents_uninteresting(tree);
}
| 0 |
raptor | a676f235309a59d4aa78eeffd2574ae5d341fcb0 | NOT_APPLICABLE | NOT_APPLICABLE | char* rdfa_get_buffer(rdfacontext* context, size_t* blen)
{
*blen = context->wb_allocated;
return context->working_buffer;
}
| 0 |
openexr | bc88cdb6c97fbf5bc5d11ad8ca55306da931283a | NOT_APPLICABLE | NOT_APPLICABLE | ScanLineInputFile::rawPixelData (int firstScanLine,
const char *&pixelData,
int &pixelDataSize)
{
try
{
#if ILMBASE_THREADING_ENABLED
std::lock_guard<std::mutex> lock (*_streamData);
#endif
if (firstScanLine < _data->minY || firstScanLine > _data->maxY)
{
throw IEX_NAMESPACE::ArgExc ("Tried to read scan line outside "
"the image file's data window.");
}
int minY = lineBufferMinY
(firstScanLine, _data->minY, _data->linesInBuffer);
readPixelData
(_streamData, _data, minY, _data->lineBuffers[0]->buffer, pixelDataSize);
pixelData = _data->lineBuffers[0]->buffer;
}
catch (IEX_NAMESPACE::BaseExc &e)
{
REPLACE_EXC (e, "Error reading pixel data from image "
"file \"" << fileName() << "\". " << e.what());
throw;
}
} | 0 |
naviserver | a5c3079f1d8996d5f34c9384a440acf3519ca3bb | NOT_APPLICABLE | NOT_APPLICABLE | AsyncWriterThread(void *arg)
{
SpoolerQueue *queuePtr = (SpoolerQueue*)arg;
char charBuffer[1];
int pollTimeout;
Ns_ReturnCode status;
bool stopping;
AsyncWriteData *curPtr, *nextPtr, *writePtr;
PollData pdata;
Ns_ThreadSetName("-asynclogwriter%d-", queuePtr->id);
queuePtr->threadName = Ns_ThreadGetName();
/*
* Allocate and initialize controlling variables
*/
PollCreate(&pdata);
writePtr = NULL;
stopping = NS_FALSE;
/*
* Loop forever until signaled to shutdown and all
* connections are complete and gracefully closed.
*/
while (!stopping) {
/*
* Always listen to the trigger pipe. We could as well perform
* in the writer thread async write operations, but for the
* effect of reducing latency in connection threads, this is
* not an issue. To keep things simple, we perform the
* typically small write operations without testing for POLLOUT.
*/
PollReset(&pdata);
(void)PollSet(&pdata, queuePtr->pipe[0], (short)POLLIN, NULL);
if (writePtr == NULL) {
pollTimeout = 30 * 1000;
} else {
pollTimeout = 0;
}
/*
* Wait for data
*/
/*n =*/ (void) PollWait(&pdata, pollTimeout);
/*
* Select and drain the trigger pipe if necessary.
*/
if (PollIn(&pdata, 0)) {
if (ns_recv(queuePtr->pipe[0], charBuffer, 1u, 0) != 1) {
Ns_Fatal("asynclogwriter: trigger ns_recv() failed: %s",
ns_sockstrerror(ns_sockerrno));
}
if (queuePtr->stopped) {
/*
* Drain the queue from everything
*/
for (curPtr = writePtr; curPtr != NULL; curPtr = curPtr->nextPtr) {
ssize_t written = ns_write(curPtr->fd, curPtr->buf, curPtr->bufsize);
if (unlikely(written != (ssize_t)curPtr->bufsize)) {
WriteWarningRaw("drain writer", curPtr->fd, curPtr->bufsize, written);
}
}
writePtr = NULL;
for (curPtr = queuePtr->sockPtr; curPtr != NULL; curPtr = curPtr->nextPtr) {
ssize_t written = ns_write(curPtr->fd, curPtr->buf, curPtr->bufsize);
if (unlikely(written != (ssize_t)curPtr->bufsize)) {
WriteWarningRaw("drain queue", curPtr->fd, curPtr->bufsize, written);
}
}
queuePtr->sockPtr = NULL;
/*
* Notify the caller (normally
* NsAsyncWriterQueueDisable()) that we are done
*/
Ns_CondBroadcast(&queuePtr->cond);
}
}
/*
* Write to all available file descriptors
*/
curPtr = writePtr;
writePtr = NULL;
while (curPtr != NULL) {
ssize_t written;
nextPtr = curPtr->nextPtr;
status = NS_OK;
/*
* Write the actual data and allow for partial write operations.
*/
written = ns_write(curPtr->fd, curPtr->buf, curPtr->bufsize);
if (unlikely(written < 0)) {
status = NS_ERROR;
} else {
curPtr->size -= (size_t)written;
curPtr->nsent += written;
curPtr->bufsize -= (size_t)written;
if (curPtr->data != NULL) {
curPtr->buf += written;
}
}
if (unlikely(status != NS_OK)) {
AsyncWriterRelease(curPtr);
queuePtr->queuesize--;
} else {
/*
* The write operation was successful. Check if there
* is some remaining data to write. If not we are done
* with this request can release the write buffer.
*/
if (curPtr->size > 0u) {
Push(curPtr, writePtr);
} else {
AsyncWriterRelease(curPtr);
queuePtr->queuesize--;
}
}
curPtr = nextPtr;
}
/*
* Check for shutdown
*/
stopping = queuePtr->shutdown;
if (stopping) {
curPtr = queuePtr->sockPtr;
assert(writePtr == NULL);
while (curPtr != NULL) {
ssize_t written = ns_write(curPtr->fd, curPtr->buf, curPtr->bufsize);
if (unlikely(written != (ssize_t)curPtr->bufsize)) {
WriteWarningRaw("shutdown", curPtr->fd, curPtr->bufsize, written);
}
curPtr = curPtr->nextPtr;
}
} else {
/*
* Add fresh jobs to the writer queue. This means actually to
* move jobs from queuePtr->sockPtr (kept name for being able
* to use the same queue as above) to the currently active
* jobs in queuePtr->curPtr.
*/
Ns_MutexLock(&queuePtr->lock);
curPtr = queuePtr->sockPtr;
queuePtr->sockPtr = NULL;
while (curPtr != NULL) {
nextPtr = curPtr->nextPtr;
Push(curPtr, writePtr);
queuePtr->queuesize++;
curPtr = nextPtr;
}
queuePtr->curPtr = writePtr;
Ns_MutexUnlock(&queuePtr->lock);
}
}
PollFree(&pdata);
queuePtr->stopped = NS_TRUE;
Ns_Log(Notice, "exiting");
} | 0 |
libexpat | 9b4ce651b26557f16103c3a366c91934ecd439ab | NOT_APPLICABLE | NOT_APPLICABLE | XML_UseParserAsHandlerArg(XML_Parser parser) {
if (parser != NULL)
parser->m_handlerArg = parser;
} | 0 |
libgd | a93eac0e843148dc2d631c3ba80af17e9c8c860f | NOT_APPLICABLE | NOT_APPLICABLE | lsqrt (long n)
{
long result = (long) sqrt ((double) n);
return result;
} | 0 |
tcpdump | 1dcd10aceabbc03bf571ea32b892c522cbe923de | NOT_APPLICABLE | NOT_APPLICABLE | sig_print(netdissect_options *ndo,
const u_char *p)
{
uint32_t call_ref;
ND_TCHECK(p[PROTO_POS]);
if (p[PROTO_POS] == Q2931) {
/*
* protocol:Q.2931 for User to Network Interface
* (UNI 3.1) signalling
*/
ND_PRINT((ndo, "Q.2931"));
ND_TCHECK(p[MSG_TYPE_POS]);
ND_PRINT((ndo, ":%s ",
tok2str(msgtype2str, "msgtype#%d", p[MSG_TYPE_POS])));
/*
* The call reference comes before the message type,
* so if we know we have the message type, which we
* do from the caplen test above, we also know we have
* the call reference.
*/
call_ref = EXTRACT_24BITS(&p[CALL_REF_POS]);
ND_PRINT((ndo, "CALL_REF:0x%06x", call_ref));
} else {
/* SSCOP with some unknown protocol atop it */
ND_PRINT((ndo, "SSCOP, proto %d ", p[PROTO_POS]));
}
return;
trunc:
ND_PRINT((ndo, " %s", tstr));
}
| 0 |
Chrome | 80742f2ffeb9e90cd85cbee27acb9f924ffebd16 | NOT_APPLICABLE | NOT_APPLICABLE | AutofillManager::~AutofillManager() {
download_manager_.SetObserver(NULL);
}
| 0 |
linux | ae7b4e1f213aa659aedf9c6ecad0bf5f0476e1e2 | NOT_APPLICABLE | NOT_APPLICABLE | struct fib6_table *fib6_new_table(struct net *net, u32 id)
{
struct fib6_table *tb;
if (id == 0)
id = RT6_TABLE_MAIN;
tb = fib6_get_table(net, id);
if (tb)
return tb;
tb = fib6_alloc_table(net, id);
if (tb)
fib6_link_table(net, tb);
return tb;
}
| 0 |
linux | ef3313e84acbf349caecae942ab3ab731471f1a1 | NOT_APPLICABLE | NOT_APPLICABLE | static int ax25_release(struct socket *sock)
{
struct sock *sk = sock->sk;
ax25_cb *ax25;
if (sk == NULL)
return 0;
sock_hold(sk);
sock_orphan(sk);
lock_sock(sk);
ax25 = ax25_sk(sk);
if (sk->sk_type == SOCK_SEQPACKET) {
switch (ax25->state) {
case AX25_STATE_0:
release_sock(sk);
ax25_disconnect(ax25, 0);
lock_sock(sk);
ax25_destroy_socket(ax25);
break;
case AX25_STATE_1:
case AX25_STATE_2:
ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
release_sock(sk);
ax25_disconnect(ax25, 0);
lock_sock(sk);
ax25_destroy_socket(ax25);
break;
case AX25_STATE_3:
case AX25_STATE_4:
ax25_clear_queues(ax25);
ax25->n2count = 0;
switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
case AX25_PROTO_STD_SIMPLEX:
case AX25_PROTO_STD_DUPLEX:
ax25_send_control(ax25,
AX25_DISC,
AX25_POLLON,
AX25_COMMAND);
ax25_stop_t2timer(ax25);
ax25_stop_t3timer(ax25);
ax25_stop_idletimer(ax25);
break;
#ifdef CONFIG_AX25_DAMA_SLAVE
case AX25_PROTO_DAMA_SLAVE:
ax25_stop_t3timer(ax25);
ax25_stop_idletimer(ax25);
break;
#endif
}
ax25_calculate_t1(ax25);
ax25_start_t1timer(ax25);
ax25->state = AX25_STATE_2;
sk->sk_state = TCP_CLOSE;
sk->sk_shutdown |= SEND_SHUTDOWN;
sk->sk_state_change(sk);
sock_set_flag(sk, SOCK_DESTROY);
break;
default:
break;
}
} else {
sk->sk_state = TCP_CLOSE;
sk->sk_shutdown |= SEND_SHUTDOWN;
sk->sk_state_change(sk);
ax25_destroy_socket(ax25);
}
sock->sk = NULL;
release_sock(sk);
sock_put(sk);
return 0;
}
| 0 |
Chrome | 5385c44d9634d00b1cec2abf0fe7290d4205c7b0 | NOT_APPLICABLE | NOT_APPLICABLE | void PopulateResourceResponse(net::URLRequest* request,
ResourceResponse* response) {
response->status = request->status();
response->request_time = request->request_time();
response->response_time = request->response_time();
response->headers = request->response_headers();
request->GetCharset(&response->charset);
response->content_length = request->GetExpectedContentSize();
request->GetMimeType(&response->mime_type);
net::HttpResponseInfo response_info = request->response_info();
response->was_fetched_via_spdy = response_info.was_fetched_via_spdy;
response->was_npn_negotiated = response_info.was_npn_negotiated;
response->npn_negotiated_protocol = response_info.npn_negotiated_protocol;
response->was_fetched_via_proxy = request->was_fetched_via_proxy();
response->socket_address = request->GetSocketAddress();
appcache::AppCacheInterceptor::GetExtraResponseInfo(
request,
&response->appcache_id,
&response->appcache_manifest_url);
}
| 0 |
Chrome | c71d8045ce0592cf3f4290744ab57b23c1d1b4c6 | NOT_APPLICABLE | NOT_APPLICABLE | RenderFrameDevToolsAgentHost::RenderFrameDevToolsAgentHost(
FrameTreeNode* frame_tree_node)
: DevToolsAgentHostImpl(frame_tree_node->devtools_frame_token().ToString()),
frame_tree_node_(nullptr) {
SetFrameTreeNode(frame_tree_node);
frame_host_ = frame_tree_node->current_frame_host();
render_frame_alive_ = frame_host_ && frame_host_->IsRenderFrameLive();
AddRef(); // Balanced in DestroyOnRenderFrameGone.
NotifyCreated();
}
| 0 |
lxde | 56f66684592abf257c4004e6e1fff041c64a12ce | NOT_APPLICABLE | NOT_APPLICABLE | MenuCacheNotifyId menu_cache_add_reload_notify(MenuCache* cache, MenuCacheReloadNotify func, gpointer user_data)
{
GSList* l = g_slist_alloc();
CacheReloadNotifier* n = g_slice_new(CacheReloadNotifier);
gboolean is_first;
n->func = func;
n->user_data = user_data;
l->data = n;
MENU_CACHE_LOCK;
is_first = (cache->root_dir == NULL && cache->notifiers == NULL);
cache->notifiers = g_slist_concat( cache->notifiers, l );
/* reload existing file first so it will be ready right away */
if(is_first && cache->reload_id == 0)
cache->reload_id = g_idle_add_full(G_PRIORITY_HIGH_IDLE,
menu_cache_reload_idle,
menu_cache_ref(cache),
(GDestroyNotify)menu_cache_unref);
MENU_CACHE_UNLOCK;
return (MenuCacheNotifyId)l;
}
| 0 |
radare2 | cb8b683758edddae2d2f62e8e63a738c39f92683 | NOT_APPLICABLE | NOT_APPLICABLE | static void rap_break (void *u) {
RIORap *rior = (RIORap*) u;
if (u) {
r_socket_close (rior->fd);
rior->fd = NULL;
}
} | 0 |
linux | 59c4bd853abcea95eccc167a7d7fd5f1a5f47b98 | NOT_APPLICABLE | NOT_APPLICABLE | static inline void copy_kernel_to_xregs(struct xregs_state *xstate, u64 mask)
{
u32 lmask = mask;
u32 hmask = mask >> 32;
XSTATE_XRESTORE(xstate, lmask, hmask);
} | 0 |
linux | bb1fceca22492109be12640d49f5ea5a544c6bb4 | NOT_APPLICABLE | NOT_APPLICABLE | static inline struct sk_buff *tcp_write_queue_head(const struct sock *sk)
{
return skb_peek(&sk->sk_write_queue);
} | 0 |
linux | b6a2fea39318e43fee84fa7b0b90d68bed92d2ba | NOT_APPLICABLE | NOT_APPLICABLE | asmlinkage long compat_sys_epoll_wait(int epfd,
struct compat_epoll_event __user *events,
int maxevents, int timeout)
{
long i, ret, err = 0;
struct epoll_event __user *kbuf;
struct epoll_event ev;
if ((maxevents <= 0) ||
(maxevents > (INT_MAX / sizeof(struct epoll_event))))
return -EINVAL;
kbuf = compat_alloc_user_space(sizeof(struct epoll_event) * maxevents);
ret = sys_epoll_wait(epfd, kbuf, maxevents, timeout);
for (i = 0; i < ret; i++) {
err |= __get_user(ev.events, &kbuf[i].events);
err |= __get_user(ev.data, &kbuf[i].data);
err |= __put_user(ev.events, &events->events);
err |= __put_user_unaligned(ev.data, &events->data);
events++;
}
return err ? -EFAULT: ret;
} | 0 |
radare2 | 04edfa82c1f3fa2bc3621ccdad2f93bdbf00e4f9 | NOT_APPLICABLE | NOT_APPLICABLE | R_API void r_str_sanitize(char *c) {
char *d = c;
if (d) {
for (; *d; c++, d++) {
switch (*d) {
case '`':
case '$':
case '{':
case '}':
case '~':
case '|':
case ';':
case '#':
case '@':
case '&':
case '<':
case '>':
*c = '_';
continue;
}
}
}
} | 0 |
Chrome | 6a310d99a741f9ba5e4e537c5ec49d3adbe5876f | NOT_APPLICABLE | NOT_APPLICABLE | void AXTree::SetEnableExtraMacNodes(bool enabled) {
DCHECK(enable_extra_mac_nodes_ != enabled);
DCHECK_EQ(0U, table_info_map_.size());
enable_extra_mac_nodes_ = enabled;
}
| 0 |
open62541 | b79db1ac78146fc06b0b8435773d3967de2d659c | NOT_APPLICABLE | NOT_APPLICABLE | START_TEST(SecureChannel_sendSymmetricMessage_modeNone) {
// initialize dummy message
UA_ReadRequest dummyMessage;
UA_ReadRequest_init(&dummyMessage);
UA_DataType dummyType = UA_TYPES[UA_TYPES_READREQUEST];
testChannel.securityMode = UA_MESSAGESECURITYMODE_NONE;
UA_StatusCode retval = UA_SecureChannel_sendSymmetricMessage(&testChannel, 42, UA_MESSAGETYPE_MSG,
&dummyMessage, &dummyType);
ck_assert_msg(retval == UA_STATUSCODE_GOOD, "Expected success");
ck_assert_msg(!fCalled.sym_sign, "Expected message to not have been signed");
ck_assert_msg(!fCalled.sym_enc, "Expected message to not have been encrypted");
} END_TEST | 0 |
dbus | 954d75b2b64e4799f360d2a6bf9cff6d9fee37e7 | NOT_APPLICABLE | NOT_APPLICABLE | _dbus_get_real_time (long *tv_sec,
long *tv_usec)
{
FILETIME ft;
dbus_uint64_t time64;
GetSystemTimeAsFileTime (&ft);
memcpy (&time64, &ft, sizeof (time64));
/* Convert from 100s of nanoseconds since 1601-01-01
* to Unix epoch. Yes, this is Y2038 unsafe.
*/
time64 -= DBUS_INT64_CONSTANT (116444736000000000);
time64 /= 10;
if (tv_sec)
*tv_sec = time64 / 1000000;
if (tv_usec)
*tv_usec = time64 % 1000000;
}
| 0 |
Chrome | 56b512399a5c2221ba4812f5170f3f8dc352cd74 | NOT_APPLICABLE | NOT_APPLICABLE | void NavigationRequest::CreateNavigationHandle(bool is_for_commit) {
DCHECK(frame_tree_node_->navigation_request() == this || is_for_commit);
FrameTreeNode* frame_tree_node = frame_tree_node_;
std::vector<GURL> redirect_chain;
if (!begin_params_->client_side_redirect_url.is_empty()) {
redirect_chain.push_back(begin_params_->client_side_redirect_url);
} else if (!commit_params_.redirects.empty()) {
for (const auto& url : commit_params_.redirects)
redirect_chain.push_back(url);
}
if (!is_for_commit)
redirect_chain.push_back(common_params_.url);
net::HttpRequestHeaders headers;
headers.AddHeadersFromString(begin_params_->headers);
std::unique_ptr<NavigationHandleImpl> navigation_handle =
base::WrapUnique(new NavigationHandleImpl(
this, redirect_chain,
FrameMsg_Navigate_Type::IsSameDocument(
common_params_.navigation_type),
nav_entry_id_, std::move(navigation_ui_data_), std::move(headers),
Referrer::SanitizeForRequest(common_params_.url,
common_params_.referrer)));
if (!frame_tree_node->navigation_request() && !is_for_commit) {
return;
}
navigation_handle_ = std::move(navigation_handle);
}
| 0 |
linux | f2fcfcd670257236ebf2088bbdf26f6a8ef459fe | NOT_APPLICABLE | NOT_APPLICABLE | static void l2cap_do_start(struct sock *sk)
{
struct l2cap_conn *conn = l2cap_pi(sk)->conn;
if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) {
if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
return;
if (l2cap_check_security(sk)) {
struct l2cap_conn_req req;
req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
req.psm = l2cap_pi(sk)->psm;
l2cap_pi(sk)->ident = l2cap_get_ident(conn);
l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
L2CAP_CONN_REQ, sizeof(req), &req);
}
} else {
struct l2cap_info_req req;
req.type = cpu_to_le16(L2CAP_IT_FEAT_MASK);
conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT;
conn->info_ident = l2cap_get_ident(conn);
mod_timer(&conn->info_timer, jiffies +
msecs_to_jiffies(L2CAP_INFO_TIMEOUT));
l2cap_send_cmd(conn, conn->info_ident,
L2CAP_INFO_REQ, sizeof(req), &req);
}
}
| 0 |
date | 8f2d7a0c7e52cea8333824bd527822e5449ed83d | NOT_APPLICABLE | NOT_APPLICABLE | d_lite_yday(VALUE self)
{
get_d1(self);
return INT2FIX(m_yday(dat));
} | 0 |
Chrome | 94b3728a2836da335a10085d4089c9d8e1c9d225 | NOT_APPLICABLE | NOT_APPLICABLE | bool PDFiumEngine::HandleEvent(const pp::InputEvent& event) {
DCHECK(!defer_page_unload_);
defer_page_unload_ = true;
bool rv = false;
switch (event.GetType()) {
case PP_INPUTEVENT_TYPE_MOUSEDOWN:
rv = OnMouseDown(pp::MouseInputEvent(event));
break;
case PP_INPUTEVENT_TYPE_MOUSEUP:
rv = OnMouseUp(pp::MouseInputEvent(event));
break;
case PP_INPUTEVENT_TYPE_MOUSEMOVE:
rv = OnMouseMove(pp::MouseInputEvent(event));
break;
case PP_INPUTEVENT_TYPE_KEYDOWN:
rv = OnKeyDown(pp::KeyboardInputEvent(event));
break;
case PP_INPUTEVENT_TYPE_KEYUP:
rv = OnKeyUp(pp::KeyboardInputEvent(event));
break;
case PP_INPUTEVENT_TYPE_CHAR:
rv = OnChar(pp::KeyboardInputEvent(event));
break;
case PP_INPUTEVENT_TYPE_TOUCHSTART: {
KillTouchTimer(next_touch_timer_id_);
pp::TouchInputEvent touch_event(event);
if (touch_event.GetTouchCount(PP_TOUCHLIST_TYPE_TARGETTOUCHES) == 1)
ScheduleTouchTimer(touch_event);
break;
}
case PP_INPUTEVENT_TYPE_TOUCHEND:
KillTouchTimer(next_touch_timer_id_);
break;
case PP_INPUTEVENT_TYPE_TOUCHMOVE:
KillTouchTimer(next_touch_timer_id_);
break;
default:
break;
}
DCHECK(defer_page_unload_);
defer_page_unload_ = false;
std::vector<int> pages_to_unload;
std::swap(pages_to_unload, deferred_page_unloads_);
for (int page_index : pages_to_unload)
pages_[page_index]->Unload();
return rv;
}
| 0 |
Chrome | ee281f7cac9df44fe241a37f188b28be8845ded0 | NOT_APPLICABLE | NOT_APPLICABLE | const ResourceLoaderOptions& ResourceFetcher::defaultResourceOptions()
{
DEFINE_STATIC_LOCAL(ResourceLoaderOptions, options, (SniffContent, BufferData, AllowStoredCredentials, ClientRequestedCredentials, CheckContentSecurityPolicy, DocumentContext));
return options;
}
| 0 |
libmodbus | 5ccdf5ef79d742640355d1132fa9e2abc7fbaefc | NOT_APPLICABLE | NOT_APPLICABLE | int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask)
{
int rc;
int req_length;
/* The request length can not exceed _MIN_REQ_LENGTH - 2 and 4 bytes to
* store the masks. The ugly substraction is there to remove the 'nb' value
* (2 bytes) which is not used. */
uint8_t req[_MIN_REQ_LENGTH + 2];
req_length = ctx->backend->build_request_basis(ctx,
MODBUS_FC_MASK_WRITE_REGISTER,
addr, 0, req);
/* HACKISH, count is not used */
req_length -= 2;
req[req_length++] = and_mask >> 8;
req[req_length++] = and_mask & 0x00ff;
req[req_length++] = or_mask >> 8;
req[req_length++] = or_mask & 0x00ff;
rc = send_msg(ctx, req, req_length);
if (rc > 0) {
/* Used by write_bit and write_register */
uint8_t rsp[MAX_MESSAGE_LENGTH];
rc = _modbus_receive_msg(ctx, rsp, MSG_CONFIRMATION);
if (rc == -1)
return -1;
rc = check_confirmation(ctx, req, rsp, rc);
}
return rc;
}
| 0 |
Chrome | 0720b02e4f303ea6b114d4ae9453e3a7ff55f8dc | NOT_APPLICABLE | NOT_APPLICABLE | void WebContentsImpl::EnsureOpenerProxiesExist(RenderFrameHost* source_rfh) {
WebContentsImpl* source_web_contents = static_cast<WebContentsImpl*>(
WebContents::FromRenderFrameHost(source_rfh));
if (source_web_contents) {
if (GetBrowserPluginEmbedder() &&
GuestMode::IsCrossProcessFrameGuest(source_web_contents)) {
return;
}
if (this != source_web_contents && GetBrowserPluginGuest()) {
source_web_contents->GetRenderManager()->CreateRenderFrameProxy(
GetSiteInstance());
} else {
RenderFrameHostImpl* source_rfhi =
static_cast<RenderFrameHostImpl*>(source_rfh);
source_rfhi->frame_tree_node()->render_manager()->CreateOpenerProxies(
GetSiteInstance(), nullptr);
}
}
}
| 0 |
Chrome | fcd3a7a671ecf2d5f46ea34787d27507a914d2f5 | NOT_APPLICABLE | NOT_APPLICABLE | void SyncBackendHost::HandleConnectionStatusChangeOnFrontendLoop(
sync_api::ConnectionStatus status) {
if (!frontend_)
return;
DCHECK_EQ(MessageLoop::current(), frontend_loop_);
frontend_->OnConnectionStatusChange(status);
}
| 0 |
libvirt | 506e9d6c2d4baaf580d489fff0690c0ff2ff588f | NOT_APPLICABLE | NOT_APPLICABLE | virDomainMigrateGetMaxSpeed(virDomainPtr domain,
unsigned long *bandwidth,
unsigned int flags)
{
virConnectPtr conn;
VIR_DOMAIN_DEBUG(domain, "bandwidth = %p, flags=%x", bandwidth, flags);
virResetLastError();
virCheckDomainReturn(domain, -1);
conn = domain->conn;
virCheckNonNullArgGoto(bandwidth, error);
virCheckReadOnlyGoto(conn->flags, error);
if (conn->driver->domainMigrateGetMaxSpeed) {
if (conn->driver->domainMigrateGetMaxSpeed(domain, bandwidth, flags) < 0)
goto error;
return 0;
}
virReportUnsupportedError();
error:
virDispatchError(conn);
return -1;
}
| 0 |
linux | d29216842a85c7970c536108e093963f02714498 | NOT_APPLICABLE | NOT_APPLICABLE | int proc_dostring(struct ctl_table *table, int write,
void __user *buffer, size_t *lenp, loff_t *ppos)
{
if (write && *ppos && sysctl_writes_strict == SYSCTL_WRITES_WARN)
warn_sysctl_write(table);
return _proc_do_string((char *)(table->data), table->maxlen, write,
(char __user *)buffer, lenp, ppos);
}
| 0 |
file | d65781527c8134a1202b2649695d48d5701ac60b | NOT_APPLICABLE | NOT_APPLICABLE | varexpand(struct magic_set *ms, char *buf, size_t len, const char *str)
{
const char *ptr, *sptr, *e, *t, *ee, *et;
size_t l;
for (sptr = str; (ptr = strstr(sptr, "${")) != NULL;) {
l = (size_t)(ptr - sptr);
if (l >= len)
return -1;
memcpy(buf, sptr, l);
buf += l;
len -= l;
ptr += 2;
if (!*ptr || ptr[1] != '?')
return -1;
for (et = t = ptr + 2; *et && *et != ':'; et++)
continue;
if (*et != ':')
return -1;
for (ee = e = et + 1; *ee && *ee != '}'; ee++)
continue;
if (*ee != '}')
return -1;
switch (*ptr) {
case 'x':
if (ms->mode & 0111) {
ptr = t;
l = et - t;
} else {
ptr = e;
l = ee - e;
}
break;
default:
return -1;
}
if (l >= len)
return -1;
memcpy(buf, ptr, l);
buf += l;
len -= l;
sptr = ee + 1;
}
l = strlen(sptr);
if (l >= len)
return -1;
memcpy(buf, sptr, l);
buf[l] = '\0';
return 0;
} | 0 |
Chrome | 537abce1bcf7378e760e904d6e5540a02a2fca9f | CVE-2013-0909 | CWE-200 | int ShellBrowserMain(const content::MainFunctionParams& parameters) {
bool layout_test_mode =
CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree);
base::ScopedTempDir browser_context_path_for_layout_tests;
if (layout_test_mode) {
CHECK(browser_context_path_for_layout_tests.CreateUniqueTempDir());
CHECK(!browser_context_path_for_layout_tests.path().MaybeAsASCII().empty());
CommandLine::ForCurrentProcess()->AppendSwitchASCII(
switches::kContentShellDataPath,
browser_context_path_for_layout_tests.path().MaybeAsASCII());
}
scoped_ptr<content::BrowserMainRunner> main_runner_(
content::BrowserMainRunner::Create());
int exit_code = main_runner_->Initialize(parameters);
if (exit_code >= 0)
return exit_code;
if (CommandLine::ForCurrentProcess()->HasSwitch(
switches::kCheckLayoutTestSysDeps)) {
MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
main_runner_->Run();
main_runner_->Shutdown();
return 0;
}
if (layout_test_mode) {
content::WebKitTestController test_controller;
std::string test_string;
CommandLine::StringVector args =
CommandLine::ForCurrentProcess()->GetArgs();
size_t command_line_position = 0;
bool ran_at_least_once = false;
#if defined(OS_ANDROID)
std::cout << "#READY\n";
std::cout.flush();
#endif
while (GetNextTest(args, &command_line_position, &test_string)) {
if (test_string.empty())
continue;
if (test_string == "QUIT")
break;
bool enable_pixel_dumps;
std::string pixel_hash;
FilePath cwd;
GURL test_url = GetURLForLayoutTest(
test_string, &cwd, &enable_pixel_dumps, &pixel_hash);
if (!content::WebKitTestController::Get()->PrepareForLayoutTest(
test_url, cwd, enable_pixel_dumps, pixel_hash)) {
break;
}
ran_at_least_once = true;
main_runner_->Run();
if (!content::WebKitTestController::Get()->ResetAfterLayoutTest())
break;
}
if (!ran_at_least_once) {
MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
main_runner_->Run();
}
exit_code = 0;
} else {
exit_code = main_runner_->Run();
}
main_runner_->Shutdown();
return exit_code;
}
| 1 |
redis | 9fdcc15962f9ff4baebe6fdd947816f43f730d50 | NOT_APPLICABLE | NOT_APPLICABLE | void cliLoadPreferences(void) {
sds rcfile = getDotfilePath(REDIS_CLI_RCFILE_ENV,REDIS_CLI_RCFILE_DEFAULT);
if (rcfile == NULL) return;
FILE *fp = fopen(rcfile,"r");
char buf[1024];
if (fp) {
while(fgets(buf,sizeof(buf),fp) != NULL) {
sds *argv;
int argc;
argv = sdssplitargs(buf,&argc);
if (argc > 0) cliSetPreferences(argv,argc,0);
sdsfreesplitres(argv,argc);
}
fclose(fp);
}
sdsfree(rcfile);
}
| 0 |
libsass | 8f40dc03e5ab5a8b2ebeb72b31f8d1adbb2fd6ae | NOT_APPLICABLE | NOT_APPLICABLE | struct Sass_Options* ADDCALL sass_data_context_get_options(struct Sass_Data_Context* ctx) { return ctx; } | 0 |
Chrome | 50370b3c98047bdc80184ff87a502edc5c597d3a | NOT_APPLICABLE | NOT_APPLICABLE | void OneClickSigninHelper::CreateForWebContentsWithPasswordManager(
content::WebContents* contents,
PasswordManager* password_manager) {
if (!FromWebContents(contents)) {
contents->SetUserData(UserDataKey(),
new OneClickSigninHelper(contents, password_manager));
}
}
| 0 |
Android | 94d9e646454f6246bf823b6897bd6aea5f08eda3 | NOT_APPLICABLE | NOT_APPLICABLE | bool ACodec::BaseState::onOMXEvent(
OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {
if (event != OMX_EventError) {
ALOGV("[%s] EVENT(%d, 0x%08x, 0x%08x)",
mCodec->mComponentName.c_str(), event, data1, data2);
return false;
}
ALOGE("[%s] ERROR(0x%08x)", mCodec->mComponentName.c_str(), data1);
OMX_ERRORTYPE omxError = (OMX_ERRORTYPE)data1;
if (!isOMXError(omxError)) {
ALOGW("Invalid OMX error %#x", omxError);
omxError = OMX_ErrorUndefined;
}
mCodec->signalError(omxError);
return true;
}
| 0 |
Chrome | 94fef6e2a56ef5b3ed0dc0fd94e6ad52267067fb | NOT_APPLICABLE | NOT_APPLICABLE | scoped_refptr<base::SingleThreadTaskRunner> TaskService::GetTaskRunner(
RunnerId runner_id) {
base::AutoLock lock(lock_);
if (runner_id == kDefaultRunnerId)
return default_task_runner_;
if (threads_.size() < runner_id)
threads_.resize(runner_id);
size_t thread = runner_id - 1;
if (!threads_[thread]) {
threads_[thread] = base::MakeUnique<base::Thread>(
base::StringPrintf("MidiService_TaskService_Thread(%zu)", runner_id));
#if defined(OS_WIN)
threads_[thread]->init_com_with_mta(true);
#endif
threads_[thread]->Start();
}
return threads_[thread]->task_runner();
}
| 0 |
spice | 8af619009660b24e0b41ad26b30289eea288fcc2 | NOT_APPLICABLE | NOT_APPLICABLE | static void reds_mig_target_client_add(RedClient *client)
{
RedsMigTargetClient *mig_client;
spice_assert(reds);
spice_info(NULL);
mig_client = spice_malloc0(sizeof(RedsMigTargetClient));
mig_client->client = client;
ring_init(&mig_client->pending_links);
ring_add(&reds->mig_target_clients, &mig_client->link);
reds->num_mig_target_clients++;
}
| 0 |
linux | d974baa398f34393db76be45f7d4d04fbdbb4a0a | NOT_APPLICABLE | NOT_APPLICABLE | static u64 vmx_get_mt_mask(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio)
{
u64 ret;
/* For VT-d and EPT combination
* 1. MMIO: always map as UC
* 2. EPT with VT-d:
* a. VT-d without snooping control feature: can't guarantee the
* result, try to trust guest.
* b. VT-d with snooping control feature: snooping control feature of
* VT-d engine can guarantee the cache correctness. Just set it
* to WB to keep consistent with host. So the same as item 3.
* 3. EPT without VT-d: always map as WB and set IPAT=1 to keep
* consistent with host MTRR
*/
if (is_mmio)
ret = MTRR_TYPE_UNCACHABLE << VMX_EPT_MT_EPTE_SHIFT;
else if (kvm_arch_has_noncoherent_dma(vcpu->kvm))
ret = kvm_get_guest_memory_type(vcpu, gfn) <<
VMX_EPT_MT_EPTE_SHIFT;
else
ret = (MTRR_TYPE_WRBACK << VMX_EPT_MT_EPTE_SHIFT)
| VMX_EPT_IPAT_BIT;
return ret;
}
| 0 |
linux | 942080643bce061c3dd9d5718d3b745dcb39a8bc | NOT_APPLICABLE | NOT_APPLICABLE | int ecryptfs_new_file_context(struct inode *ecryptfs_inode)
{
struct ecryptfs_crypt_stat *crypt_stat =
&ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat;
struct ecryptfs_mount_crypt_stat *mount_crypt_stat =
&ecryptfs_superblock_to_private(
ecryptfs_inode->i_sb)->mount_crypt_stat;
int cipher_name_len;
int rc = 0;
ecryptfs_set_default_crypt_stat_vals(crypt_stat, mount_crypt_stat);
crypt_stat->flags |= (ECRYPTFS_ENCRYPTED | ECRYPTFS_KEY_VALID);
ecryptfs_copy_mount_wide_flags_to_inode_flags(crypt_stat,
mount_crypt_stat);
rc = ecryptfs_copy_mount_wide_sigs_to_inode_sigs(crypt_stat,
mount_crypt_stat);
if (rc) {
printk(KERN_ERR "Error attempting to copy mount-wide key sigs "
"to the inode key sigs; rc = [%d]\n", rc);
goto out;
}
cipher_name_len =
strlen(mount_crypt_stat->global_default_cipher_name);
memcpy(crypt_stat->cipher,
mount_crypt_stat->global_default_cipher_name,
cipher_name_len);
crypt_stat->cipher[cipher_name_len] = '\0';
crypt_stat->key_size =
mount_crypt_stat->global_default_cipher_key_size;
ecryptfs_generate_new_key(crypt_stat);
rc = ecryptfs_init_crypt_ctx(crypt_stat);
if (rc)
ecryptfs_printk(KERN_ERR, "Error initializing cryptographic "
"context for cipher [%s]: rc = [%d]\n",
crypt_stat->cipher, rc);
out:
return rc;
}
| 0 |
virglrenderer | 0a5dff15912207b83018485f83e067474e818bab | NOT_APPLICABLE | NOT_APPLICABLE | void vrend_decode_reset(bool ctx_0_only)
{
int i;
vrend_hw_switch_context(dec_ctx[0]->grctx, true);
if (ctx_0_only == false) {
for (i = 1; i < VREND_MAX_CTX; i++) {
if (!dec_ctx[i])
continue;
if (!dec_ctx[i]->grctx)
continue;
vrend_destroy_context(dec_ctx[i]->grctx);
free(dec_ctx[i]);
dec_ctx[i] = NULL;
}
} else {
vrend_destroy_context(dec_ctx[0]->grctx);
free(dec_ctx[0]);
dec_ctx[0] = NULL;
}
}
| 0 |
mysql-server | 659514dc83299a7d8c7defeb543be4339fbe1ee1 | NOT_APPLICABLE | NOT_APPLICABLE | innodb_conn_clean_data(
/*===================*/
innodb_conn_data_t* conn_data,
bool has_lock,
bool free_all)
{
if (!conn_data) {
return;
}
LOCK_CURRENT_CONN_IF_NOT_LOCKED(has_lock, conn_data);
if (conn_data->idx_crsr) {
innodb_cb_cursor_close(conn_data->idx_crsr);
conn_data->idx_crsr = NULL;
}
if (conn_data->idx_read_crsr) {
innodb_cb_cursor_close(conn_data->idx_read_crsr);
conn_data->idx_read_crsr = NULL;
}
if (conn_data->crsr) {
innodb_cb_cursor_close(conn_data->crsr);
conn_data->crsr = NULL;
}
if (conn_data->read_crsr) {
innodb_cb_cursor_close(conn_data->read_crsr);
conn_data->read_crsr = NULL;
}
if (conn_data->crsr_trx) {
ib_err_t err;
innodb_cb_trx_commit(conn_data->crsr_trx);
err = ib_cb_trx_release(conn_data->crsr_trx);
assert(err == DB_SUCCESS);
conn_data->crsr_trx = NULL;
}
innodb_close_mysql_table(conn_data);
if (conn_data->tpl) {
ib_cb_tuple_delete(conn_data->tpl);
conn_data->tpl = NULL;
}
if (conn_data->idx_tpl) {
ib_cb_tuple_delete(conn_data->idx_tpl);
conn_data->idx_tpl = NULL;
}
if (conn_data->read_tpl) {
ib_cb_tuple_delete(conn_data->read_tpl);
conn_data->read_tpl = NULL;
}
if (conn_data->sel_tpl) {
ib_cb_tuple_delete(conn_data->sel_tpl);
conn_data->sel_tpl = NULL;
}
UNLOCK_CURRENT_CONN_IF_NOT_LOCKED(has_lock, conn_data);
if (free_all) {
if (conn_data->result) {
free(conn_data->result);
conn_data->result = NULL;
}
if (conn_data->row_buf) {
free(conn_data->row_buf);
conn_data->row_buf = NULL;
conn_data->row_buf_len = 0;
}
if (conn_data->cmd_buf) {
free(conn_data->cmd_buf);
conn_data->cmd_buf = NULL;
conn_data->cmd_buf_len = 0;
}
if (conn_data->mul_col_buf) {
free(conn_data->mul_col_buf);
conn_data->mul_col_buf = NULL;
conn_data->mul_col_buf_len = 0;
}
pthread_mutex_destroy(&conn_data->curr_conn_mutex);
free(conn_data);
}
} | 0 |
linux | 792039c73cf176c8e39a6e8beef2c94ff46522ed | NOT_APPLICABLE | NOT_APPLICABLE | static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
{
struct sock *sk = sock->sk;
struct l2cap_chan *chan = l2cap_pi(sk)->chan;
struct bt_security sec;
struct bt_power pwr;
int len, err = 0;
BT_DBG("sk %p", sk);
if (level == SOL_L2CAP)
return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
if (level != SOL_BLUETOOTH)
return -ENOPROTOOPT;
if (get_user(len, optlen))
return -EFAULT;
lock_sock(sk);
switch (optname) {
case BT_SECURITY:
if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
chan->chan_type != L2CAP_CHAN_RAW) {
err = -EINVAL;
break;
}
memset(&sec, 0, sizeof(sec));
if (chan->conn)
sec.level = chan->conn->hcon->sec_level;
else
sec.level = chan->sec_level;
if (sk->sk_state == BT_CONNECTED)
sec.key_size = chan->conn->hcon->enc_key_size;
len = min_t(unsigned int, len, sizeof(sec));
if (copy_to_user(optval, (char *) &sec, len))
err = -EFAULT;
break;
case BT_DEFER_SETUP:
if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
err = -EINVAL;
break;
}
if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
(u32 __user *) optval))
err = -EFAULT;
break;
case BT_FLUSHABLE:
if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
(u32 __user *) optval))
err = -EFAULT;
break;
case BT_POWER:
if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
&& sk->sk_type != SOCK_RAW) {
err = -EINVAL;
break;
}
pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
len = min_t(unsigned int, len, sizeof(pwr));
if (copy_to_user(optval, (char *) &pwr, len))
err = -EFAULT;
break;
case BT_CHANNEL_POLICY:
if (!enable_hs) {
err = -ENOPROTOOPT;
break;
}
if (put_user(chan->chan_policy, (u32 __user *) optval))
err = -EFAULT;
break;
default:
err = -ENOPROTOOPT;
break;
}
release_sock(sk);
return err;
}
| 0 |
Chrome | a4150b688a754d3d10d2ca385155b1c95d77d6ae | NOT_APPLICABLE | NOT_APPLICABLE | error::Error GLES2DecoderImpl::HandleTexSubImage3D(
uint32_t immediate_data_size,
const volatile void* cmd_data) {
if (!feature_info_->IsWebGL2OrES3Context())
return error::kUnknownCommand;
const char* func_name = "glTexSubImage3D";
const volatile gles2::cmds::TexSubImage3D& c =
*static_cast<const volatile gles2::cmds::TexSubImage3D*>(cmd_data);
TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexSubImage3D",
"widthXheight", c.width * c.height, "depth", c.depth);
GLboolean internal = static_cast<GLboolean>(c.internal);
if (internal == GL_TRUE && texture_state_.tex_image_failed)
return error::kNoError;
GLenum target = static_cast<GLenum>(c.target);
GLint level = static_cast<GLint>(c.level);
GLint xoffset = static_cast<GLint>(c.xoffset);
GLint yoffset = static_cast<GLint>(c.yoffset);
GLint zoffset = static_cast<GLint>(c.zoffset);
GLsizei width = static_cast<GLsizei>(c.width);
GLsizei height = static_cast<GLsizei>(c.height);
GLsizei depth = static_cast<GLsizei>(c.depth);
GLenum format = static_cast<GLenum>(c.format);
GLenum type = static_cast<GLenum>(c.type);
uint32_t pixels_shm_id = static_cast<uint32_t>(c.pixels_shm_id);
uint32_t pixels_shm_offset = static_cast<uint32_t>(c.pixels_shm_offset);
if (width < 0 || height < 0 || depth < 0) {
LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "dimensions < 0");
return error::kNoError;
}
PixelStoreParams params;
Buffer* buffer = state_.bound_pixel_unpack_buffer.get();
if (buffer) {
if (pixels_shm_id)
return error::kInvalidArguments;
if (buffer->GetMappedRange()) {
LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
"pixel unpack buffer should not be mapped to client memory");
return error::kNoError;
}
params = state_.GetUnpackParams(ContextState::k3D);
} else {
if (!pixels_shm_id && pixels_shm_offset)
return error::kInvalidArguments;
params.alignment = state_.unpack_alignment;
}
uint32_t pixels_size;
uint32_t skip_size;
uint32_t padding;
if (!GLES2Util::ComputeImageDataSizesES3(width, height, depth,
format, type,
params,
&pixels_size,
nullptr,
nullptr,
&skip_size,
&padding)) {
return error::kOutOfBounds;
}
DCHECK_EQ(0u, skip_size);
const void* pixels;
if (pixels_shm_id) {
pixels = GetSharedMemoryAs<const void*>(
pixels_shm_id, pixels_shm_offset, pixels_size);
if (!pixels)
return error::kOutOfBounds;
} else {
DCHECK(buffer || !pixels_shm_offset);
pixels = reinterpret_cast<const void*>(pixels_shm_offset);
}
TextureManager::DoTexSubImageArguments args = {
target, level, xoffset, yoffset, zoffset, width, height, depth,
format, type, pixels, pixels_size, padding,
TextureManager::DoTexSubImageArguments::kTexSubImage3D};
texture_manager()->ValidateAndDoTexSubImage(
this, &texture_state_, &state_, error_state_.get(), &framebuffer_state_,
func_name, args);
ExitCommandProcessingEarly();
return error::kNoError;
}
| 0 |
Chrome | f14efc560a12a513696d6396413b138879dabd7a | NOT_APPLICABLE | NOT_APPLICABLE | MessageRouter* ChildThread::GetRouter() {
DCHECK(base::MessageLoop::current() == message_loop());
return &router_;
}
| 0 |
Onigmo | ce13b17b955e0b6dfc6606b1fdbd4755590b360b | NOT_APPLICABLE | NOT_APPLICABLE | euckr_mbc_case_fold(OnigCaseFoldType flag, const UChar** pp, const UChar* end,
UChar* lower, OnigEncoding enc)
{
return onigenc_mbn_mbc_case_fold(enc, flag,
pp, end, lower);
} | 0 |
gpac | 77510778516803b7f7402d7423c6d6bef50254c3 | NOT_APPLICABLE | NOT_APPLICABLE | void trgr_box_del(GF_Box *s)
{
GF_TrackGroupBox *ptr = (GF_TrackGroupBox *)s;
if (ptr == NULL) return;
gf_list_del(ptr->groups);
gf_free(ptr);
} | 0 |
Chrome | 5fe74f831fddb92afa5ddfe46490bb49f083132b | NOT_APPLICABLE | NOT_APPLICABLE | WebString WebLocalFrameImpl::Prompt(const WebString& message,
const WebString& default_value) {
DCHECK(GetFrame());
ScriptState* script_state = ToScriptStateForMainWorld(GetFrame());
DCHECK(script_state);
return GetFrame()->DomWindow()->prompt(script_state, message, default_value);
}
| 0 |
linux | ca4463bf8438b403596edd0ec961ca0d4fbe0220 | NOT_APPLICABLE | NOT_APPLICABLE | static void set_cursor(struct vc_data *vc)
{
if (!con_is_fg(vc) || console_blanked || vc->vc_mode == KD_GRAPHICS)
return;
if (vc->vc_deccm) {
if (vc_is_sel(vc))
clear_selection();
add_softcursor(vc);
if ((vc->vc_cursor_type & 0x0f) != 1)
vc->vc_sw->con_cursor(vc, CM_DRAW);
} else
hide_cursor(vc);
} | 0 |
httpd | 643f0fcf3b8ab09a68f0ecd2aa37aafeda3e63ef | NOT_APPLICABLE | NOT_APPLICABLE | static const char *req_document_root(request_rec *r)
{
return ap_document_root(r);
}
| 0 |
linux | cfa39381173d5f969daf43582c95ad679189cbc9 | NOT_APPLICABLE | NOT_APPLICABLE | void kvm_sigset_activate(struct kvm_vcpu *vcpu)
{
if (!vcpu->sigset_active)
return;
/*
* This does a lockless modification of ->real_blocked, which is fine
* because, only current can change ->real_blocked and all readers of
* ->real_blocked don't care as long ->real_blocked is always a subset
* of ->blocked.
*/
sigprocmask(SIG_SETMASK, &vcpu->sigset, ¤t->real_blocked);
}
| 0 |
Chrome | f03ea5a5c2ff26e239dfd23e263b15da2d9cee93 | NOT_APPLICABLE | NOT_APPLICABLE | explicit FrameURLLoaderFactory(base::WeakPtr<RenderFrameImpl> frame)
: frame_(std::move(frame)) {}
| 0 |
linux | e6bd18f57aad1a2d1ef40e646d03ed0f2515c9e3 | NOT_APPLICABLE | NOT_APPLICABLE | static ssize_t ib_ucm_send_apr(struct ib_ucm_file *file,
const char __user *inbuf,
int in_len, int out_len)
{
return ib_ucm_send_info(file, inbuf, in_len, (void *)ib_send_cm_apr);
}
| 0 |
openssl | 56f1acf5ef8a432992497a04792ff4b3b2c6f286 | NOT_APPLICABLE | NOT_APPLICABLE | X509 *ssl_get_server_send_cert(const SSL *s)
{
CERT_PKEY *cpk;
cpk = ssl_get_server_send_pkey(s);
if (!cpk)
return NULL;
return cpk->x509;
} | 0 |
linux | 853bc26a7ea39e354b9f8889ae7ad1492ffa28d2 | NOT_APPLICABLE | NOT_APPLICABLE | void o2nm_node_put(struct o2nm_node *node)
{
config_item_put(&node->nd_item);
}
| 0 |
linux-2.6 | 17b24b3c97498935a2ef9777370b1151dfed3f6f | NOT_APPLICABLE | NOT_APPLICABLE | static int svc_listen(struct socket *sock,int backlog)
{
DEFINE_WAIT(wait);
struct sock *sk = sock->sk;
struct atm_vcc *vcc = ATM_SD(sock);
int error;
pr_debug("svc_listen %p\n",vcc);
lock_sock(sk);
/* let server handle listen on unbound sockets */
if (test_bit(ATM_VF_SESSION,&vcc->flags)) {
error = -EINVAL;
goto out;
}
if (test_bit(ATM_VF_LISTEN, &vcc->flags)) {
error = -EADDRINUSE;
goto out;
}
set_bit(ATM_VF_WAITING, &vcc->flags);
prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
sigd_enq(vcc,as_listen,NULL,NULL,&vcc->local);
while (test_bit(ATM_VF_WAITING, &vcc->flags) && sigd) {
schedule();
prepare_to_wait(sk->sk_sleep, &wait, TASK_UNINTERRUPTIBLE);
}
finish_wait(sk->sk_sleep, &wait);
if (!sigd) {
error = -EUNATCH;
goto out;
}
set_bit(ATM_VF_LISTEN,&vcc->flags);
vcc_insert_socket(sk);
sk->sk_max_ack_backlog = backlog > 0 ? backlog : ATM_BACKLOG_DEFAULT;
error = -sk->sk_err;
out:
release_sock(sk);
return error;
} | 0 |
linux | b4487b93545214a9db8cbf32e86411677b0cca21 | NOT_APPLICABLE | NOT_APPLICABLE | static int decode_open_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
{
stateid->type = NFS4_OPEN_STATEID_TYPE;
return decode_stateid(xdr, stateid);
} | 0 |
samba | 6ef0e33fe8afa0ebb81652b9d42b42d20efadf04 | NOT_APPLICABLE | NOT_APPLICABLE | static NTSTATUS copy_internals(TALLOC_CTX *ctx,
connection_struct *conn,
struct smb_request *req,
struct smb_filename *smb_fname_src,
struct smb_filename *smb_fname_dst,
uint32 attrs)
{
files_struct *fsp1,*fsp2;
uint32 fattr;
int info;
SMB_OFF_T ret=-1;
NTSTATUS status = NT_STATUS_OK;
char *parent;
if (!CAN_WRITE(conn)) {
status = NT_STATUS_MEDIA_WRITE_PROTECTED;
goto out;
}
/* Source must already exist. */
if (!VALID_STAT(smb_fname_src->st)) {
status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
goto out;
}
/* Ensure attributes match. */
fattr = dos_mode(conn, smb_fname_src);
if ((fattr & ~attrs) & (aHIDDEN | aSYSTEM)) {
status = NT_STATUS_NO_SUCH_FILE;
goto out;
}
/* Disallow if dst file already exists. */
if (VALID_STAT(smb_fname_dst->st)) {
status = NT_STATUS_OBJECT_NAME_COLLISION;
goto out;
}
/* No links from a directory. */
if (S_ISDIR(smb_fname_src->st.st_ex_mode)) {
status = NT_STATUS_FILE_IS_A_DIRECTORY;
goto out;
}
DEBUG(10,("copy_internals: doing file copy %s to %s\n",
smb_fname_str_dbg(smb_fname_src),
smb_fname_str_dbg(smb_fname_dst)));
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
req, /* req */
0, /* root_dir_fid */
smb_fname_src, /* fname */
FILE_READ_DATA, /* access_mask */
(FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
FILE_SHARE_DELETE),
FILE_OPEN, /* create_disposition*/
0, /* create_options */
FILE_ATTRIBUTE_NORMAL, /* file_attributes */
NO_OPLOCK, /* oplock_request */
0, /* allocation_size */
NULL, /* sd */
NULL, /* ea_list */
&fsp1, /* result */
&info); /* pinfo */
if (!NT_STATUS_IS_OK(status)) {
goto out;
}
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
req, /* req */
0, /* root_dir_fid */
smb_fname_dst, /* fname */
FILE_WRITE_DATA, /* access_mask */
(FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
FILE_SHARE_DELETE),
FILE_CREATE, /* create_disposition*/
0, /* create_options */
fattr, /* file_attributes */
NO_OPLOCK, /* oplock_request */
0, /* allocation_size */
NULL, /* sd */
NULL, /* ea_list */
&fsp2, /* result */
&info); /* pinfo */
if (!NT_STATUS_IS_OK(status)) {
close_file(NULL, fsp1, ERROR_CLOSE);
goto out;
}
if (smb_fname_src->st.st_ex_size) {
ret = vfs_transfer_file(fsp1, fsp2, smb_fname_src->st.st_ex_size);
}
/*
* As we are opening fsp1 read-only we only expect
* an error on close on fsp2 if we are out of space.
* Thus we don't look at the error return from the
* close of fsp1.
*/
close_file(NULL, fsp1, NORMAL_CLOSE);
/* Ensure the modtime is set correctly on the destination file. */
set_close_write_time(fsp2, smb_fname_src->st.st_ex_mtime);
status = close_file(NULL, fsp2, NORMAL_CLOSE);
/* Grrr. We have to do this as open_file_ntcreate adds aARCH when it
creates the file. This isn't the correct thing to do in the copy
case. JRA */
if (!parent_dirname(talloc_tos(), smb_fname_dst->base_name, &parent,
NULL)) {
status = NT_STATUS_NO_MEMORY;
goto out;
}
file_set_dosmode(conn, smb_fname_dst, fattr, parent, false);
TALLOC_FREE(parent);
if (ret < (SMB_OFF_T)smb_fname_src->st.st_ex_size) {
status = NT_STATUS_DISK_FULL;
goto out;
}
out:
if (!NT_STATUS_IS_OK(status)) {
DEBUG(3,("copy_internals: Error %s copy file %s to %s\n",
nt_errstr(status), smb_fname_str_dbg(smb_fname_src),
smb_fname_str_dbg(smb_fname_dst)));
}
return status;
} | 0 |
linux | 427215d85e8d1476da1a86b8d67aceb485eb3631 | NOT_APPLICABLE | NOT_APPLICABLE | static inline bool mnt_is_cursor(struct mount *mnt)
{
return mnt->mnt.mnt_flags & MNT_CURSOR;
} | 0 |
libxkbcommon | c1e5ac16e77a21f87bdf3bc4dea61b037a17dddb | NOT_APPLICABLE | NOT_APPLICABLE | XkbFileCreate(enum xkb_file_type type, char *name, ParseCommon *defs,
enum xkb_map_flags flags)
{
XkbFile *file;
file = calloc(1, sizeof(*file));
if (!file)
return NULL;
XkbEscapeMapName(name);
file->file_type = type;
file->name = name ? name : strdup("(unnamed)");
file->defs = defs;
file->flags = flags;
return file;
}
| 0 |
pdf2json | 80bf71f16c804108fd933e267fe31692aaa509b4 | NOT_APPLICABLE | NOT_APPLICABLE | static int getCharFromString(void *data) {
char *p;
int c;
p = *(char **)data;
if (*p) {
c = *p++;
*(char **)data = p;
} else {
c = EOF;
}
return c;
} | 0 |
xserver | 3f0d3f4d97bce75c1828635c322b6560a45a037f | NOT_APPLICABLE | NOT_APPLICABLE | int __glXDisp_MakeContextCurrent(__GLXclientState *cl, GLbyte *pc)
{
xGLXMakeContextCurrentReq *req = (xGLXMakeContextCurrentReq *) pc;
return DoMakeCurrent( cl, req->drawable, req->readdrawable,
req->context, req->oldContextTag );
}
| 0 |
Android | 472271b153c5dc53c28beac55480a8d8434b2d5c | CVE-2016-3839 | CWE-284 | void bta_hh_co_open(UINT8 dev_handle, UINT8 sub_class, tBTA_HH_ATTR_MASK attr_mask,
UINT8 app_id)
{
UINT32 i;
btif_hh_device_t *p_dev = NULL;
if (dev_handle == BTA_HH_INVALID_HANDLE) {
APPL_TRACE_WARNING("%s: Oops, dev_handle (%d) is invalid...",
__FUNCTION__, dev_handle);
return;
}
for (i = 0; i < BTIF_HH_MAX_HID; i++) {
p_dev = &btif_hh_cb.devices[i];
if (p_dev->dev_status != BTHH_CONN_STATE_UNKNOWN &&
p_dev->dev_handle == dev_handle) {
APPL_TRACE_WARNING("%s: Found an existing device with the same handle "
"dev_status = %d",__FUNCTION__,
p_dev->dev_status);
APPL_TRACE_WARNING("%s: bd_addr = [%02X:%02X:%02X:%02X:%02X:]", __FUNCTION__,
p_dev->bd_addr.address[0], p_dev->bd_addr.address[1], p_dev->bd_addr.address[2],
p_dev->bd_addr.address[3], p_dev->bd_addr.address[4]);
APPL_TRACE_WARNING("%s: attr_mask = 0x%04x, sub_class = 0x%02x, app_id = %d",
__FUNCTION__, p_dev->attr_mask, p_dev->sub_class, p_dev->app_id);
if(p_dev->fd<0) {
p_dev->fd = open(dev_path, O_RDWR | O_CLOEXEC);
if (p_dev->fd < 0){
APPL_TRACE_ERROR("%s: Error: failed to open uhid, err:%s",
__FUNCTION__,strerror(errno));
return;
}else
APPL_TRACE_DEBUG("%s: uhid fd = %d", __FUNCTION__, p_dev->fd);
}
p_dev->hh_keep_polling = 1;
p_dev->hh_poll_thread_id = create_thread(btif_hh_poll_event_thread, p_dev);
break;
}
p_dev = NULL;
}
if (p_dev == NULL) {
for (i = 0; i < BTIF_HH_MAX_HID; i++) {
if (btif_hh_cb.devices[i].dev_status == BTHH_CONN_STATE_UNKNOWN) {
p_dev = &btif_hh_cb.devices[i];
p_dev->dev_handle = dev_handle;
p_dev->attr_mask = attr_mask;
p_dev->sub_class = sub_class;
p_dev->app_id = app_id;
p_dev->local_vup = FALSE;
btif_hh_cb.device_num++;
p_dev->fd = open(dev_path, O_RDWR | O_CLOEXEC);
if (p_dev->fd < 0){
APPL_TRACE_ERROR("%s: Error: failed to open uhid, err:%s",
__FUNCTION__,strerror(errno));
return;
}else{
APPL_TRACE_DEBUG("%s: uhid fd = %d", __FUNCTION__, p_dev->fd);
p_dev->hh_keep_polling = 1;
p_dev->hh_poll_thread_id = create_thread(btif_hh_poll_event_thread, p_dev);
}
break;
}
}
}
if (p_dev == NULL) {
APPL_TRACE_ERROR("%s: Error: too many HID devices are connected", __FUNCTION__);
return;
}
p_dev->dev_status = BTHH_CONN_STATE_CONNECTED;
APPL_TRACE_DEBUG("%s: Return device status %d", __FUNCTION__, p_dev->dev_status);
}
| 1 |
exiv2 | c72d16f4c402a8acc2dfe06fe3d58bf6cf99069e | NOT_APPLICABLE | NOT_APPLICABLE | int Extract::run(const std::string& path)
{
try {
path_ = path;
int rc = 0;
bool bStdout = Params::instance().target_ & Params::ctStdInOut ? true : false;
if (bStdout) {
_setmode(_fileno(stdout), _O_BINARY);
}
if (Params::instance().target_ & Params::ctThumb) {
rc = writeThumbnail();
}
if (!rc && Params::instance().target_ & Params::ctPreview) {
rc = writePreviews();
}
if (!rc && Params::instance().target_ & Params::ctXmpSidecar) {
std::string xmpPath = bStdout ? "-" : newFilePath(path_, ".xmp");
if (dontOverwrite(xmpPath))
return 0;
rc = metacopy(path_, xmpPath, Exiv2::ImageType::xmp, false);
}
if (!rc && Params::instance().target_ & Params::ctIccProfile) {
std::string iccPath = bStdout ? "-" : newFilePath(path_, ".icc");
rc = writeIccProfile(iccPath);
}
if (!rc && !(Params::instance().target_ & Params::ctXmpSidecar) &&
!(Params::instance().target_ & Params::ctThumb) && !(Params::instance().target_ & Params::ctPreview) &&
!(Params::instance().target_ & Params::ctIccProfile)) {
std::string exvPath = bStdout ? "-" : newFilePath(path_, ".exv");
if (dontOverwrite(exvPath))
return 0;
rc = metacopy(path_, exvPath, Exiv2::ImageType::exv, false);
}
return rc;
} catch (const Exiv2::AnyError& e) {
std::cerr << "Exiv2 exception in extract action for file " << path << ":\n" << e << "\n";
return 1;
}
} | 0 |
Chrome | f85a87ec670ad0fce9d98d90c9a705b72a288154 | NOT_APPLICABLE | NOT_APPLICABLE | static void reflectedStringAttrAttributeGetterCallback(v8::Local<v8::String>, const v8::PropertyCallbackInfo<v8::Value>& info)
{
TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMGetter");
TestObjectV8Internal::reflectedStringAttrAttributeGetter(info);
TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
}
| 0 |
ovs | 0befd1f3745055c32940f5faf9559be6a14395e6 | NOT_APPLICABLE | NOT_APPLICABLE | oftable_set_name(struct oftable *table, const char *name)
{
if (name && name[0]) {
int len = strnlen(name, OFP_MAX_TABLE_NAME_LEN);
if (!table->name || strncmp(name, table->name, len)) {
free(table->name);
table->name = xmemdup0(name, len);
}
} else {
free(table->name);
table->name = NULL;
}
}
| 0 |
Chrome | a7d715ae5b654d1f98669fd979a00282a7229044 | NOT_APPLICABLE | NOT_APPLICABLE | void WebContentsImpl::DispatchBeforeUnload(bool auto_cancel) {
auto before_unload_type =
auto_cancel ? RenderFrameHostImpl::BeforeUnloadType::DISCARD
: RenderFrameHostImpl::BeforeUnloadType::TAB_CLOSE;
GetMainFrame()->DispatchBeforeUnload(before_unload_type, false);
}
| 0 |
envoy | 2c60632d41555ec8b3d9ef5246242be637a2db0f | NOT_APPLICABLE | NOT_APPLICABLE | static std::vector<Http::HeaderMatcherSharedPtr> buildHeaderMatcherVector(
const Protobuf::RepeatedPtrField<envoy::config::route::v3::HeaderMatcher>& header_matchers) {
std::vector<Http::HeaderMatcherSharedPtr> ret;
for (const auto& header_matcher : header_matchers) {
ret.emplace_back(std::make_shared<HeaderUtility::HeaderData>(header_matcher));
}
return ret;
} | 0 |
ImageMagick | 01843366d6a7b96e22ad7bb67f3df7d9fd4d5d74 | NOT_APPLICABLE | NOT_APPLICABLE | MagickExport ImageInfo *CloneImageInfo(const ImageInfo *image_info)
{
ImageInfo
*clone_info;
clone_info=AcquireImageInfo();
if (image_info == (ImageInfo *) NULL)
return(clone_info);
clone_info->compression=image_info->compression;
clone_info->temporary=image_info->temporary;
clone_info->adjoin=image_info->adjoin;
clone_info->antialias=image_info->antialias;
clone_info->scene=image_info->scene;
clone_info->number_scenes=image_info->number_scenes;
clone_info->depth=image_info->depth;
(void) CloneString(&clone_info->size,image_info->size);
(void) CloneString(&clone_info->extract,image_info->extract);
(void) CloneString(&clone_info->scenes,image_info->scenes);
(void) CloneString(&clone_info->page,image_info->page);
clone_info->interlace=image_info->interlace;
clone_info->endian=image_info->endian;
clone_info->units=image_info->units;
clone_info->quality=image_info->quality;
(void) CloneString(&clone_info->sampling_factor,image_info->sampling_factor);
(void) CloneString(&clone_info->server_name,image_info->server_name);
(void) CloneString(&clone_info->font,image_info->font);
(void) CloneString(&clone_info->texture,image_info->texture);
(void) CloneString(&clone_info->density,image_info->density);
clone_info->pointsize=image_info->pointsize;
clone_info->fuzz=image_info->fuzz;
clone_info->pen=image_info->pen;
clone_info->background_color=image_info->background_color;
clone_info->border_color=image_info->border_color;
clone_info->matte_color=image_info->matte_color;
clone_info->transparent_color=image_info->transparent_color;
clone_info->dither=image_info->dither;
clone_info->monochrome=image_info->monochrome;
clone_info->colors=image_info->colors;
clone_info->colorspace=image_info->colorspace;
clone_info->type=image_info->type;
clone_info->orientation=image_info->orientation;
clone_info->preview_type=image_info->preview_type;
clone_info->group=image_info->group;
clone_info->ping=image_info->ping;
clone_info->verbose=image_info->verbose;
(void) CloneString(&clone_info->view,image_info->view);
(void) CloneString(&clone_info->authenticate,image_info->authenticate);
(void) CloneImageOptions(clone_info,image_info);
clone_info->progress_monitor=image_info->progress_monitor;
clone_info->client_data=image_info->client_data;
clone_info->cache=image_info->cache;
if (image_info->cache != (void *) NULL)
clone_info->cache=ReferencePixelCache(image_info->cache);
if (image_info->profile != (void *) NULL)
clone_info->profile=(void *) CloneStringInfo((StringInfo *)
image_info->profile);
SetImageInfoFile(clone_info,image_info->file);
SetImageInfoBlob(clone_info,image_info->blob,image_info->length);
clone_info->stream=image_info->stream;
clone_info->virtual_pixel_method=image_info->virtual_pixel_method;
(void) CopyMagickString(clone_info->magick,image_info->magick,MaxTextExtent);
(void) CopyMagickString(clone_info->unique,image_info->unique,MaxTextExtent);
(void) CopyMagickString(clone_info->zero,image_info->zero,MaxTextExtent);
(void) CopyMagickString(clone_info->filename,image_info->filename,
MaxTextExtent);
clone_info->subimage=image_info->scene; /* deprecated */
clone_info->subrange=image_info->number_scenes; /* deprecated */
clone_info->channel=image_info->channel;
clone_info->debug=IsEventLogging();
clone_info->signature=image_info->signature;
return(clone_info);
}
| 0 |
ghostpdl | 9f39ed4a92578a020ae10459643e1fe72573d134 | NOT_APPLICABLE | NOT_APPLICABLE | lips_mode3format_encode(byte * inBuff, byte * outBuff, int Length)
{
int size = 0;
while (Length) {
int count;
if (1 < (count = GetNumSameData(inBuff,
Length > 257 ? 257 : Length))) {
Length -= count;
size += 3;
*outBuff++ = *inBuff;
*outBuff++ = *inBuff;
*outBuff++ = count - 2;
inBuff += count;
} else {
count = GetNumWrongData(inBuff, Length);
Length -= count;
size += count;
while (count--) {
*outBuff++ = *inBuff++;
}
}
}
return (size);
} | 0 |
vim | 083692d598139228e101b8c521aaef7bcf256e9a | NOT_APPLICABLE | NOT_APPLICABLE | msg_clr_eos_force(void)
{
if (msg_use_printf())
{
if (full_screen) // only when termcap codes are valid
{
if (*T_CD)
out_str(T_CD); // clear to end of display
else if (*T_CE)
out_str(T_CE); // clear to end of line
}
}
else
{
#ifdef FEAT_RIGHTLEFT
if (cmdmsg_rl)
{
screen_fill(msg_row, msg_row + 1, 0, msg_col + 1, ' ', ' ', 0);
screen_fill(msg_row + 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
}
else
#endif
{
screen_fill(msg_row, msg_row + 1, msg_col, (int)Columns,
' ', ' ', 0);
screen_fill(msg_row + 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
}
}
} | 0 |
linux | 1137b5e2529a8f5ca8ee709288ecba3e68044df2 | NOT_APPLICABLE | NOT_APPLICABLE | static int xfrm_add_sa_expire(struct sk_buff *skb, struct nlmsghdr *nlh,
struct nlattr **attrs)
{
struct net *net = sock_net(skb->sk);
struct xfrm_state *x;
int err;
struct xfrm_user_expire *ue = nlmsg_data(nlh);
struct xfrm_usersa_info *p = &ue->state;
struct xfrm_mark m;
u32 mark = xfrm_mark_get(attrs, &m);
x = xfrm_state_lookup(net, mark, &p->id.daddr, p->id.spi, p->id.proto, p->family);
err = -ENOENT;
if (x == NULL)
return err;
spin_lock_bh(&x->lock);
err = -EINVAL;
if (x->km.state != XFRM_STATE_VALID)
goto out;
km_state_expired(x, ue->hard, nlh->nlmsg_pid);
if (ue->hard) {
__xfrm_state_delete(x);
xfrm_audit_state_delete(x, 1, true);
}
err = 0;
out:
spin_unlock_bh(&x->lock);
xfrm_state_put(x);
return err;
}
| 0 |
PackageKit | 7e8a7905ea9abbd1f384f05f36a4458682cd4697 | NOT_APPLICABLE | NOT_APPLICABLE | _g_variant_new_maybe_string (const gchar *value)
{
if (value == NULL)
return g_variant_new_string ("");
return g_variant_new_string (value);
} | 0 |
openssl | 0042fb5fd1c9d257d713b15a1f45da05cf5c1c87 | NOT_APPLICABLE | NOT_APPLICABLE | const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
int (*cmp)(const void *, const void *))
{
return OBJ_bsearch_ex_(key, base, num, size, cmp, 0);
}
| 0 |
lxc | 592fd47a6245508b79fe6ac819fe6d3b2c1289be | NOT_APPLICABLE | NOT_APPLICABLE | static int setup_lodev(const char *rootfs, int fd, struct loop_info64 *loinfo)
{
int rfd;
int ret = -1;
rfd = open(rootfs, O_RDWR);
if (rfd < 0) {
SYSERROR("failed to open '%s'", rootfs);
return -1;
}
memset(loinfo, 0, sizeof(*loinfo));
loinfo->lo_flags = LO_FLAGS_AUTOCLEAR;
if (ioctl(fd, LOOP_SET_FD, rfd)) {
SYSERROR("failed to LOOP_SET_FD");
goto out;
}
if (ioctl(fd, LOOP_SET_STATUS64, loinfo)) {
SYSERROR("failed to LOOP_SET_STATUS64");
goto out;
}
ret = 0;
out:
close(rfd);
return ret;
}
| 0 |
linux | e50293ef9775c5f1cf3fcc093037dd6a8c5684ea | NOT_APPLICABLE | NOT_APPLICABLE | static inline char *portspeed(struct usb_hub *hub, int portstatus)
{
if (hub_is_superspeed(hub->hdev))
return "5.0 Gb/s";
if (portstatus & USB_PORT_STAT_HIGH_SPEED)
return "480 Mb/s";
else if (portstatus & USB_PORT_STAT_LOW_SPEED)
return "1.5 Mb/s";
else
return "12 Mb/s";
}
| 0 |
ImageMagick | 9fd10cf630832b36a588c1545d8736539b2f1fb5 | NOT_APPLICABLE | NOT_APPLICABLE | static MagickBooleanType EncodeImage(const ImageInfo *image_info,Image *image,
const size_t data_size,ExceptionInfo *exception)
{
#define MaxCode(number_bits) ((one << (number_bits))-1)
#define MaxHashTable 5003
#define MaxGIFBits 12UL
#define MaxGIFTable (1UL << MaxGIFBits)
#define GIFOutputCode(code) \
{ \
/* \
Emit a code. \
*/ \
if (bits > 0) \
datum|=(code) << bits; \
else \
datum=code; \
bits+=number_bits; \
while (bits >= 8) \
{ \
/* \
Add a character to current packet. \
*/ \
packet[length++]=(unsigned char) (datum & 0xff); \
if (length >= 254) \
{ \
(void) WriteBlobByte(image,(unsigned char) length); \
(void) WriteBlob(image,length,packet); \
length=0; \
} \
datum>>=8; \
bits-=8; \
} \
if (free_code > max_code) \
{ \
number_bits++; \
if (number_bits == MaxGIFBits) \
max_code=MaxGIFTable; \
else \
max_code=MaxCode(number_bits); \
} \
}
Quantum
index;
short
*hash_code,
*hash_prefix,
waiting_code;
size_t
bits,
clear_code,
datum,
end_of_information_code,
free_code,
length,
max_code,
next_pixel,
number_bits,
one,
pass;
ssize_t
displacement,
offset,
k,
y;
unsigned char
*packet,
*hash_suffix;
/*
Allocate encoder tables.
*/
assert(image != (Image *) NULL);
one=1;
packet=(unsigned char *) AcquireQuantumMemory(256,sizeof(*packet));
hash_code=(short *) AcquireQuantumMemory(MaxHashTable,sizeof(*hash_code));
hash_prefix=(short *) AcquireQuantumMemory(MaxHashTable,sizeof(*hash_prefix));
hash_suffix=(unsigned char *) AcquireQuantumMemory(MaxHashTable,
sizeof(*hash_suffix));
if ((packet == (unsigned char *) NULL) || (hash_code == (short *) NULL) ||
(hash_prefix == (short *) NULL) ||
(hash_suffix == (unsigned char *) NULL))
{
if (packet != (unsigned char *) NULL)
packet=(unsigned char *) RelinquishMagickMemory(packet);
if (hash_code != (short *) NULL)
hash_code=(short *) RelinquishMagickMemory(hash_code);
if (hash_prefix != (short *) NULL)
hash_prefix=(short *) RelinquishMagickMemory(hash_prefix);
if (hash_suffix != (unsigned char *) NULL)
hash_suffix=(unsigned char *) RelinquishMagickMemory(hash_suffix);
return(MagickFalse);
}
/*
Initialize GIF encoder.
*/
(void) ResetMagickMemory(hash_code,0,MaxHashTable*sizeof(*hash_code));
(void) ResetMagickMemory(hash_prefix,0,MaxHashTable*sizeof(*hash_prefix));
(void) ResetMagickMemory(hash_suffix,0,MaxHashTable*sizeof(*hash_suffix));
number_bits=data_size;
max_code=MaxCode(number_bits);
clear_code=((short) one << (data_size-1));
end_of_information_code=clear_code+1;
free_code=clear_code+2;
length=0;
datum=0;
bits=0;
GIFOutputCode(clear_code);
/*
Encode pixels.
*/
offset=0;
pass=0;
waiting_code=0;
for (y=0; y < (ssize_t) image->rows; y++)
{
register const Quantum
*magick_restrict p;
register ssize_t
x;
p=GetVirtualPixels(image,0,offset,image->columns,1,exception);
if (p == (const Quantum *) NULL)
break;
if (y == 0)
{
waiting_code=(short) GetPixelIndex(image,p);
p+=GetPixelChannels(image);
}
for (x=(ssize_t) (y == 0 ? 1 : 0); x < (ssize_t) image->columns; x++)
{
/*
Probe hash table.
*/
index=(Quantum) ((size_t) GetPixelIndex(image,p) & 0xff);
p+=GetPixelChannels(image);
k=(ssize_t) (((size_t) index << (MaxGIFBits-8))+waiting_code);
if (k >= MaxHashTable)
k-=MaxHashTable;
next_pixel=MagickFalse;
displacement=1;
if (hash_code[k] > 0)
{
if ((hash_prefix[k] == waiting_code) &&
(hash_suffix[k] == (unsigned char) index))
{
waiting_code=hash_code[k];
continue;
}
if (k != 0)
displacement=MaxHashTable-k;
for ( ; ; )
{
k-=displacement;
if (k < 0)
k+=MaxHashTable;
if (hash_code[k] == 0)
break;
if ((hash_prefix[k] == waiting_code) &&
(hash_suffix[k] == (unsigned char) index))
{
waiting_code=hash_code[k];
next_pixel=MagickTrue;
break;
}
}
if (next_pixel != MagickFalse)
continue;
}
GIFOutputCode((size_t) waiting_code);
if (free_code < MaxGIFTable)
{
hash_code[k]=(short) free_code++;
hash_prefix[k]=waiting_code;
hash_suffix[k]=(unsigned char) index;
}
else
{
/*
Fill the hash table with empty entries.
*/
for (k=0; k < MaxHashTable; k++)
hash_code[k]=0;
/*
Reset compressor and issue a clear code.
*/
free_code=clear_code+2;
GIFOutputCode(clear_code);
number_bits=data_size;
max_code=MaxCode(number_bits);
}
waiting_code=(short) index;
}
if (image_info->interlace == NoInterlace)
offset++;
else
switch (pass)
{
case 0:
default:
{
offset+=8;
if (offset >= (ssize_t) image->rows)
{
pass++;
offset=4;
}
break;
}
case 1:
{
offset+=8;
if (offset >= (ssize_t) image->rows)
{
pass++;
offset=2;
}
break;
}
case 2:
{
offset+=4;
if (offset >= (ssize_t) image->rows)
{
pass++;
offset=1;
}
break;
}
case 3:
{
offset+=2;
break;
}
}
}
/*
Flush out the buffered code.
*/
GIFOutputCode((size_t) waiting_code);
GIFOutputCode(end_of_information_code);
if (bits > 0)
{
/*
Add a character to current packet.
*/
packet[length++]=(unsigned char) (datum & 0xff);
if (length >= 254)
{
(void) WriteBlobByte(image,(unsigned char) length);
(void) WriteBlob(image,length,packet);
length=0;
}
}
/*
Flush accumulated data.
*/
if (length > 0)
{
(void) WriteBlobByte(image,(unsigned char) length);
(void) WriteBlob(image,length,packet);
}
/*
Free encoder memory.
*/
hash_suffix=(unsigned char *) RelinquishMagickMemory(hash_suffix);
hash_prefix=(short *) RelinquishMagickMemory(hash_prefix);
hash_code=(short *) RelinquishMagickMemory(hash_code);
packet=(unsigned char *) RelinquishMagickMemory(packet);
return(MagickTrue);
}
| 0 |
Chrome | f85a87ec670ad0fce9d98d90c9a705b72a288154 | NOT_APPLICABLE | NOT_APPLICABLE | static void deprecatedLongAttributeAttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)
{
ExceptionState exceptionState(ExceptionState::SetterContext, "deprecatedLongAttribute", "TestObjectPython", info.Holder(), info.GetIsolate());
TestObjectPython* imp = V8TestObjectPython::toNative(info.Holder());
V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), exceptionState);
imp->setDeprecatedLongAttribute(cppValue);
}
| 0 |
LuaJIT | e296f56b825c688c3530a981dc6b495d972f3d01 | NOT_APPLICABLE | NOT_APPLICABLE | static void penalty_pc(jit_State *J, GCproto *pt, BCIns *pc, TraceError e)
{
uint32_t i, val = PENALTY_MIN;
for (i = 0; i < PENALTY_SLOTS; i++)
if (mref(J->penalty[i].pc, const BCIns) == pc) { /* Cache slot found? */
/* First try to bump its hotcount several times. */
val = ((uint32_t)J->penalty[i].val << 1) +
LJ_PRNG_BITS(J, PENALTY_RNDBITS);
if (val > PENALTY_MAX) {
blacklist_pc(pt, pc); /* Blacklist it, if that didn't help. */
return;
}
goto setpenalty;
}
/* Assign a new penalty cache slot. */
i = J->penaltyslot;
J->penaltyslot = (J->penaltyslot + 1) & (PENALTY_SLOTS-1);
setmref(J->penalty[i].pc, pc);
setpenalty:
J->penalty[i].val = (uint16_t)val;
J->penalty[i].reason = e;
hotcount_set(J2GG(J), pc+1, val);
} | 0 |
qemu | e2c57529c9306e4c9aac75d9879f6e7699584a22 | NOT_APPLICABLE | NOT_APPLICABLE | static inline uint16_t nvme_zrm_open(NvmeCtrl *n, NvmeNamespace *ns,
NvmeZone *zone)
{
return nvme_zrm_open_flags(n, ns, zone, 0);
} | 0 |
gpac | a51f951b878c2b73c1d8e2f1518c7cdc5fb82c3f | NOT_APPLICABLE | NOT_APPLICABLE | u32 parse_dash_profile(char *arg_val, u32 opt)
{
if (!stricmp(arg_val, "live") || !stricmp(arg_val, "simple")) dash_profile = GF_DASH_PROFILE_LIVE;
else if (!stricmp(arg_val, "onDemand")) dash_profile = GF_DASH_PROFILE_ONDEMAND;
else if (!stricmp(arg_val, "hbbtv1.5:live") || !stricmp(arg_val, "hbbtv1.5.live"))
dash_profile = GF_DASH_PROFILE_HBBTV_1_5_ISOBMF_LIVE;
else if (!stricmp(arg_val, "dashavc264:live") || !stricmp(arg_val, "dashavc264.live"))
dash_profile = GF_DASH_PROFILE_AVC264_LIVE;
else if (!stricmp(arg_val, "dashavc264:onDemand") || !stricmp(arg_val, "dashavc264.onDemand"))
dash_profile = GF_DASH_PROFILE_AVC264_ONDEMAND;
else if (!stricmp(arg_val, "dashif.ll")) dash_profile = GF_DASH_PROFILE_DASHIF_LL;
else if (!stricmp(arg_val, "main")) dash_profile = GF_DASH_PROFILE_MAIN;
else if (!stricmp(arg_val, "full")) dash_profile = GF_DASH_PROFILE_FULL;
else {
M4_LOG(GF_LOG_ERROR, ("Unrecognized DASH profile \"%s\" - please check usage\n", arg_val));
return 2;
}
return 0;
} | 0 |
Chrome | a6f7726de20450074a01493e4e85409ce3f2595a | NOT_APPLICABLE | NOT_APPLICABLE | void Document::unregisterForMediaVolumeCallbacks(Element* e)
{
m_mediaVolumeCallbackElements.remove(e);
}
| 0 |
linux | 0ea1ec713f04bdfac343c9702b21cd3a7c711826 | NOT_APPLICABLE | NOT_APPLICABLE | static void __dma_remap(struct page *page, size_t size, pgprot_t prot)
{
unsigned long start = (unsigned long) page_address(page);
unsigned end = start + size;
apply_to_page_range(&init_mm, start, size, __dma_update_pte, &prot);
flush_tlb_kernel_range(start, end);
}
| 0 |
qemu | b3af7fdf9cc537f8f0dd3e2423d83f5c99a457e8 | NOT_APPLICABLE | NOT_APPLICABLE | static int scsi_disk_emulate_vpd_page(SCSIRequest *req, uint8_t *outbuf)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, req->dev);
uint8_t page_code = req->cmd.buf[2];
int start, buflen = 0;
outbuf[buflen++] = s->qdev.type & 0x1f;
outbuf[buflen++] = page_code;
outbuf[buflen++] = 0x00;
outbuf[buflen++] = 0x00;
start = buflen;
switch (page_code) {
case 0x00: /* Supported page codes, mandatory */
{
trace_scsi_disk_emulate_vpd_page_00(req->cmd.xfer);
outbuf[buflen++] = 0x00; /* list of supported pages (this page) */
if (s->serial) {
outbuf[buflen++] = 0x80; /* unit serial number */
}
outbuf[buflen++] = 0x83; /* device identification */
if (s->qdev.type == TYPE_DISK) {
outbuf[buflen++] = 0xb0; /* block limits */
outbuf[buflen++] = 0xb1; /* block device characteristics */
outbuf[buflen++] = 0xb2; /* thin provisioning */
}
break;
}
case 0x80: /* Device serial number, optional */
{
int l;
if (!s->serial) {
trace_scsi_disk_emulate_vpd_page_80_not_supported();
return -1;
}
l = strlen(s->serial);
if (l > 36) {
l = 36;
}
trace_scsi_disk_emulate_vpd_page_80(req->cmd.xfer);
memcpy(outbuf + buflen, s->serial, l);
buflen += l;
break;
}
case 0x83: /* Device identification page, mandatory */
{
int id_len = s->device_id ? MIN(strlen(s->device_id), 255 - 8) : 0;
trace_scsi_disk_emulate_vpd_page_83(req->cmd.xfer);
if (id_len) {
outbuf[buflen++] = 0x2; /* ASCII */
outbuf[buflen++] = 0; /* not officially assigned */
outbuf[buflen++] = 0; /* reserved */
outbuf[buflen++] = id_len; /* length of data following */
memcpy(outbuf + buflen, s->device_id, id_len);
buflen += id_len;
}
if (s->qdev.wwn) {
outbuf[buflen++] = 0x1; /* Binary */
outbuf[buflen++] = 0x3; /* NAA */
outbuf[buflen++] = 0; /* reserved */
outbuf[buflen++] = 8;
stq_be_p(&outbuf[buflen], s->qdev.wwn);
buflen += 8;
}
if (s->qdev.port_wwn) {
outbuf[buflen++] = 0x61; /* SAS / Binary */
outbuf[buflen++] = 0x93; /* PIV / Target port / NAA */
outbuf[buflen++] = 0; /* reserved */
outbuf[buflen++] = 8;
stq_be_p(&outbuf[buflen], s->qdev.port_wwn);
buflen += 8;
}
if (s->port_index) {
outbuf[buflen++] = 0x61; /* SAS / Binary */
/* PIV/Target port/relative target port */
outbuf[buflen++] = 0x94;
outbuf[buflen++] = 0; /* reserved */
outbuf[buflen++] = 4;
stw_be_p(&outbuf[buflen + 2], s->port_index);
buflen += 4;
}
break;
}
case 0xb0: /* block limits */
{
SCSIBlockLimits bl = {};
if (s->qdev.type == TYPE_ROM) {
trace_scsi_disk_emulate_vpd_page_b0_not_supported();
return -1;
}
bl.wsnz = 1;
bl.unmap_sectors =
s->qdev.conf.discard_granularity / s->qdev.blocksize;
bl.min_io_size =
s->qdev.conf.min_io_size / s->qdev.blocksize;
bl.opt_io_size =
s->qdev.conf.opt_io_size / s->qdev.blocksize;
bl.max_unmap_sectors =
s->max_unmap_size / s->qdev.blocksize;
bl.max_io_sectors =
s->max_io_size / s->qdev.blocksize;
/* 255 descriptors fit in 4 KiB with an 8-byte header */
bl.max_unmap_descr = 255;
if (s->qdev.type == TYPE_DISK) {
int max_transfer_blk = blk_get_max_transfer(s->qdev.conf.blk);
int max_io_sectors_blk =
max_transfer_blk / s->qdev.blocksize;
bl.max_io_sectors =
MIN_NON_ZERO(max_io_sectors_blk, bl.max_io_sectors);
}
buflen += scsi_emulate_block_limits(outbuf + buflen, &bl);
break;
}
case 0xb1: /* block device characteristics */
{
buflen = 0x40;
outbuf[4] = (s->rotation_rate >> 8) & 0xff;
outbuf[5] = s->rotation_rate & 0xff;
outbuf[6] = 0; /* PRODUCT TYPE */
outbuf[7] = 0; /* WABEREQ | WACEREQ | NOMINAL FORM FACTOR */
outbuf[8] = 0; /* VBULS */
break;
}
case 0xb2: /* thin provisioning */
{
buflen = 8;
outbuf[4] = 0;
outbuf[5] = 0xe0; /* unmap & write_same 10/16 all supported */
outbuf[6] = s->qdev.conf.discard_granularity ? 2 : 1;
outbuf[7] = 0;
break;
}
default:
return -1;
}
/* done with EVPD */
assert(buflen - start <= 255);
outbuf[start - 1] = buflen - start;
return buflen;
} | 0 |
ntopng | 01f47e04fd7c8d54399c9e465f823f0017069f8f | NOT_APPLICABLE | NOT_APPLICABLE | static int ntop_change_allowed_ifname(lua_State* vm) {
char *username, *allowed_ifname;
ntop->getTrace()->traceEvent(TRACE_DEBUG, "%s() called", __FUNCTION__);
if(!Utils::isUserAdministrator(vm)) return(CONST_LUA_ERROR);
if(ntop_lua_check(vm, __FUNCTION__, 1, LUA_TSTRING)) return(CONST_LUA_PARAM_ERROR);
if((username = (char*)lua_tostring(vm, 1)) == NULL) return(CONST_LUA_PARAM_ERROR);
if(ntop_lua_check(vm, __FUNCTION__, 2, LUA_TSTRING)) return(CONST_LUA_PARAM_ERROR);
if((allowed_ifname = (char*)lua_tostring(vm, 2)) == NULL) return(CONST_LUA_PARAM_ERROR);
return ntop->changeAllowedIfname(username, allowed_ifname);
} | 0 |
libsndfile | 708e996c87c5fae77b104ccfeb8f6db784c32074 | NOT_APPLICABLE | NOT_APPLICABLE | sf_strerror (SNDFILE *sndfile)
{ SF_PRIVATE *psf = NULL ;
int errnum ;
if (sndfile == NULL)
{ errnum = sf_errno ;
if (errnum == SFE_SYSTEM && sf_syserr [0])
return sf_syserr ;
}
else
{ psf = (SF_PRIVATE *) sndfile ;
if (psf->Magick != SNDFILE_MAGICK)
return "sf_strerror : Bad magic number." ;
errnum = psf->error ;
if (errnum == SFE_SYSTEM && psf->syserr [0])
return psf->syserr ;
} ;
return sf_error_number (errnum) ;
} /* sf_strerror */
| 0 |
CImg | ac8003393569aba51048c9d67e1491559877b1d1 | NOT_APPLICABLE | NOT_APPLICABLE |
static double mp_median(_cimg_math_parser& mp) {
const unsigned int i_end = (unsigned int)mp.opcode[2];
switch (i_end - 3) {
case 1 : return _mp_arg(3);
case 2 : return cimg::median(_mp_arg(3),_mp_arg(4));
case 3 : return cimg::median(_mp_arg(3),_mp_arg(4),_mp_arg(5));
case 5 : return cimg::median(_mp_arg(3),_mp_arg(4),_mp_arg(5),_mp_arg(6),_mp_arg(7));
case 7 : return cimg::median(_mp_arg(3),_mp_arg(4),_mp_arg(5),_mp_arg(6),_mp_arg(7),_mp_arg(8),_mp_arg(9));
case 9 : return cimg::median(_mp_arg(3),_mp_arg(4),_mp_arg(5),_mp_arg(6),_mp_arg(7),_mp_arg(8),_mp_arg(9),
_mp_arg(10),_mp_arg(11));
case 13 : return cimg::median(_mp_arg(3),_mp_arg(4),_mp_arg(5),_mp_arg(6),_mp_arg(7),_mp_arg(8),_mp_arg(9),
_mp_arg(10),_mp_arg(11),_mp_arg(12),_mp_arg(13),_mp_arg(14),_mp_arg(15));
}
CImg<doubleT> vals(i_end - 3);
double *p = vals.data();
for (unsigned int i = 3; i<i_end; ++i) *(p++) = _mp_arg(i);
return vals.median(); | 0 |
libgit2 | 2fdef641fd0dd2828bd948234ae86de75221a11a | NOT_APPLICABLE | NOT_APPLICABLE | static int network_packetsize(size_t received, void *payload)
{
struct network_packetsize_payload *npp = (struct network_packetsize_payload*)payload;
/* Accumulate bytes */
npp->stats->received_bytes += received;
/* Fire notification if the threshold is reached */
if ((npp->stats->received_bytes - npp->last_fired_bytes) > NETWORK_XFER_THRESHOLD) {
npp->last_fired_bytes = npp->stats->received_bytes;
if (npp->callback(npp->stats, npp->payload))
return GIT_EUSER;
}
return 0;
}
| 0 |
linux | 9c895160d25a76c21b65bad141b08e8d4f99afef | NOT_APPLICABLE | NOT_APPLICABLE | static int get_msr_mce(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
{
u64 data;
u64 mcg_cap = vcpu->arch.mcg_cap;
unsigned bank_num = mcg_cap & 0xff;
switch (msr) {
case MSR_IA32_P5_MC_ADDR:
case MSR_IA32_P5_MC_TYPE:
data = 0;
break;
case MSR_IA32_MCG_CAP:
data = vcpu->arch.mcg_cap;
break;
case MSR_IA32_MCG_CTL:
if (!(mcg_cap & MCG_CTL_P))
return 1;
data = vcpu->arch.mcg_ctl;
break;
case MSR_IA32_MCG_STATUS:
data = vcpu->arch.mcg_status;
break;
default:
if (msr >= MSR_IA32_MC0_CTL &&
msr < MSR_IA32_MC0_CTL + 4 * bank_num) {
u32 offset = msr - MSR_IA32_MC0_CTL;
data = vcpu->arch.mce_banks[offset];
break;
}
return 1;
}
*pdata = data;
return 0;
}
| 0 |
libtasn1 | 53958290ab731c8486531a3bdef54a933533579d | NOT_APPLICABLE | NOT_APPLICABLE | asn1_read_value_type (asn1_node root, const char *name, void *ivalue,
int *len, unsigned int *etype)
{
asn1_node node, p, p2;
int len2, len3, result;
int value_size = *len;
unsigned char *value = ivalue;
unsigned type;
node = asn1_find_node (root, name);
if (node == NULL)
return ASN1_ELEMENT_NOT_FOUND;
type = type_field (node->type);
if ((type != ASN1_ETYPE_NULL) &&
(type != ASN1_ETYPE_CHOICE) &&
!(node->type & CONST_DEFAULT) && !(node->type & CONST_ASSIGN) &&
(node->value == NULL))
return ASN1_VALUE_NOT_FOUND;
if (etype)
*etype = type;
switch (type)
{
case ASN1_ETYPE_NULL:
PUT_STR_VALUE (value, value_size, "NULL");
break;
case ASN1_ETYPE_BOOLEAN:
if ((node->type & CONST_DEFAULT) && (node->value == NULL))
{
p = node->down;
while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
p = p->right;
if (p->type & CONST_TRUE)
{
PUT_STR_VALUE (value, value_size, "TRUE");
}
else
{
PUT_STR_VALUE (value, value_size, "FALSE");
}
}
else if (node->value[0] == 'T')
{
PUT_STR_VALUE (value, value_size, "TRUE");
}
else
{
PUT_STR_VALUE (value, value_size, "FALSE");
}
break;
case ASN1_ETYPE_INTEGER:
case ASN1_ETYPE_ENUMERATED:
if ((node->type & CONST_DEFAULT) && (node->value == NULL))
{
p = node->down;
while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
p = p->right;
if ((isdigit (p->value[0])) || (p->value[0] == '-')
|| (p->value[0] == '+'))
{
result = _asn1_convert_integer
(p->value, value, value_size, len);
if (result != ASN1_SUCCESS)
return result;
}
else
{ /* is an identifier like v1 */
p2 = node->down;
while (p2)
{
if (type_field (p2->type) == ASN1_ETYPE_CONSTANT)
{
if (!_asn1_strcmp (p2->name, p->value))
{
result = _asn1_convert_integer
(p2->value, value, value_size,
len);
if (result != ASN1_SUCCESS)
return result;
break;
}
}
p2 = p2->right;
}
}
}
else
{
len2 = -1;
result = asn1_get_octet_der
(node->value, node->value_len, &len2, value, value_size,
len);
if (result != ASN1_SUCCESS)
return result;
}
break;
case ASN1_ETYPE_OBJECT_ID:
if (node->type & CONST_ASSIGN)
{
*len = 0;
if (value)
value[0] = 0;
p = node->down;
while (p)
{
if (type_field (p->type) == ASN1_ETYPE_CONSTANT)
{
ADD_STR_VALUE (value, value_size, p->value);
if (p->right)
{
ADD_STR_VALUE (value, value_size, ".");
}
}
p = p->right;
}
(*len)++;
}
else if ((node->type & CONST_DEFAULT) && (node->value == NULL))
{
p = node->down;
while (type_field (p->type) != ASN1_ETYPE_DEFAULT)
p = p->right;
PUT_STR_VALUE (value, value_size, p->value);
}
else
{
PUT_STR_VALUE (value, value_size, node->value);
}
break;
case ASN1_ETYPE_GENERALIZED_TIME:
case ASN1_ETYPE_UTC_TIME:
PUT_AS_STR_VALUE (value, value_size, node->value, node->value_len);
break;
case ASN1_ETYPE_OCTET_STRING:
case ASN1_ETYPE_GENERALSTRING:
case ASN1_ETYPE_NUMERIC_STRING:
case ASN1_ETYPE_IA5_STRING:
case ASN1_ETYPE_TELETEX_STRING:
case ASN1_ETYPE_PRINTABLE_STRING:
case ASN1_ETYPE_UNIVERSAL_STRING:
case ASN1_ETYPE_BMP_STRING:
case ASN1_ETYPE_UTF8_STRING:
case ASN1_ETYPE_VISIBLE_STRING:
len2 = -1;
result = asn1_get_octet_der
(node->value, node->value_len, &len2, value, value_size,
len);
if (result != ASN1_SUCCESS)
return result;
break;
case ASN1_ETYPE_BIT_STRING:
len2 = -1;
result = asn1_get_bit_der
(node->value, node->value_len, &len2, value, value_size,
len);
if (result != ASN1_SUCCESS)
return result;
break;
case ASN1_ETYPE_CHOICE:
PUT_STR_VALUE (value, value_size, node->down->name);
break;
case ASN1_ETYPE_ANY:
len3 = -1;
len2 = asn1_get_length_der (node->value, node->value_len, &len3);
if (len2 < 0)
return ASN1_DER_ERROR;
PUT_VALUE (value, value_size, node->value + len3, len2);
break;
default:
return ASN1_ELEMENT_NOT_FOUND;
break;
}
return ASN1_SUCCESS;
} | 0 |
Subsets and Splits