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
|
|---|---|---|---|---|---|
OpenSC | 8fe377e93b4b56060e5bbfb6f3142ceaeca744fa | NOT_APPLICABLE | NOT_APPLICABLE | acl_to_ac_byte(struct sc_card *card, const struct sc_acl_entry *e)
{
if (e == NULL)
return SC_ERROR_OBJECT_NOT_FOUND;
switch (e->method) {
case SC_AC_NONE:
LOG_FUNC_RETURN(card->ctx, EPASS2003_AC_MAC_NOLESS | EPASS2003_AC_EVERYONE);
case SC_AC_NEVER:
LOG_FUNC_RETURN(card->ctx, EPASS2003_AC_MAC_NOLESS | EPASS2003_AC_NOONE);
default:
LOG_FUNC_RETURN(card->ctx, EPASS2003_AC_MAC_NOLESS | EPASS2003_AC_USER);
}
LOG_FUNC_RETURN(card->ctx, SC_ERROR_INCORRECT_PARAMETERS);
}
| 0 |
linux-2.6 | db048b69037e7fa6a7d9e95a1271a50dc08ae233 | CVE-2010-2478 | CWE-190 | static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
void __user *useraddr)
{
struct ethtool_rxnfc info;
const struct ethtool_ops *ops = dev->ethtool_ops;
int ret;
void *rule_buf = NULL;
if (!ops->get_rxnfc)
return -EOPNOTSUPP;
if (copy_from_user(&info, useraddr, sizeof(info)))
return -EFAULT;
if (info.cmd == ETHTOOL_GRXCLSRLALL) {
if (info.rule_cnt > 0) {
rule_buf = kmalloc(info.rule_cnt * sizeof(u32),
GFP_USER);
if (!rule_buf)
return -ENOMEM;
}
}
ret = ops->get_rxnfc(dev, &info, rule_buf);
if (ret < 0)
goto err_out;
ret = -EFAULT;
if (copy_to_user(useraddr, &info, sizeof(info)))
goto err_out;
if (rule_buf) {
useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
if (copy_to_user(useraddr, rule_buf,
info.rule_cnt * sizeof(u32)))
goto err_out;
}
ret = 0;
err_out:
kfree(rule_buf);
return ret;
} | 1 |
Android | ede8f95361dcbf9757aaf6d25ce59fa3767344e3 | NOT_APPLICABLE | NOT_APPLICABLE | void FrameSequenceState_gif::savePreserveBuffer(Color8888* outputPtr, int outputPixelStride, int frameNr) {
if (frameNr == mPreserveBufferFrame) return;
mPreserveBufferFrame = frameNr;
const int width = mFrameSequence.getWidth();
const int height = mFrameSequence.getHeight();
if (!mPreserveBuffer) {
mPreserveBuffer = new Color8888[width * height];
}
for (int y = 0; y < height; y++) {
memcpy(mPreserveBuffer + width * y,
outputPtr + outputPixelStride * y,
width * 4);
}
}
| 0 |
FFmpeg | 454a11a1c9c686c78aa97954306fb63453299760 | NOT_APPLICABLE | NOT_APPLICABLE | static inline void put_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
switch(width){
case 2: put_pixels2_8_c (dst, src, stride, height); break;
case 4: put_pixels4_8_c (dst, src, stride, height); break;
case 8: put_pixels8_8_c (dst, src, stride, height); break;
case 16:put_pixels16_8_c(dst, src, stride, height); break;
}
}
| 0 |
php-src | f3feddb5b45b5abd93abb1a95044b7e099d51c84 | NOT_APPLICABLE | NOT_APPLICABLE | static size_t php_bz2iop_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
{
struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *) stream->abstract;
int bz2_ret;
bz2_ret = BZ2_bzread(self->bz_file, buf, count);
if (bz2_ret < 0) {
stream->eof = 1;
return -1;
}
if (bz2_ret == 0) {
stream->eof = 1;
}
return (size_t)bz2_ret;
} | 0 |
gstreamer | bdc20b9baf13564d9a061343416395f8f9a92b53 | NOT_APPLICABLE | NOT_APPLICABLE | qtdemux_tag_add_num (GstQTDemux * qtdemux, const char *tag1,
const char *tag2, GNode * node)
{
GNode *data;
int len;
int type;
int n1, n2;
data = qtdemux_tree_get_child_by_type (node, FOURCC_data);
if (data) {
len = QT_UINT32 (data->data);
type = QT_UINT32 ((guint8 *) data->data + 8);
if (type == 0x00000000 && len >= 22) {
n1 = QT_UINT16 ((guint8 *) data->data + 18);
n2 = QT_UINT16 ((guint8 *) data->data + 20);
GST_DEBUG_OBJECT (qtdemux, "adding tag %d/%d", n1, n2);
gst_tag_list_add (qtdemux->tag_list, GST_TAG_MERGE_REPLACE,
tag1, n1, tag2, n2, NULL);
}
}
}
| 0 |
ghostpdl | 849e74e5ab450dd581942192da7101e0664fa5af | CVE-2020-16298 | CWE-120 | mj_color_correct(gx_color_value *Rptr ,gx_color_value *Gptr , gx_color_value *Bptr )
/* R,G,B : 0 to 255 */
{
short R,G,B; /* R,G,B : 0 to 255 */
short C,M,Y; /* C,M,Y : 0 to 1023 */
short H,D,Wa; /* ese-HSV */
long S; /* HSV */
R = *Rptr;
G = *Gptr;
B = *Bptr;
if (R==G) {
if (G==B) { /* R=G=B */
C=M=Y=1023-v_tbl[R];
*Rptr = C;
*Gptr = M;
*Bptr = Y;
return;
} else if (G>B) { /* R=G>B */
D = G-B;
Wa = R;
H = 256;
} else { /* B>R=G */
D = G-B;
Wa = R;
H = 1024;
}
}
if (R>G) {
if (G>=B) { /* R>G>B */
Wa=R;
D=R-B;
H=(G-B)*256/D;
} else if (R>B) { /* R>B>G */
Wa=R;
D=R-G;
H=1536-(B-G)*256/D;
} else { /* B>R>G */
Wa=B;
D=B-G;
H=1024+(R-G)*256/D;
}
} else {
if (R>B) { /* G>R>B */
Wa=G;
D=G-B;
H=512-(R-B)*256/D;
} else if (G>B) { /* G>B>R */
Wa=G;
D=G-R;
H=512+(B-R)*256/D;
} else { /* B>G>R */
Wa=B;
D=B-R;
H=1024-(G-R)*256/D;
}
}
if(Wa!=0){
if(Wa==D){
Wa=v_tbl[Wa];
D=Wa/4;
} else {
S=((long)D<<16)/Wa;
Wa=v_tbl[Wa];
D= ( ((long)S*Wa)>>18 );
}
}
Wa=1023-Wa;
C=(HtoCMY[H*3 ])*D/256+Wa;
M=(HtoCMY[H*3+1])*D/256+Wa;
Y=(HtoCMY[H*3+2])*D/256+Wa;
if (C<0)
C=0;
if (M<0)
M=0;
if (Y<0)
Y=0;
if(H>256 && H<1024){ /* green correct */
short work;
work=(((long)grnsep[M]*(long)grnsep2[H-256])>>16);
C+=work;
Y+=work+work;
M-=work+work;
if(C>1023) C=1023;
if(Y>1023) Y=1023;
}
*Rptr = C;
*Gptr = M;
*Bptr = Y;
} | 1 |
libsass | f2db04883e5fff4e03777dcc1eb60d4373c45be1 | NOT_APPLICABLE | NOT_APPLICABLE | Lookahead Parser::lookahead_for_value(const char* start)
{
// init result struct
Lookahead rv = Lookahead();
// get start position
const char* p = start ? start : position;
// match in one big "regex"
if (const char* q =
peek <
non_greedy <
alternatives <
// consume whitespace
block_comment, // spaces,
// main tokens
sequence <
interpolant,
optional <
quoted_string
>
>,
identifier,
variable,
// issue #442
sequence <
parenthese_scope,
interpolant,
optional <
quoted_string
>
>
>,
sequence <
// optional_spaces,
alternatives <
// end_of_file,
exactly<'{'>,
exactly<'}'>,
exactly<';'>
>
>
>
>(p)
) {
if (p == q) return rv;
while (p < q) {
// did we have interpolations?
if (*p == '#' && *(p+1) == '{') {
rv.has_interpolants = true;
p = q; break;
}
++ p;
}
// store anyway
// ToDo: remove
rv.position = q;
// check expected opening bracket
// only after successful matching
if (peek < exactly<'{'> >(q)) rv.found = q;
else if (peek < exactly<';'> >(q)) rv.found = q;
else if (peek < exactly<'}'> >(q)) rv.found = q;
}
// return result
return rv;
} | 0 |
mod_auth_openidc | 132a4111bf3791e76437619a66336dce2ce4c79b | NOT_APPLICABLE | NOT_APPLICABLE | static int oidc_authorization_response_error(request_rec *r, oidc_cfg *c,
oidc_proto_state_t *proto_state, const char *error,
const char *error_description) {
const char *prompt = oidc_proto_state_get_prompt(proto_state);
if (prompt != NULL)
prompt = apr_pstrdup(r->pool, prompt);
oidc_proto_state_destroy(proto_state);
if ((prompt != NULL)
&& (apr_strnatcmp(prompt, OIDC_PROTO_PROMPT_NONE) == 0)) {
return oidc_session_redirect_parent_window_to_logout(r, c);
}
return oidc_util_html_send_error(r, c->error_template,
apr_psprintf(r->pool, "OpenID Connect Provider error: %s", error),
error_description, DONE);
}
| 0 |
squid | 780c4ea1b4c9d2fb41f6962aa6ed73ae57f74b2b | NOT_APPLICABLE | NOT_APPLICABLE | gopherTimeout(const CommTimeoutCbParams &io)
{
GopherStateData *gopherState = static_cast<GopherStateData *>(io.data);
debugs(10, 4, HERE << io.conn << ": '" << gopherState->entry->url() << "'" );
gopherState->fwd->fail(new ErrorState(ERR_READ_TIMEOUT, Http::scGatewayTimeout, gopherState->fwd->request));
if (Comm::IsConnOpen(io.conn))
io.conn->close();
} | 0 |
PackageKit | 7e8a7905ea9abbd1f384f05f36a4458682cd4697 | NOT_APPLICABLE | NOT_APPLICABLE | pk_transaction_finalize (GObject *object)
{
PkTransaction *transaction;
g_return_if_fail (PK_IS_TRANSACTION (object));
transaction = PK_TRANSACTION (object);
if (transaction->priv->subject != NULL)
g_object_unref (transaction->priv->subject);
if (transaction->priv->watch_id > 0)
g_bus_unwatch_name (transaction->priv->watch_id);
g_free (transaction->priv->last_package_id);
g_free (transaction->priv->cached_package_id);
g_free (transaction->priv->cached_key_id);
g_strfreev (transaction->priv->cached_package_ids);
g_free (transaction->priv->cached_transaction_id);
g_free (transaction->priv->cached_directory);
g_strfreev (transaction->priv->cached_values);
g_free (transaction->priv->cached_repo_id);
g_free (transaction->priv->cached_parameter);
g_free (transaction->priv->cached_value);
g_free (transaction->priv->tid);
g_free (transaction->priv->sender);
g_free (transaction->priv->cmdline);
g_ptr_array_unref (transaction->priv->supported_content_types);
if (transaction->priv->connection != NULL)
g_object_unref (transaction->priv->connection);
if (transaction->priv->introspection != NULL)
g_dbus_node_info_unref (transaction->priv->introspection);
g_key_file_unref (transaction->priv->conf);
g_object_unref (transaction->priv->dbus);
if (transaction->priv->backend != NULL)
g_object_unref (transaction->priv->backend);
g_object_unref (transaction->priv->job);
g_object_unref (transaction->priv->transaction_db);
g_object_unref (transaction->priv->results);
g_object_unref (transaction->priv->authority);
g_object_unref (transaction->priv->cancellable);
G_OBJECT_CLASS (pk_transaction_parent_class)->finalize (object);
} | 0 |
openssl | 9a0db453ba017ebcaccbee933ee6511a9ae4d1c8 | NOT_APPLICABLE | NOT_APPLICABLE | static void crl_akid_check(X509_STORE_CTX *ctx, X509_CRL *crl,
X509 **pissuer, int *pcrl_score)
{
X509 *crl_issuer = NULL;
X509_NAME *cnm = X509_CRL_get_issuer(crl);
int cidx = ctx->error_depth;
int i;
if (cidx != sk_X509_num(ctx->chain) - 1)
cidx++;
crl_issuer = sk_X509_value(ctx->chain, cidx);
if (X509_check_akid(crl_issuer, crl->akid) == X509_V_OK) {
if (*pcrl_score & CRL_SCORE_ISSUER_NAME) {
*pcrl_score |= CRL_SCORE_AKID | CRL_SCORE_ISSUER_CERT;
*pissuer = crl_issuer;
return;
}
}
for (cidx++; cidx < sk_X509_num(ctx->chain); cidx++) {
crl_issuer = sk_X509_value(ctx->chain, cidx);
if (X509_NAME_cmp(X509_get_subject_name(crl_issuer), cnm))
continue;
if (X509_check_akid(crl_issuer, crl->akid) == X509_V_OK) {
*pcrl_score |= CRL_SCORE_AKID | CRL_SCORE_SAME_PATH;
*pissuer = crl_issuer;
return;
}
}
/* Anything else needs extended CRL support */
if (!(ctx->param->flags & X509_V_FLAG_EXTENDED_CRL_SUPPORT))
return;
/*
* Otherwise the CRL issuer is not on the path. Look for it in the set of
* untrusted certificates.
*/
for (i = 0; i < sk_X509_num(ctx->untrusted); i++) {
crl_issuer = sk_X509_value(ctx->untrusted, i);
if (X509_NAME_cmp(X509_get_subject_name(crl_issuer), cnm))
continue;
if (X509_check_akid(crl_issuer, crl->akid) == X509_V_OK) {
*pissuer = crl_issuer;
*pcrl_score |= CRL_SCORE_AKID;
return;
}
}
}
| 0 |
Chrome | 3bfe67c9c4b45eb713326aae7a67c8f7390dae08 | NOT_APPLICABLE | NOT_APPLICABLE | static void *contextMalloc(sqlite3_context *context, i64 nByte){
char *z;
sqlite3 *db = sqlite3_context_db_handle(context);
assert( nByte>0 );
testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
sqlite3_result_error_toobig(context);
z = 0;
}else{
z = sqlite3Malloc(nByte);
if( !z ){
sqlite3_result_error_nomem(context);
}
}
return z;
}
| 0 |
Chrome | 3c036ca040c114c077e13c35baaea78e2ddbaf61 | NOT_APPLICABLE | NOT_APPLICABLE | void WebTransformOperations::appendPerspective(double depth)
{
WebTransformOperation toAdd;
toAdd.matrix.applyPerspective(depth);
toAdd.type = WebTransformOperation::WebTransformOperationPerspective;
toAdd.perspectiveDepth = depth;
m_private->operations.append(toAdd);
}
| 0 |
libssh2 | ca5222ea819cc5ed797860070b4c6c1aeeb28420 | NOT_APPLICABLE | NOT_APPLICABLE | static int kex_agree_hostkey(LIBSSH2_SESSION * session,
unsigned long kex_flags,
unsigned char *hostkey, unsigned long hostkey_len)
{
const LIBSSH2_HOSTKEY_METHOD **hostkeyp = libssh2_hostkey_methods();
unsigned char *s;
if (session->hostkey_prefs) {
s = (unsigned char *) session->hostkey_prefs;
while (s && *s) {
unsigned char *p = (unsigned char *) strchr((char *) s, ',');
size_t method_len = (p ? (size_t)(p - s) : strlen((char *) s));
if (kex_agree_instr(hostkey, hostkey_len, s, method_len)) {
const LIBSSH2_HOSTKEY_METHOD *method =
(const LIBSSH2_HOSTKEY_METHOD *)
kex_get_method_by_name((char *) s, method_len,
(const LIBSSH2_COMMON_METHOD **)
hostkeyp);
if (!method) {
/* Invalid method -- Should never be reached */
return -1;
}
/* So far so good, but does it suit our purposes? (Encrypting
vs Signing) */
if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) ==
0) || (method->encrypt)) {
/* Either this hostkey can do encryption or this kex just
doesn't require it */
if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY)
== 0) || (method->sig_verify)) {
/* Either this hostkey can do signing or this kex just
doesn't require it */
session->hostkey = method;
return 0;
}
}
}
s = p ? p + 1 : NULL;
}
return -1;
}
while (hostkeyp && (*hostkeyp) && (*hostkeyp)->name) {
s = kex_agree_instr(hostkey, hostkey_len,
(unsigned char *) (*hostkeyp)->name,
strlen((*hostkeyp)->name));
if (s) {
/* So far so good, but does it suit our purposes? (Encrypting vs
Signing) */
if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) == 0) ||
((*hostkeyp)->encrypt)) {
/* Either this hostkey can do encryption or this kex just
doesn't require it */
if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY) ==
0) || ((*hostkeyp)->sig_verify)) {
/* Either this hostkey can do signing or this kex just
doesn't require it */
session->hostkey = *hostkeyp;
return 0;
}
}
}
hostkeyp++;
}
return -1;
} | 0 |
redcarpet | e5a10516d07114d582d13b9125b733008c61c242 | NOT_APPLICABLE | NOT_APPLICABLE | prefix_quote(uint8_t *data, size_t size)
{
size_t i = 0;
if (i < size && data[i] == ' ') i++;
if (i < size && data[i] == ' ') i++;
if (i < size && data[i] == ' ') i++;
if (i < size && data[i] == '>') {
if (i + 1 < size && data[i + 1] == ' ')
return i + 2;
return i + 1;
}
return 0;
} | 0 |
qemu | 98f93ddd84800f207889491e0b5d851386b459cf | NOT_APPLICABLE | NOT_APPLICABLE | static int virtio_net_load(QEMUFile *f, void *opaque, int version_id)
{
VirtIONet *n = opaque;
VirtIODevice *vdev = VIRTIO_DEVICE(n);
int ret, i, link_down;
if (version_id < 2 || version_id > VIRTIO_NET_VM_VERSION)
return -EINVAL;
ret = virtio_load(vdev, f);
if (ret) {
return ret;
}
qemu_get_buffer(f, n->mac, ETH_ALEN);
n->vqs[0].tx_waiting = qemu_get_be32(f);
virtio_net_set_mrg_rx_bufs(n, qemu_get_be32(f));
if (version_id >= 3)
n->status = qemu_get_be16(f);
if (version_id >= 4) {
if (version_id < 8) {
n->promisc = qemu_get_be32(f);
n->allmulti = qemu_get_be32(f);
} else {
n->promisc = qemu_get_byte(f);
n->allmulti = qemu_get_byte(f);
}
}
if (version_id >= 5) {
n->mac_table.in_use = qemu_get_be32(f);
/* MAC_TABLE_ENTRIES may be different from the saved image */
if (n->mac_table.in_use <= MAC_TABLE_ENTRIES) {
qemu_get_buffer(f, n->mac_table.macs,
n->mac_table.in_use * ETH_ALEN);
} else {
int64_t i;
/* Overflow detected - can happen if source has a larger MAC table.
* We simply set overflow flag so there's no need to maintain the
* table of addresses, discard them all.
* Note: 64 bit math to avoid integer overflow.
*/
for (i = 0; i < (int64_t)n->mac_table.in_use * ETH_ALEN; ++i) {
qemu_get_byte(f);
}
n->mac_table.multi_overflow = n->mac_table.uni_overflow = 1;
n->mac_table.in_use = 0;
}
error_report("virtio-net: saved image requires vnet_hdr=on");
return -1;
}
}
| 0 |
passenger | ddb8ecc4ebf260e4967f57f271d4f5761abeac3e | NOT_APPLICABLE | NOT_APPLICABLE | Controller::constructHeaderBuffersForHttpProtocol(Request *req, struct iovec *buffers,
unsigned int maxbuffers, unsigned int & restrict_ref nbuffers,
unsigned int & restrict_ref dataSize, HttpHeaderConstructionCache &cache)
{
#define BEGIN_PUSH_NEXT_BUFFER() \
do { \
if (buffers != NULL && i >= maxbuffers) { \
return false; \
} \
} while (false)
#define INC_BUFFER_ITER(i) \
do { \
i++; \
} while (false)
#define PUSH_STATIC_BUFFER(buf) \
do { \
BEGIN_PUSH_NEXT_BUFFER(); \
if (buffers != NULL) { \
buffers[i].iov_base = (void *) buf; \
buffers[i].iov_len = sizeof(buf) - 1; \
} \
INC_BUFFER_ITER(i); \
dataSize += sizeof(buf) - 1; \
} while (false)
ServerKit::HeaderTable::Iterator it(req->headers);
const LString::Part *part;
unsigned int i = 0;
nbuffers = 0;
dataSize = 0;
if (!cache.cached) {
cache.methodStr = http_method_str(req->method);
cache.remoteAddr = req->secureHeaders.lookup(REMOTE_ADDR);
cache.setCookie = req->headers.lookup(ServerKit::HTTP_SET_COOKIE);
cache.cached = true;
}
if (buffers != NULL) {
BEGIN_PUSH_NEXT_BUFFER();
buffers[i].iov_base = (void *) cache.methodStr.data();
buffers[i].iov_len = cache.methodStr.size();
}
INC_BUFFER_ITER(i);
dataSize += cache.methodStr.size();
PUSH_STATIC_BUFFER(" ");
if (buffers != NULL) {
BEGIN_PUSH_NEXT_BUFFER();
buffers[i].iov_base = (void *) req->path.start->data;
buffers[i].iov_len = req->path.size;
}
INC_BUFFER_ITER(i);
dataSize += req->path.size;
if (req->upgraded()) {
PUSH_STATIC_BUFFER(" HTTP/1.1\r\nConnection: upgrade\r\n");
} else {
PUSH_STATIC_BUFFER(" HTTP/1.1\r\nConnection: close\r\n");
}
if (cache.setCookie != NULL) {
LString::Part *part;
PUSH_STATIC_BUFFER("Set-Cookie: ");
part = cache.setCookie->start;
while (part != NULL) {
if (part->size == 1 && part->data[0] == '\n') {
// HeaderTable joins multiple Set-Cookie headers together using \n.
PUSH_STATIC_BUFFER("\r\nSet-Cookie: ");
} else {
if (buffers != NULL) {
BEGIN_PUSH_NEXT_BUFFER();
buffers[i].iov_base = (void *) part->data;
buffers[i].iov_len = part->size;
}
INC_BUFFER_ITER(i);
dataSize += part->size;
}
part = part->next;
}
PUSH_STATIC_BUFFER("\r\n");
}
while (*it != NULL) {
if ((it->header->hash == HTTP_CONNECTION.hash()
|| it->header->hash == ServerKit::HTTP_SET_COOKIE.hash())
&& (psg_lstr_cmp(&it->header->key, P_STATIC_STRING("connection"))
|| psg_lstr_cmp(&it->header->key, ServerKit::HTTP_SET_COOKIE)))
{
it.next();
continue;
}
part = it->header->key.start;
while (part != NULL) {
if (buffers != NULL) {
BEGIN_PUSH_NEXT_BUFFER();
buffers[i].iov_base = (void *) part->data;
buffers[i].iov_len = part->size;
}
INC_BUFFER_ITER(i);
part = part->next;
}
dataSize += it->header->key.size;
PUSH_STATIC_BUFFER(": ");
part = it->header->val.start;
while (part != NULL) {
if (buffers != NULL) {
BEGIN_PUSH_NEXT_BUFFER();
buffers[i].iov_base = (void *) part->data;
buffers[i].iov_len = part->size;
}
INC_BUFFER_ITER(i);
part = part->next;
}
dataSize += it->header->val.size;
PUSH_STATIC_BUFFER("\r\n");
it.next();
}
if (req->https) {
PUSH_STATIC_BUFFER("X-Forwarded-Proto: https\r\n");
PUSH_STATIC_BUFFER("!~Passenger-Proto: https\r\n");
}
if (cache.remoteAddr != NULL && cache.remoteAddr->size > 0) {
PUSH_STATIC_BUFFER("X-Forwarded-For: ");
part = cache.remoteAddr->start;
while (part != NULL) {
if (buffers != NULL) {
BEGIN_PUSH_NEXT_BUFFER();
buffers[i].iov_base = (void *) part->data;
buffers[i].iov_len = part->size;
}
INC_BUFFER_ITER(i);
part = part->next;
}
dataSize += cache.remoteAddr->size;
PUSH_STATIC_BUFFER("\r\n");
PUSH_STATIC_BUFFER("!~Passenger-Client-Address: ");
part = cache.remoteAddr->start;
while (part != NULL) {
if (buffers != NULL) {
BEGIN_PUSH_NEXT_BUFFER();
buffers[i].iov_base = (void *) part->data;
buffers[i].iov_len = part->size;
}
INC_BUFFER_ITER(i);
part = part->next;
}
dataSize += cache.remoteAddr->size;
PUSH_STATIC_BUFFER("\r\n");
}
if (req->envvars != NULL) {
PUSH_STATIC_BUFFER("!~Passenger-Envvars: ");
if (buffers != NULL) {
BEGIN_PUSH_NEXT_BUFFER();
buffers[i].iov_base = (void *) req->envvars->start->data;
buffers[i].iov_len = req->envvars->size;
}
INC_BUFFER_ITER(i);
dataSize += req->envvars->size;
PUSH_STATIC_BUFFER("\r\n");
}
if (req->options.analytics) {
PUSH_STATIC_BUFFER("!~Passenger-Txn-Id: ");
if (buffers != NULL) {
BEGIN_PUSH_NEXT_BUFFER();
buffers[i].iov_base = (void *) req->options.transaction->getTxnId().data();
buffers[i].iov_len = req->options.transaction->getTxnId().size();
}
INC_BUFFER_ITER(i);
dataSize += req->options.transaction->getTxnId().size();
PUSH_STATIC_BUFFER("\r\n");
}
PUSH_STATIC_BUFFER("\r\n");
nbuffers = i;
return true;
#undef BEGIN_PUSH_NEXT_BUFFER
#undef INC_BUFFER_ITER
#undef PUSH_STATIC_BUFFER
} | 0 |
linux | 704620afc70cf47abb9d6a1a57f3825d2bca49cf | NOT_APPLICABLE | NOT_APPLICABLE | static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
{
struct usb_port *port_dev = hub->ports[port1 - 1];
struct usb_device *hdev = hub->hdev;
int ret = 0;
if (!hub->error) {
if (hub_is_superspeed(hub->hdev)) {
hub_usb3_port_prepare_disable(hub, port_dev);
ret = hub_set_port_link_state(hub, port_dev->portnum,
USB_SS_PORT_LS_U3);
} else {
ret = usb_clear_port_feature(hdev, port1,
USB_PORT_FEAT_ENABLE);
}
}
if (port_dev->child && set_state)
usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
if (ret && ret != -ENODEV)
dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
return ret;
}
| 0 |
grub | ac8cac1dac50daaf1c390d701cca3b55e16ee768 | NOT_APPLICABLE | NOT_APPLICABLE | grub_ext2_close (grub_file_t file)
{
grub_free (file->data);
grub_dl_unref (my_mod);
return GRUB_ERR_NONE;
} | 0 |
Chrome | 9eb1fd426a04adac0906c81ed88f1089969702ba | NOT_APPLICABLE | NOT_APPLICABLE | bool GetStoreLoginFunction::RunImpl() {
if (!IsWebStoreURL(profile_, source_url()))
return false;
ExtensionService* service = profile_->GetExtensionService();
ExtensionPrefs* prefs = service->extension_prefs();
std::string login;
if (prefs->GetWebStoreLogin(&login)) {
result_.reset(Value::CreateStringValue(login));
} else {
result_.reset(Value::CreateStringValue(std::string()));
}
return true;
}
| 0 |
linux | ccfe8c3f7e52ae83155cb038753f4c75b774ca8a | NOT_APPLICABLE | NOT_APPLICABLE | static int cbc_decrypt(struct blkcipher_desc *desc,
struct scatterlist *dst, struct scatterlist *src,
unsigned int nbytes)
{
struct crypto_aes_ctx *ctx = aes_ctx(crypto_blkcipher_ctx(desc->tfm));
struct blkcipher_walk walk;
int err;
blkcipher_walk_init(&walk, dst, src, nbytes);
err = blkcipher_walk_virt(desc, &walk);
desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
kernel_fpu_begin();
while ((nbytes = walk.nbytes)) {
aesni_cbc_dec(ctx, walk.dst.virt.addr, walk.src.virt.addr,
nbytes & AES_BLOCK_MASK, walk.iv);
nbytes &= AES_BLOCK_SIZE - 1;
err = blkcipher_walk_done(desc, &walk, nbytes);
}
kernel_fpu_end();
return err;
}
| 0 |
Chrome | c4a4dfb26615b5ef5e9dcc730ef43f70ce9202e2 | NOT_APPLICABLE | NOT_APPLICABLE | void RenderThreadImpl::OnCreateNewSharedWorker(
const WorkerProcessMsg_CreateWorker_Params& params) {
new EmbeddedSharedWorkerStub(params.url,
params.name,
params.content_security_policy,
params.security_policy_type,
params.pause_on_start,
params.route_id);
}
| 0 |
radare2 | 041e53cab7ca33481ae45ecd65ad596976d78e68 | NOT_APPLICABLE | NOT_APPLICABLE | INST_HANDLER (ldi) { // LDI Rd, K
int k = (buf[0] & 0xf) + ((buf[1] & 0xf) << 4);
int d = ((buf[0] >> 4) & 0xf) + 16;
op->val = k;
ESIL_A ("0x%x,r%d,=,", k, d);
}
| 0 |
FreeRDP | 7d58aac24fe20ffaad7bd9b40c9ddf457c1b06e7 | NOT_APPLICABLE | NOT_APPLICABLE | BOOL rdp_recv_set_error_info_data_pdu(rdpRdp* rdp, STREAM* s)
{
if (stream_get_left(s) < 4)
return FALSE;
stream_read_UINT32(s, rdp->errorInfo); /* errorInfo (4 bytes) */
if (rdp->errorInfo != ERRINFO_SUCCESS)
rdp_print_errinfo(rdp->errorInfo);
return TRUE;
}
| 0 |
libgcrypt | a4c561aab1014c3630bc88faf6f5246fee16b020 | NOT_APPLICABLE | NOT_APPLICABLE | gcm_check_aadlen_or_ivlen (u32 ctr[2])
{
/* len(aad/iv) <= 2^64-1 bits ~= 2^61-1 bytes */
if (ctr[1] > 0x1fffffffU)
return 0;
if (ctr[1] < 0x1fffffffU)
return 1;
if (ctr[0] <= 0xffffffffU)
return 1;
return 0;
}
| 0 |
gnome-bluetooth | 6b5086d42ea64d46277f3c93b43984f331d12f89 | NOT_APPLICABLE | NOT_APPLICABLE | _bluetooth_client_get_default_adapter_name (BluetoothClient *self)
{
BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE (self);
GtkTreePath *path;
GtkTreeIter iter;
char *ret;
if (priv->default_adapter == NULL)
return NULL;
path = gtk_tree_row_reference_get_path (priv->default_adapter);
gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store), &iter, path);
gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter, BLUETOOTH_COLUMN_NAME, &ret, -1);
gtk_tree_path_free (path);
return ret;
} | 0 |
linux | 99e3a236dd43d06c65af0a2ef9cb44306aef6e02 | NOT_APPLICABLE | NOT_APPLICABLE | static int xdp_umem_account_pages(struct xdp_umem *umem)
{
unsigned long lock_limit, new_npgs, old_npgs;
if (capable(CAP_IPC_LOCK))
return 0;
lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
umem->user = get_uid(current_user());
do {
old_npgs = atomic_long_read(&umem->user->locked_vm);
new_npgs = old_npgs + umem->npgs;
if (new_npgs > lock_limit) {
free_uid(umem->user);
umem->user = NULL;
return -ENOBUFS;
}
} while (atomic_long_cmpxchg(&umem->user->locked_vm, old_npgs,
new_npgs) != old_npgs);
return 0;
} | 0 |
tcpdump | cc356512f512e7fa423b3674db4bb31dbe40ffec | NOT_APPLICABLE | NOT_APPLICABLE | wb_print(netdissect_options *ndo,
register const void *hdr, register u_int len)
{
register const struct pkt_hdr *ph;
ph = (const struct pkt_hdr *)hdr;
if (len < sizeof(*ph) || !ND_TTEST(*ph)) {
ND_PRINT((ndo, "%s", tstr));
return;
}
len -= sizeof(*ph);
if (ph->ph_flags)
ND_PRINT((ndo, "*"));
switch (ph->ph_type) {
case PT_KILL:
ND_PRINT((ndo, " wb-kill"));
return;
case PT_ID:
if (wb_id(ndo, (const struct pkt_id *)(ph + 1), len) >= 0)
return;
ND_PRINT((ndo, "%s", tstr));
break;
case PT_RREQ:
if (wb_rreq(ndo, (const struct pkt_rreq *)(ph + 1), len) >= 0)
return;
ND_PRINT((ndo, "%s", tstr));
break;
case PT_RREP:
if (wb_rrep(ndo, (const struct pkt_rrep *)(ph + 1), len) >= 0)
return;
ND_PRINT((ndo, "%s", tstr));
break;
case PT_DRAWOP:
if (wb_drawop(ndo, (const struct pkt_dop *)(ph + 1), len) >= 0)
return;
ND_PRINT((ndo, "%s", tstr));
break;
case PT_PREQ:
if (wb_preq(ndo, (const struct pkt_preq *)(ph + 1), len) >= 0)
return;
ND_PRINT((ndo, "%s", tstr));
break;
case PT_PREP:
if (wb_prep(ndo, (const struct pkt_prep *)(ph + 1), len) >= 0)
return;
ND_PRINT((ndo, "%s", tstr));
break;
default:
ND_PRINT((ndo, " wb-%d!", ph->ph_type));
return;
}
}
| 0 |
Android | dd28d8ddf2985d654781770c691c60b45d7f32b4 | NOT_APPLICABLE | NOT_APPLICABLE | const char* dump_av_sm_state_name(btif_av_state_t state) {
switch (state) {
CASE_RETURN_STR(BTIF_AV_STATE_IDLE)
CASE_RETURN_STR(BTIF_AV_STATE_OPENING)
CASE_RETURN_STR(BTIF_AV_STATE_OPENED)
CASE_RETURN_STR(BTIF_AV_STATE_STARTED)
CASE_RETURN_STR(BTIF_AV_STATE_CLOSING)
default:
return "UNKNOWN_STATE";
}
}
| 0 |
sqlite | 5f69512404cd2e5153ddf90ea277fbba6dd58ab7 | NOT_APPLICABLE | NOT_APPLICABLE | Select *sqlite3SelectNew(
Parse *pParse, /* Parsing context */
ExprList *pEList, /* which columns to include in the result */
SrcList *pSrc, /* the FROM clause -- which tables to scan */
Expr *pWhere, /* the WHERE clause */
ExprList *pGroupBy, /* the GROUP BY clause */
Expr *pHaving, /* the HAVING clause */
ExprList *pOrderBy, /* the ORDER BY clause */
u32 selFlags, /* Flag parameters, such as SF_Distinct */
Expr *pLimit /* LIMIT value. NULL means not used */
){
Select *pNew;
Select standin;
pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );
if( pNew==0 ){
assert( pParse->db->mallocFailed );
pNew = &standin;
}
if( pEList==0 ){
pEList = sqlite3ExprListAppend(pParse, 0,
sqlite3Expr(pParse->db,TK_ASTERISK,0));
}
pNew->pEList = pEList;
pNew->op = TK_SELECT;
pNew->selFlags = selFlags;
pNew->iLimit = 0;
pNew->iOffset = 0;
pNew->selId = ++pParse->nSelect;
pNew->addrOpenEphm[0] = -1;
pNew->addrOpenEphm[1] = -1;
pNew->nSelectRow = 0;
if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc));
pNew->pSrc = pSrc;
pNew->pWhere = pWhere;
pNew->pGroupBy = pGroupBy;
pNew->pHaving = pHaving;
pNew->pOrderBy = pOrderBy;
pNew->pPrior = 0;
pNew->pNext = 0;
pNew->pLimit = pLimit;
pNew->pWith = 0;
#ifndef SQLITE_OMIT_WINDOWFUNC
pNew->pWin = 0;
pNew->pWinDefn = 0;
#endif
if( pParse->db->mallocFailed ) {
clearSelect(pParse->db, pNew, pNew!=&standin);
pNew = 0;
}else{
assert( pNew->pSrc!=0 || pParse->nErr>0 );
}
assert( pNew!=&standin );
return pNew;
} | 0 |
src | 9dcfda045474d8903224d175907bfc29761dcb45 | NOT_APPLICABLE | NOT_APPLICABLE | smtp_tx_filtered_dataline(struct smtp_tx *tx, const char *line)
{
if (!strcmp(line, "."))
line = NULL;
else {
/* ignore data line if an error is set */
if (tx->error)
return 0;
}
io_printf(tx->filter, "%s\n", line ? line : ".");
return line ? 0 : 1;
} | 0 |
monit | 328f60773057641c4b2075fab9820145e95b728c | NOT_APPLICABLE | NOT_APPLICABLE | static void print_alerts(HttpResponse res, Mail_T s) {
for (Mail_T r = s; r; r = r->next) {
StringBuffer_append(res->outputbuffer,
"<tr class='stripe'><td>Alert mail to</td>"
"<td>%s</td></tr>", r->to ? r->to : "");
StringBuffer_append(res->outputbuffer, "<tr><td>Alert on</td><td>");
if (r->events == Event_Null) {
StringBuffer_append(res->outputbuffer, "No events");
} else if (r->events == Event_All) {
StringBuffer_append(res->outputbuffer, "All events");
} else {
if (IS_EVENT_SET(r->events, Event_Action))
StringBuffer_append(res->outputbuffer, "Action ");
if (IS_EVENT_SET(r->events, Event_ByteIn))
StringBuffer_append(res->outputbuffer, "ByteIn ");
if (IS_EVENT_SET(r->events, Event_ByteOut))
StringBuffer_append(res->outputbuffer, "ByteOut ");
if (IS_EVENT_SET(r->events, Event_Checksum))
StringBuffer_append(res->outputbuffer, "Checksum ");
if (IS_EVENT_SET(r->events, Event_Connection))
StringBuffer_append(res->outputbuffer, "Connection ");
if (IS_EVENT_SET(r->events, Event_Content))
StringBuffer_append(res->outputbuffer, "Content ");
if (IS_EVENT_SET(r->events, Event_Data))
StringBuffer_append(res->outputbuffer, "Data ");
if (IS_EVENT_SET(r->events, Event_Exec))
StringBuffer_append(res->outputbuffer, "Exec ");
if (IS_EVENT_SET(r->events, Event_Exist))
StringBuffer_append(res->outputbuffer, "Exist ");
if (IS_EVENT_SET(r->events, Event_FsFlag))
StringBuffer_append(res->outputbuffer, "Fsflags ");
if (IS_EVENT_SET(r->events, Event_Gid))
StringBuffer_append(res->outputbuffer, "Gid ");
if (IS_EVENT_SET(r->events, Event_Instance))
StringBuffer_append(res->outputbuffer, "Instance ");
if (IS_EVENT_SET(r->events, Event_Invalid))
StringBuffer_append(res->outputbuffer, "Invalid ");
if (IS_EVENT_SET(r->events, Event_Link))
StringBuffer_append(res->outputbuffer, "Link ");
if (IS_EVENT_SET(r->events, Event_NonExist))
StringBuffer_append(res->outputbuffer, "Nonexist ");
if (IS_EVENT_SET(r->events, Event_Permission))
StringBuffer_append(res->outputbuffer, "Permission ");
if (IS_EVENT_SET(r->events, Event_PacketIn))
StringBuffer_append(res->outputbuffer, "PacketIn ");
if (IS_EVENT_SET(r->events, Event_PacketOut))
StringBuffer_append(res->outputbuffer, "PacketOut ");
if (IS_EVENT_SET(r->events, Event_Pid))
StringBuffer_append(res->outputbuffer, "PID ");
if (IS_EVENT_SET(r->events, Event_Icmp))
StringBuffer_append(res->outputbuffer, "Ping ");
if (IS_EVENT_SET(r->events, Event_PPid))
StringBuffer_append(res->outputbuffer, "PPID ");
if (IS_EVENT_SET(r->events, Event_Resource))
StringBuffer_append(res->outputbuffer, "Resource ");
if (IS_EVENT_SET(r->events, Event_Saturation))
StringBuffer_append(res->outputbuffer, "Saturation ");
if (IS_EVENT_SET(r->events, Event_Size))
StringBuffer_append(res->outputbuffer, "Size ");
if (IS_EVENT_SET(r->events, Event_Speed))
StringBuffer_append(res->outputbuffer, "Speed ");
if (IS_EVENT_SET(r->events, Event_Status))
StringBuffer_append(res->outputbuffer, "Status ");
if (IS_EVENT_SET(r->events, Event_Timeout))
StringBuffer_append(res->outputbuffer, "Timeout ");
if (IS_EVENT_SET(r->events, Event_Timestamp))
StringBuffer_append(res->outputbuffer, "Timestamp ");
if (IS_EVENT_SET(r->events, Event_Uid))
StringBuffer_append(res->outputbuffer, "Uid ");
if (IS_EVENT_SET(r->events, Event_Uptime))
StringBuffer_append(res->outputbuffer, "Uptime ");
}
StringBuffer_append(res->outputbuffer, "</td></tr>");
if (r->reminder) {
StringBuffer_append(res->outputbuffer,
"<tr><td>Alert reminder</td><td>%u cycles</td></tr>",
r->reminder);
}
}
} | 0 |
linux | ac795161c93699d600db16c1a8cc23a65a1eceaf | NOT_APPLICABLE | NOT_APPLICABLE | static struct page *nfs_readdir_page_get_locked(struct address_space *mapping,
pgoff_t index, u64 last_cookie)
{
struct page *page;
page = grab_cache_page(mapping, index);
if (page && !PageUptodate(page)) {
nfs_readdir_page_init_array(page, last_cookie);
if (invalidate_inode_pages2_range(mapping, index + 1, -1) < 0)
nfs_zap_mapping(mapping->host, mapping);
SetPageUptodate(page);
}
return page;
} | 0 |
systemd | 8523bf7dd514a3a2c6114b7b8fb8f308b4f09fc4 | NOT_APPLICABLE | NOT_APPLICABLE | static bool manager_get_show_status(Manager *m, StatusType type) {
assert(m);
if (!MANAGER_IS_SYSTEM(m))
return false;
if (m->no_console_output)
return false;
if (!IN_SET(manager_state(m), MANAGER_INITIALIZING, MANAGER_STARTING, MANAGER_STOPPING))
return false;
/* If we cannot find out the status properly, just proceed. */
if (type != STATUS_TYPE_EMERGENCY && manager_check_ask_password(m) > 0)
return false;
if (m->show_status > 0)
return true;
return false;
} | 0 |
linux | 70789d7052239992824628db8133de08dc78e593 | NOT_APPLICABLE | NOT_APPLICABLE | static int __net_init ipv6_frags_init_net(struct net *net)
{
net->ipv6.frags.high_thresh = IPV6_FRAG_HIGH_THRESH;
net->ipv6.frags.low_thresh = IPV6_FRAG_LOW_THRESH;
net->ipv6.frags.timeout = IPV6_FRAG_TIMEOUT;
inet_frags_init_net(&net->ipv6.frags);
return ip6_frags_ns_sysctl_register(net);
}
| 0 |
Chrome | 9ad7483d8e7c20e9f1a5a08d00150fb51899f14c | NOT_APPLICABLE | NOT_APPLICABLE | ThreadWatcherObserver::ThreadWatcherObserver(
const base::TimeDelta& wakeup_interval)
: last_wakeup_time_(base::TimeTicks::Now()),
wakeup_interval_(wakeup_interval) {
CHECK(!g_thread_watcher_observer_);
g_thread_watcher_observer_ = this;
}
| 0 |
Chrome | 2f81d000fdb5331121cba7ff81dfaaec25b520a5 | NOT_APPLICABLE | NOT_APPLICABLE | void ResourceDispatcherHostImpl::RemovePendingLoader(
const LoaderMap::iterator& iter) {
ResourceRequestInfoImpl* info = iter->second->GetRequestInfo();
if (info->keepalive())
keepalive_statistics_recorder_.OnLoadFinished(info->GetChildID());
IncrementOutstandingRequestsMemory(-1, *info);
pending_loaders_.erase(iter);
}
| 0 |
linux | 588f7d39b3592a36fb7702ae3b8bdd9be4621e2f | NOT_APPLICABLE | NOT_APPLICABLE | static void ieee80211_verify_alignment(struct ieee80211_rx_data *rx)
{
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
WARN_ON_ONCE((unsigned long)rx->skb->data & 1);
#endif
} | 0 |
libpng | 812768d7a9c973452222d454634496b25ed415eb | NOT_APPLICABLE | NOT_APPLICABLE | png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
{
/* Set the rgb_to_gray coefficients from the colorspace. */
if (png_ptr->rgb_to_gray_coefficients_set == 0 &&
(png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
{
/* png_set_background has not been called, get the coefficients from the Y
* values of the colorspace colorants.
*/
png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y;
png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y;
png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y;
png_fixed_point total = r+g+b;
if (total > 0 &&
r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 &&
g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 &&
b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 &&
r+g+b <= 32769)
{
/* We allow 0 coefficients here. r+g+b may be 32769 if two or
* all of the coefficients were rounded up. Handle this by
* reducing the *largest* coefficient by 1; this matches the
* approach used for the default coefficients in pngrtran.c
*/
int add = 0;
if (r+g+b > 32768)
add = -1;
else if (r+g+b < 32768)
add = 1;
if (add != 0)
{
if (g >= r && g >= b)
g += add;
else if (r >= g && r >= b)
r += add;
else
b += add;
}
/* Check for an internal error. */
if (r+g+b != 32768)
png_error(png_ptr,
"internal error handling cHRM coefficients");
else
{
png_ptr->rgb_to_gray_red_coeff = (png_uint_16)r;
png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g;
}
}
/* This is a png_error at present even though it could be ignored -
* it should never happen, but it is important that if it does, the
* bug is fixed.
*/
else
png_error(png_ptr, "internal error handling cHRM->XYZ");
}
} | 0 |
ipsec | 7bab09631c2a303f87a7eb7e3d69e888673b9b7e | NOT_APPLICABLE | NOT_APPLICABLE | static int __net_init xfrm_statistics_init(struct net *net)
{
int rv;
net->mib.xfrm_statistics = alloc_percpu(struct linux_xfrm_mib);
if (!net->mib.xfrm_statistics)
return -ENOMEM;
rv = xfrm_proc_init(net);
if (rv < 0)
free_percpu(net->mib.xfrm_statistics);
return rv;
} | 0 |
savannah | c15c42ccd1e2377945fd0414eca1a49294bff454 | NOT_APPLICABLE | NOT_APPLICABLE | sparse_dump_region (struct tar_sparse_file *file, size_t i)
{
union block *blk;
off_t bytes_left = file->stat_info->sparse_map[i].numbytes;
if (!lseek_or_error (file, file->stat_info->sparse_map[i].offset))
return false;
while (bytes_left > 0)
{
size_t bufsize = (bytes_left > BLOCKSIZE) ? BLOCKSIZE : bytes_left;
size_t bytes_read;
blk = find_next_block ();
bytes_read = safe_read (file->fd, blk->buffer, bufsize);
if (bytes_read == SAFE_READ_ERROR)
{
read_diag_details (file->stat_info->orig_file_name,
(file->stat_info->sparse_map[i].offset
+ file->stat_info->sparse_map[i].numbytes
- bytes_left),
bufsize);
return false;
}
else if (bytes_read == 0)
{
char buf[UINTMAX_STRSIZE_BOUND];
struct stat st;
size_t n;
if (fstat (file->fd, &st) == 0)
n = file->stat_info->stat.st_size - st.st_size;
else
n = file->stat_info->stat.st_size
- (file->stat_info->sparse_map[i].offset
+ file->stat_info->sparse_map[i].numbytes
- bytes_left);
WARNOPT (WARN_FILE_SHRANK,
(0, 0,
ngettext ("%s: File shrank by %s byte; padding with zeros",
"%s: File shrank by %s bytes; padding with zeros",
n),
quotearg_colon (file->stat_info->orig_file_name),
STRINGIFY_BIGINT (n, buf)));
if (! ignore_failed_read_option)
set_exit_status (TAREXIT_DIFFERS);
return false;
}
memset (blk->buffer + bytes_read, 0, BLOCKSIZE - bytes_read);
bytes_left -= bytes_read;
{
size_t count;
size_t wrbytes = (write_size > BLOCKSIZE) ? BLOCKSIZE : write_size;
union block *blk = find_next_block ();
if (!blk)
{
ERROR ((0, 0, _("Unexpected EOF in archive")));
return false;
}
set_next_block_after (blk);
count = blocking_write (file->fd, blk->buffer, wrbytes);
write_size -= count;
file->dumped_size += count;
mv_size_left (file->stat_info->archive_file_size - file->dumped_size);
file->offset += count;
if (count != wrbytes)
{
write_error_details (file->stat_info->orig_file_name,
count, wrbytes);
return false;
}
}
return true;
}
/* Interface functions */
enum dump_status
sparse_dump_file (int fd, struct tar_stat_info *st)
{
return false;
}
set_next_block_after (blk);
file->dumped_size += BLOCKSIZE;
count = blocking_write (file->fd, blk->buffer, wrbytes);
write_size -= count;
mv_size_left (file->stat_info->archive_file_size - file->dumped_size);
file->offset += count;
if (count != wrbytes)
rc = sparse_scan_file (&file);
if (rc && file.optab->dump_region)
{
tar_sparse_dump_header (&file);
if (fd >= 0)
{
size_t i;
mv_begin_write (file.stat_info->file_name,
file.stat_info->stat.st_size,
file.stat_info->archive_file_size - file.dumped_size);
for (i = 0; rc && i < file.stat_info->sparse_map_avail; i++)
rc = tar_sparse_dump_region (&file, i);
}
}
pad_archive (file.stat_info->archive_file_size - file.dumped_size);
return (tar_sparse_done (&file) && rc) ? dump_status_ok : dump_status_short;
}
| 0 |
v4l2loopback | e4cd225557486c420f6a34411f98c575effd43dd | NOT_APPLICABLE | NOT_APPLICABLE | static int vidioc_g_fmt_overlay(struct file *file, void *priv,
struct v4l2_format *fmt)
{
return 0;
} | 0 |
systemd-stable | b00674347337b7531c92fdb65590ab253bb57538 | NOT_APPLICABLE | NOT_APPLICABLE | int unit_name_path_escape(const char *f, char **ret) {
_cleanup_free_ char *p = NULL;
char *s;
assert(f);
assert(ret);
p = strdup(f);
if (!p)
return -ENOMEM;
path_simplify(p, false);
if (empty_or_root(p))
s = strdup("-");
else {
if (!path_is_normalized(p))
return -EINVAL;
/* Truncate trailing slashes and skip leading slashes */
delete_trailing_chars(p, "/");
s = unit_name_escape(skip_leading_chars(p, "/"));
}
if (!s)
return -ENOMEM;
*ret = s;
return 0;
} | 0 |
mruby | aaa28a508903041dd7399d4159a8ace9766b022f | NOT_APPLICABLE | NOT_APPLICABLE | check_method_noarg(mrb_state *mrb, const mrb_callinfo *ci)
{
int argc = ci->n == CALL_MAXARGS ? RARRAY_LEN(ci->stack[1]) : ci->n;
if (ci->nk > 0) {
mrb_value kdict = ci->stack[mrb_ci_kidx(ci)];
if (!(mrb_hash_p(kdict) && mrb_hash_empty_p(mrb, kdict))) {
argc++;
}
}
if (argc > 0) {
mrb_argnum_error(mrb, argc, 0, 0);
}
} | 0 |
mruby | 97319697c8f9f6ff27b32589947e1918e3015503 | NOT_APPLICABLE | NOT_APPLICABLE | mark_context(mrb_state *mrb, struct mrb_context *c)
{
int i;
mrb_callinfo *ci;
start:
if (c->status == MRB_FIBER_TERMINATED) return;
/* mark VM stack */
mark_context_stack(mrb, c);
/* mark call stack */
if (c->cibase) {
for (ci = c->cibase; ci <= c->ci; ci++) {
mrb_gc_mark(mrb, (struct RBasic*)ci->env);
mrb_gc_mark(mrb, (struct RBasic*)ci->proc);
mrb_gc_mark(mrb, (struct RBasic*)ci->target_class);
}
}
/* mark ensure stack */
for (i=0; i<c->eidx; i++) {
mrb_gc_mark(mrb, (struct RBasic*)c->ensure[i]);
}
/* mark fibers */
mrb_gc_mark(mrb, (struct RBasic*)c->fib);
if (c->prev) {
c = c->prev;
goto start;
}
} | 0 |
src | 79a034b4aed29e965f45a13409268290c9910043 | NOT_APPLICABLE | NOT_APPLICABLE | table_inet4_match(struct sockaddr_in *ss, struct netaddr *ssmask)
{
in_addr_t mask;
int i;
/* a.b.c.d/8 -> htonl(0xff000000) */
mask = 0;
for (i = 0; i < ssmask->bits; ++i)
mask = (mask >> 1) | 0x80000000;
mask = htonl(mask);
/* (addr & mask) == (net & mask) */
if ((ss->sin_addr.s_addr & mask) ==
(((struct sockaddr_in *)ssmask)->sin_addr.s_addr & mask))
return 1;
return 0;
} | 0 |
flac | 2e7931c27eb15e387da440a37f12437e35b22dd4 | NOT_APPLICABLE | NOT_APPLICABLE | FLAC__BitReader *FLAC__bitreader_new(void)
{
FLAC__BitReader *br = calloc(1, sizeof(FLAC__BitReader));
/* calloc() implies:
memset(br, 0, sizeof(FLAC__BitReader));
br->buffer = 0;
br->capacity = 0;
br->words = br->bytes = 0;
br->consumed_words = br->consumed_bits = 0;
br->read_callback = 0;
br->client_data = 0;
*/
return br;
} | 0 |
systemd | 6d586a13717ae057aa1b4127400c3de61cd5b9e7 | NOT_APPLICABLE | NOT_APPLICABLE | static int bus_socket_start_auth_client(sd_bus *b) {
size_t l;
const char *auth_suffix, *auth_prefix;
assert(b);
if (b->anonymous_auth) {
auth_prefix = "\0AUTH ANONYMOUS ";
/* For ANONYMOUS auth we send some arbitrary "trace" string */
l = 9;
b->auth_buffer = hexmem("anonymous", l);
} else {
char text[DECIMAL_STR_MAX(uid_t) + 1];
auth_prefix = "\0AUTH EXTERNAL ";
xsprintf(text, UID_FMT, geteuid());
l = strlen(text);
b->auth_buffer = hexmem(text, l);
}
if (!b->auth_buffer)
return -ENOMEM;
if (b->accept_fd)
auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
else
auth_suffix = "\r\nBEGIN\r\n";
b->auth_iovec[0] = IOVEC_MAKE((void*) auth_prefix, 1 + strlen(auth_prefix + 1));
b->auth_iovec[1] = IOVEC_MAKE(b->auth_buffer, l * 2);
b->auth_iovec[2] = IOVEC_MAKE_STRING(auth_suffix);
return bus_socket_write_auth(b);
} | 0 |
ImageMagick | 70aa86f5d5d8aa605a918ed51f7574f433a18482 | NOT_APPLICABLE | NOT_APPLICABLE | static void ConvertRGBToYIQ(const double red,const double green,
const double blue,double *Y,double *I,double *Q)
{
*Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
*I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
*Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
} | 0 |
lhasa | 6fcdb8f1f538b9d63e63a5fa199c5514a15d4564 | NOT_APPLICABLE | NOT_APPLICABLE | static int check_common_crc(LHAFileHeader *header)
{
uint16_t crc;
crc = 0;
lha_crc16_buf(&crc, header->raw_data, header->raw_data_len);
return crc == header->common_crc;
}
| 0 |
linux | b35cc8225845112a616e3a2266d2fde5ab13d3ab | NOT_APPLICABLE | NOT_APPLICABLE | static size_t snd_compr_calc_avail(struct snd_compr_stream *stream,
struct snd_compr_avail *avail)
{
long avail_calc; /*this needs to be signed variable */
snd_compr_update_tstamp(stream, &avail->tstamp);
/* FIXME: This needs to be different for capture stream,
available is # of compressed data, for playback it's
remainder of buffer */
if (stream->runtime->total_bytes_available == 0 &&
stream->runtime->state == SNDRV_PCM_STATE_SETUP) {
pr_debug("detected init and someone forgot to do a write\n");
return stream->runtime->buffer_size;
}
pr_debug("app wrote %lld, DSP consumed %lld\n",
stream->runtime->total_bytes_available,
stream->runtime->total_bytes_transferred);
if (stream->runtime->total_bytes_available ==
stream->runtime->total_bytes_transferred) {
pr_debug("both pointers are same, returning full avail\n");
return stream->runtime->buffer_size;
}
/* FIXME: this routine isn't consistent, in one test we use
* cumulative values and in the other byte offsets. Do we
* really need the byte offsets if the cumulative values have
* been updated? In the PCM interface app_ptr and hw_ptr are
* already cumulative */
avail_calc = stream->runtime->buffer_size -
(stream->runtime->app_pointer - stream->runtime->hw_pointer);
pr_debug("calc avail as %ld, app_ptr %lld, hw+ptr %lld\n", avail_calc,
stream->runtime->app_pointer,
stream->runtime->hw_pointer);
if (avail_calc >= stream->runtime->buffer_size)
avail_calc -= stream->runtime->buffer_size;
pr_debug("ret avail as %ld\n", avail_calc);
avail->avail = avail_calc;
return avail_calc;
}
| 0 |
Chrome | e3aa8a56706c4abe208934d5c294f7b594b8b693 | NOT_APPLICABLE | NOT_APPLICABLE | base::DictionaryValue DeviceInfoToDictValue(
const device::mojom::UsbDeviceInfo& device_info) {
base::DictionaryValue device_dict;
device_dict.SetKey(kDeviceNameKey,
device_info.product_name
? base::Value(*device_info.product_name)
: base::Value(""));
if (!CanStorePersistentEntry(device_info)) {
device_dict.SetKey(kGuidKey, base::Value(device_info.guid));
return device_dict;
}
device_dict.SetKey(kVendorIdKey, base::Value(device_info.vendor_id));
device_dict.SetKey(kProductIdKey, base::Value(device_info.product_id));
device_dict.SetKey(kSerialNumberKey,
device_info.serial_number
? base::Value(*device_info.serial_number)
: base::Value(""));
return device_dict;
}
| 0 |
libgadu | 77fdc9351bf5c1913c7fc518f8a0c0c87ab3860f | NOT_APPLICABLE | NOT_APPLICABLE | static gg_action_t gg_handle_resolve_sync(struct gg_session *sess, struct gg_event *e, enum gg_state_t next_state, enum gg_state_t alt_state, enum gg_state_t alt2_state)
{
struct in_addr addr;
addr.s_addr = inet_addr(sess->resolver_host);
if (addr.s_addr == INADDR_NONE) {
struct in_addr *addr_list = NULL;
unsigned int addr_count;
if (gg_gethostbyname_real(sess->resolver_host, &addr_list, &addr_count, 0) == -1) {
gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() host %s not found\n", sess->resolver_host);
e->event.failure = GG_FAILURE_RESOLVING;
free(addr_list);
return GG_ACTION_FAIL;
}
sess->resolver_result = addr_list;
sess->resolver_count = addr_count;
sess->resolver_index = 0;
} else {
sess->resolver_result = malloc(sizeof(struct in_addr));
if (sess->resolver_result == NULL) {
gg_debug_session(sess, GG_DEBUG_MISC, "// gg_watch_fd() out of memory\n");
return GG_ACTION_FAIL;
}
sess->resolver_result[0].s_addr = addr.s_addr;
sess->resolver_count = 1;
sess->resolver_index = 0;
}
sess->state = next_state;
return GG_ACTION_NEXT;
} | 0 |
Chrome | ca8cc70b2de822b939f87effc7c2b83bac280a44 | NOT_APPLICABLE | NOT_APPLICABLE | int SocketStream::DoWriteTunnelHeadersComplete(int result) {
DCHECK_EQ(kTunnelProxy, proxy_mode_);
if (result < 0) {
next_state_ = STATE_CLOSE;
return result;
}
tunnel_request_headers_bytes_sent_ += result;
if (tunnel_request_headers_bytes_sent_ <
tunnel_request_headers_->headers_.size()) {
next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN;
} else {
tunnel_request_headers_bytes_sent_ = 0;
next_state_ = STATE_READ_TUNNEL_HEADERS;
}
return OK;
}
| 0 |
linux | 27d461333459d282ffa4a2bdb6b215a59d493a8f | NOT_APPLICABLE | NOT_APPLICABLE | u32 i40e_get_current_fd_count(struct i40e_pf *pf)
{
u32 val, fcnt_prog;
val = rd32(&pf->hw, I40E_PFQF_FDSTAT);
fcnt_prog = (val & I40E_PFQF_FDSTAT_GUARANT_CNT_MASK) +
((val & I40E_PFQF_FDSTAT_BEST_CNT_MASK) >>
I40E_PFQF_FDSTAT_BEST_CNT_SHIFT);
return fcnt_prog;
} | 0 |
Chrome | de485eb849be99305925de2257da3b85325df2fd | NOT_APPLICABLE | NOT_APPLICABLE | void Shell::OnModalWindowRemoved(aura::Window* removed) {
RootWindowControllerList controllers = GetAllRootWindowControllers();
bool activated = false;
for (RootWindowControllerList::iterator iter = controllers.begin();
iter != controllers.end() && !activated; ++iter) {
activated = (*iter)->GetSystemModalLayoutManager(removed)->
ActivateNextModalWindow();
}
if (!activated) {
RemovePreTargetHandler(modality_filter_.get());
modality_filter_.reset();
for (RootWindowControllerList::iterator iter = controllers.begin();
iter != controllers.end(); ++iter)
(*iter)->GetSystemModalLayoutManager(removed)->DestroyModalBackground();
}
}
| 0 |
linux | 704620afc70cf47abb9d6a1a57f3825d2bca49cf | NOT_APPLICABLE | NOT_APPLICABLE | static int descriptors_changed(struct usb_device *udev,
struct usb_device_descriptor *old_device_descriptor,
struct usb_host_bos *old_bos)
{
int changed = 0;
unsigned index;
unsigned serial_len = 0;
unsigned len;
unsigned old_length;
int length;
char *buf;
if (memcmp(&udev->descriptor, old_device_descriptor,
sizeof(*old_device_descriptor)) != 0)
return 1;
if ((old_bos && !udev->bos) || (!old_bos && udev->bos))
return 1;
if (udev->bos) {
len = le16_to_cpu(udev->bos->desc->wTotalLength);
if (len != le16_to_cpu(old_bos->desc->wTotalLength))
return 1;
if (memcmp(udev->bos->desc, old_bos->desc, len))
return 1;
}
/* Since the idVendor, idProduct, and bcdDevice values in the
* device descriptor haven't changed, we will assume the
* Manufacturer and Product strings haven't changed either.
* But the SerialNumber string could be different (e.g., a
* different flash card of the same brand).
*/
if (udev->serial)
serial_len = strlen(udev->serial) + 1;
len = serial_len;
for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
len = max(len, old_length);
}
buf = kmalloc(len, GFP_NOIO);
if (!buf)
/* assume the worst */
return 1;
for (index = 0; index < udev->descriptor.bNumConfigurations; index++) {
old_length = le16_to_cpu(udev->config[index].desc.wTotalLength);
length = usb_get_descriptor(udev, USB_DT_CONFIG, index, buf,
old_length);
if (length != old_length) {
dev_dbg(&udev->dev, "config index %d, error %d\n",
index, length);
changed = 1;
break;
}
if (memcmp(buf, udev->rawdescriptors[index], old_length)
!= 0) {
dev_dbg(&udev->dev, "config index %d changed (#%d)\n",
index,
((struct usb_config_descriptor *) buf)->
bConfigurationValue);
changed = 1;
break;
}
}
if (!changed && serial_len) {
length = usb_string(udev, udev->descriptor.iSerialNumber,
buf, serial_len);
if (length + 1 != serial_len) {
dev_dbg(&udev->dev, "serial string error %d\n",
length);
changed = 1;
} else if (memcmp(buf, udev->serial, length) != 0) {
dev_dbg(&udev->dev, "serial string changed\n");
changed = 1;
}
}
kfree(buf);
return changed;
}
| 0 |
libvpx | 45daecb4f73a47ab3236a29a3a48c52324cbf19a | NOT_APPLICABLE | NOT_APPLICABLE | static void yv12_extend_frame_left_right_c(YV12_BUFFER_CONFIG *ybf,
unsigned char *y_src,
unsigned char *u_src,
unsigned char *v_src) {
int i;
unsigned char *src_ptr1, *src_ptr2;
unsigned char *dest_ptr1, *dest_ptr2;
unsigned int Border;
int plane_stride;
int plane_height;
int plane_width;
/***********/
/* Y Plane */
/***********/
Border = ybf->border;
plane_stride = ybf->y_stride;
plane_height = 16;
plane_width = ybf->y_width;
/* copy the left and right most columns out */
src_ptr1 = y_src;
src_ptr2 = src_ptr1 + plane_width - 1;
dest_ptr1 = src_ptr1 - Border;
dest_ptr2 = src_ptr2 + 1;
for (i = 0; i < plane_height; ++i) {
memset(dest_ptr1, src_ptr1[0], Border);
memset(dest_ptr2, src_ptr2[0], Border);
src_ptr1 += plane_stride;
src_ptr2 += plane_stride;
dest_ptr1 += plane_stride;
dest_ptr2 += plane_stride;
}
/***********/
/* U Plane */
/***********/
plane_stride = ybf->uv_stride;
plane_height = 8;
plane_width = ybf->uv_width;
Border /= 2;
/* copy the left and right most columns out */
src_ptr1 = u_src;
src_ptr2 = src_ptr1 + plane_width - 1;
dest_ptr1 = src_ptr1 - Border;
dest_ptr2 = src_ptr2 + 1;
for (i = 0; i < plane_height; ++i) {
memset(dest_ptr1, src_ptr1[0], Border);
memset(dest_ptr2, src_ptr2[0], Border);
src_ptr1 += plane_stride;
src_ptr2 += plane_stride;
dest_ptr1 += plane_stride;
dest_ptr2 += plane_stride;
}
/***********/
/* V Plane */
/***********/
/* copy the left and right most columns out */
src_ptr1 = v_src;
src_ptr2 = src_ptr1 + plane_width - 1;
dest_ptr1 = src_ptr1 - Border;
dest_ptr2 = src_ptr2 + 1;
for (i = 0; i < plane_height; ++i) {
memset(dest_ptr1, src_ptr1[0], Border);
memset(dest_ptr2, src_ptr2[0], Border);
src_ptr1 += plane_stride;
src_ptr2 += plane_stride;
dest_ptr1 += plane_stride;
dest_ptr2 += plane_stride;
}
} | 0 |
tensorflow | c2b31ff2d3151acb230edc3f5b1832d2c713a9e0 | NOT_APPLICABLE | NOT_APPLICABLE | string SummarizeArgs(const protobuf::RepeatedPtrField<OpDef::ArgDef>& args) {
string ret;
for (const OpDef::ArgDef& arg : args) {
if (!ret.empty()) strings::StrAppend(&ret, ", ");
strings::StrAppend(&ret, arg.name(), ":");
if (arg.is_ref()) strings::StrAppend(&ret, "Ref(");
if (!arg.number_attr().empty()) {
strings::StrAppend(&ret, arg.number_attr(), "*");
}
if (arg.type() != DT_INVALID) {
strings::StrAppend(&ret, DataTypeString(arg.type()));
} else {
strings::StrAppend(&ret, arg.type_attr());
}
if (arg.is_ref()) strings::StrAppend(&ret, ")");
}
return ret;
} | 0 |
weechat | 9904cb6d2eb40f679d8ff6557c22d53a3e3dc75a | NOT_APPLICABLE | NOT_APPLICABLE | IRC_PROTOCOL_CALLBACK(353)
{
char *pos_channel, *pos_nick, *pos_nick_orig, *pos_host, *nickname;
char *prefixes, *str_nicks, *color;
int args, i, length;
struct t_irc_channel *ptr_channel;
IRC_PROTOCOL_MIN_ARGS(5);
if (irc_channel_is_channel (server, argv[3]))
{
pos_channel = argv[3];
args = 4;
}
else
{
pos_channel = argv[4];
args = 5;
}
IRC_PROTOCOL_MIN_ARGS(args + 1);
ptr_channel = irc_channel_search (server, pos_channel);
str_nicks = NULL;
/*
* for a channel without buffer, prepare a string that will be built
* with nicks and colors (argc - args is the number of nicks)
*/
if (!ptr_channel)
{
/*
* prefix color (16) + nick color (16) + reset color (16) = 48 bytes
* added for each nick
*/
length = strlen (argv_eol[args]) + ((argc - args) * (16 + 16 + 16)) + 1;
str_nicks = malloc (length);
if (str_nicks)
str_nicks[0] = '\0';
}
for (i = args; i < argc; i++)
{
pos_nick = (argv[i][0] == ':') ? argv[i] + 1 : argv[i];
pos_nick_orig = pos_nick;
/* skip and save prefix(es) */
while (pos_nick[0]
&& (irc_server_get_prefix_char_index (server, pos_nick[0]) >= 0))
{
pos_nick++;
}
prefixes = (pos_nick > pos_nick_orig) ?
weechat_strndup (pos_nick_orig, pos_nick - pos_nick_orig) : NULL;
/* extract nick from host */
pos_host = strchr (pos_nick, '!');
if (pos_host)
{
nickname = weechat_strndup (pos_nick, pos_host - pos_nick);
pos_host++;
}
else
nickname = strdup (pos_nick);
/* add or update nick on channel */
if (nickname)
{
if (ptr_channel && ptr_channel->nicks)
{
if (!irc_nick_new (server, ptr_channel, nickname, pos_host,
prefixes, 0, NULL, NULL))
{
weechat_printf (
server->buffer,
_("%s%s: cannot create nick \"%s\" for channel \"%s\""),
weechat_prefix ("error"), IRC_PLUGIN_NAME, nickname,
ptr_channel->name);
}
}
else if (!ptr_channel && str_nicks)
{
if (str_nicks[0])
{
strcat (str_nicks, IRC_COLOR_RESET);
strcat (str_nicks, " ");
}
if (prefixes)
{
strcat (str_nicks,
weechat_color (
irc_nick_get_prefix_color_name (server,
prefixes[0])));
strcat (str_nicks, prefixes);
}
if (weechat_config_boolean (irc_config_look_color_nicks_in_names))
{
if (irc_server_strcasecmp (server, nickname, server->nick) == 0)
strcat (str_nicks, IRC_COLOR_CHAT_NICK_SELF);
else
{
color = irc_nick_find_color (nickname);
strcat (str_nicks, color);
if (color)
free (color);
}
}
else
strcat (str_nicks, IRC_COLOR_RESET);
strcat (str_nicks, nickname);
}
free (nickname);
}
if (prefixes)
free (prefixes);
}
if (!ptr_channel)
{
weechat_printf_date_tags (
irc_msgbuffer_get_target_buffer (
server, NULL, command, "names", NULL),
date,
irc_protocol_tags (command, "irc_numeric", NULL, NULL),
_("%sNicks %s%s%s: %s[%s%s%s]"),
weechat_prefix ("network"),
IRC_COLOR_CHAT_CHANNEL,
pos_channel,
IRC_COLOR_RESET,
IRC_COLOR_CHAT_DELIMITERS,
IRC_COLOR_RESET,
(str_nicks) ? str_nicks : "",
IRC_COLOR_CHAT_DELIMITERS);
}
if (str_nicks)
free (str_nicks);
return WEECHAT_RC_OK;
} | 0 |
linux | 3b1c5a5307fb5277f395efdcf330c064d79df07d | NOT_APPLICABLE | NOT_APPLICABLE | static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
{
struct cfg80211_registered_device *rdev = info->user_ptr[0];
struct net_device *dev = info->user_ptr[1];
u8 *mac_addr = NULL;
if (info->attrs[NL80211_ATTR_MAC])
mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
return -EINVAL;
if (!rdev->ops->del_station)
return -EOPNOTSUPP;
return rdev_del_station(rdev, dev, mac_addr);
} | 0 |
openssh-portable | 4f9f42a9bb6a6aa8f6100d873dc6344f2f9994de | NOT_APPLICABLE | NOT_APPLICABLE | get_challenge(Authctxt *authctxt)
{
char *challenge, *name, *info, **prompts;
u_int i, numprompts;
u_int *echo_on;
device = devices[0]; /* we always use the 1st device for protocol 1 */
if (device == NULL)
return NULL;
if ((authctxt->kbdintctxt = device->init_ctx(authctxt)) == NULL)
return NULL;
if (device->query(authctxt->kbdintctxt, &name, &info,
&numprompts, &prompts, &echo_on)) {
device->free_ctx(authctxt->kbdintctxt);
authctxt->kbdintctxt = NULL;
return NULL;
}
if (numprompts < 1)
fatal("get_challenge: numprompts < 1");
challenge = xstrdup(prompts[0]);
for (i = 0; i < numprompts; i++)
xfree(prompts[i]);
xfree(prompts);
xfree(name);
xfree(echo_on);
xfree(info);
return (challenge);
} | 0 |
linux | fda4e2e85589191b123d31cdc21fd33ee70f50fd | NOT_APPLICABLE | NOT_APPLICABLE | static int kvm_vm_ioctl_reinject(struct kvm *kvm,
struct kvm_reinject_control *control)
{
if (!kvm->arch.vpit)
return -ENXIO;
mutex_lock(&kvm->arch.vpit->pit_state.lock);
kvm->arch.vpit->pit_state.reinject = control->pit_reinject;
mutex_unlock(&kvm->arch.vpit->pit_state.lock);
return 0;
}
| 0 |
rpm | 8f4b3c3cab8922a2022b9e47c71f1ecf906077ef | NOT_APPLICABLE | NOT_APPLICABLE | indexEntry findEntry(Header h, rpmTagVal tag, rpm_tagtype_t type)
{
indexEntry entry;
struct indexEntry_s key;
if (h == NULL) return NULL;
headerSort(h);
key.info.tag = tag;
entry = bsearch(&key, h->index, h->indexUsed, sizeof(*h->index), indexCmp);
if (entry == NULL)
return NULL;
if (type == RPM_NULL_TYPE)
return entry;
/* look backwards */
while (entry->info.tag == tag && entry->info.type != type &&
entry > h->index) entry--;
if (entry->info.tag == tag && entry->info.type == type)
return entry;
return NULL;
} | 0 |
Chrome | c13e1da62b5f5f0e6fe8c1f769a5a28415415244 | NOT_APPLICABLE | NOT_APPLICABLE | void GLES2DecoderImpl::DoVertexAttrib3fv(GLuint index, const GLfloat* v) {
VertexAttribManager::VertexAttribInfo* info =
vertex_attrib_manager_.GetVertexAttribInfo(index);
if (!info) {
SetGLError(GL_INVALID_VALUE, "glVertexAttrib3fv: index out of range");
return;
}
VertexAttribManager::VertexAttribInfo::Vec4 value;
value.v[0] = v[0];
value.v[1] = v[1];
value.v[2] = v[2];
value.v[3] = 1.0f;
info->set_value(value);
glVertexAttrib3fv(index, v);
}
| 0 |
Chrome | 027429ee5abe6e2fb5e3b2b4542f0a6fe0dbc12d | NOT_APPLICABLE | NOT_APPLICABLE | bool BaseSessionService::RunTaskOnBackendThread(
const tracked_objects::Location& from_here,
const base::Closure& task) {
if (RunningInProduction()) {
return BrowserThread::PostTask(BrowserThread::FILE, from_here, task);
} else {
task.Run();
return true;
}
}
| 0 |
linux | 23adbe12ef7d3d4195e80800ab36b37bee28cd03 | NOT_APPLICABLE | NOT_APPLICABLE | xfs_getbmapx_format(void **ap, struct getbmapx *bmv, int *full)
{
struct getbmapx __user *base = *ap;
if (copy_to_user(base, bmv, sizeof(struct getbmapx)))
return XFS_ERROR(EFAULT);
*ap += sizeof(struct getbmapx);
return 0;
}
| 0 |
tcpdump | 1bc78d795cd5cad5525498658f414a11ea0a7e9c | NOT_APPLICABLE | NOT_APPLICABLE | radius_attrs_print(netdissect_options *ndo,
register const u_char *attr, u_int length)
{
register const struct radius_attr *rad_attr = (const struct radius_attr *)attr;
const char *attr_string;
while (length > 0)
{
if (length < 2)
goto trunc;
ND_TCHECK(*rad_attr);
if (rad_attr->type > 0 && rad_attr->type < TAM_SIZE(attr_type))
attr_string = attr_type[rad_attr->type].name;
else
attr_string = "Unknown";
if (rad_attr->len < 2)
{
ND_PRINT((ndo, "\n\t %s Attribute (%u), length: %u (bogus, must be >= 2)",
attr_string,
rad_attr->type,
rad_attr->len));
return;
}
if (rad_attr->len > length)
{
ND_PRINT((ndo, "\n\t %s Attribute (%u), length: %u (bogus, goes past end of packet)",
attr_string,
rad_attr->type,
rad_attr->len));
return;
}
ND_PRINT((ndo, "\n\t %s Attribute (%u), length: %u, Value: ",
attr_string,
rad_attr->type,
rad_attr->len));
if (rad_attr->type < TAM_SIZE(attr_type))
{
if (rad_attr->len > 2)
{
if ( attr_type[rad_attr->type].print_func )
(*attr_type[rad_attr->type].print_func)(
ndo, ((const u_char *)(rad_attr+1)),
rad_attr->len - 2, rad_attr->type);
}
}
/* do we also want to see a hex dump ? */
if (ndo->ndo_vflag> 1)
print_unknown_data(ndo, (const u_char *)rad_attr+2, "\n\t ", (rad_attr->len)-2);
length-=(rad_attr->len);
rad_attr = (const struct radius_attr *)( ((const char *)(rad_attr))+rad_attr->len);
}
return;
trunc:
ND_PRINT((ndo, "%s", tstr));
}
| 0 |
linux | 5b9fbeb75b6a98955f628e205ac26689bcb1383e | NOT_APPLICABLE | NOT_APPLICABLE | static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env,
struct bpf_insn *insn,
const struct bpf_reg_state *ptr_reg,
const struct bpf_reg_state *off_reg)
{
struct bpf_verifier_state *vstate = env->cur_state;
struct bpf_func_state *state = vstate->frame[vstate->curframe];
struct bpf_reg_state *regs = state->regs, *dst_reg;
bool known = tnum_is_const(off_reg->var_off);
s64 smin_val = off_reg->smin_value, smax_val = off_reg->smax_value,
smin_ptr = ptr_reg->smin_value, smax_ptr = ptr_reg->smax_value;
u64 umin_val = off_reg->umin_value, umax_val = off_reg->umax_value,
umin_ptr = ptr_reg->umin_value, umax_ptr = ptr_reg->umax_value;
u32 dst = insn->dst_reg, src = insn->src_reg;
u8 opcode = BPF_OP(insn->code);
int ret;
dst_reg = ®s[dst];
if ((known && (smin_val != smax_val || umin_val != umax_val)) ||
smin_val > smax_val || umin_val > umax_val) {
/* Taint dst register if offset had invalid bounds derived from
* e.g. dead branches.
*/
__mark_reg_unknown(env, dst_reg);
return 0;
}
if (BPF_CLASS(insn->code) != BPF_ALU64) {
/* 32-bit ALU ops on pointers produce (meaningless) scalars */
if (opcode == BPF_SUB && env->allow_ptr_leaks) {
__mark_reg_unknown(env, dst_reg);
return 0;
}
verbose(env,
"R%d 32-bit pointer arithmetic prohibited\n",
dst);
return -EACCES;
}
switch (ptr_reg->type) {
case PTR_TO_MAP_VALUE_OR_NULL:
verbose(env, "R%d pointer arithmetic on %s prohibited, null-check it first\n",
dst, reg_type_str[ptr_reg->type]);
return -EACCES;
case CONST_PTR_TO_MAP:
case PTR_TO_PACKET_END:
case PTR_TO_SOCKET:
case PTR_TO_SOCKET_OR_NULL:
case PTR_TO_SOCK_COMMON:
case PTR_TO_SOCK_COMMON_OR_NULL:
case PTR_TO_TCP_SOCK:
case PTR_TO_TCP_SOCK_OR_NULL:
case PTR_TO_XDP_SOCK:
verbose(env, "R%d pointer arithmetic on %s prohibited\n",
dst, reg_type_str[ptr_reg->type]);
return -EACCES;
case PTR_TO_MAP_VALUE:
if (!env->allow_ptr_leaks && !known && (smin_val < 0) != (smax_val < 0)) {
verbose(env, "R%d has unknown scalar with mixed signed bounds, pointer arithmetic with it prohibited for !root\n",
off_reg == dst_reg ? dst : src);
return -EACCES;
}
fallthrough;
default:
break;
}
/* In case of 'scalar += pointer', dst_reg inherits pointer type and id.
* The id may be overwritten later if we create a new variable offset.
*/
dst_reg->type = ptr_reg->type;
dst_reg->id = ptr_reg->id;
if (!check_reg_sane_offset(env, off_reg, ptr_reg->type) ||
!check_reg_sane_offset(env, ptr_reg, ptr_reg->type))
return -EINVAL;
/* pointer types do not carry 32-bit bounds at the moment. */
__mark_reg32_unbounded(dst_reg);
switch (opcode) {
case BPF_ADD:
ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0);
if (ret < 0) {
verbose(env, "R%d tried to add from different maps or paths\n", dst);
return ret;
}
/* We can take a fixed offset as long as it doesn't overflow
* the s32 'off' field
*/
if (known && (ptr_reg->off + smin_val ==
(s64)(s32)(ptr_reg->off + smin_val))) {
/* pointer += K. Accumulate it into fixed offset */
dst_reg->smin_value = smin_ptr;
dst_reg->smax_value = smax_ptr;
dst_reg->umin_value = umin_ptr;
dst_reg->umax_value = umax_ptr;
dst_reg->var_off = ptr_reg->var_off;
dst_reg->off = ptr_reg->off + smin_val;
dst_reg->raw = ptr_reg->raw;
break;
}
/* A new variable offset is created. Note that off_reg->off
* == 0, since it's a scalar.
* dst_reg gets the pointer type and since some positive
* integer value was added to the pointer, give it a new 'id'
* if it's a PTR_TO_PACKET.
* this creates a new 'base' pointer, off_reg (variable) gets
* added into the variable offset, and we copy the fixed offset
* from ptr_reg.
*/
if (signed_add_overflows(smin_ptr, smin_val) ||
signed_add_overflows(smax_ptr, smax_val)) {
dst_reg->smin_value = S64_MIN;
dst_reg->smax_value = S64_MAX;
} else {
dst_reg->smin_value = smin_ptr + smin_val;
dst_reg->smax_value = smax_ptr + smax_val;
}
if (umin_ptr + umin_val < umin_ptr ||
umax_ptr + umax_val < umax_ptr) {
dst_reg->umin_value = 0;
dst_reg->umax_value = U64_MAX;
} else {
dst_reg->umin_value = umin_ptr + umin_val;
dst_reg->umax_value = umax_ptr + umax_val;
}
dst_reg->var_off = tnum_add(ptr_reg->var_off, off_reg->var_off);
dst_reg->off = ptr_reg->off;
dst_reg->raw = ptr_reg->raw;
if (reg_is_pkt_pointer(ptr_reg)) {
dst_reg->id = ++env->id_gen;
/* something was added to pkt_ptr, set range to zero */
dst_reg->raw = 0;
}
break;
case BPF_SUB:
ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0);
if (ret < 0) {
verbose(env, "R%d tried to sub from different maps or paths\n", dst);
return ret;
}
if (dst_reg == off_reg) {
/* scalar -= pointer. Creates an unknown scalar */
verbose(env, "R%d tried to subtract pointer from scalar\n",
dst);
return -EACCES;
}
/* We don't allow subtraction from FP, because (according to
* test_verifier.c test "invalid fp arithmetic", JITs might not
* be able to deal with it.
*/
if (ptr_reg->type == PTR_TO_STACK) {
verbose(env, "R%d subtraction from stack pointer prohibited\n",
dst);
return -EACCES;
}
if (known && (ptr_reg->off - smin_val ==
(s64)(s32)(ptr_reg->off - smin_val))) {
/* pointer -= K. Subtract it from fixed offset */
dst_reg->smin_value = smin_ptr;
dst_reg->smax_value = smax_ptr;
dst_reg->umin_value = umin_ptr;
dst_reg->umax_value = umax_ptr;
dst_reg->var_off = ptr_reg->var_off;
dst_reg->id = ptr_reg->id;
dst_reg->off = ptr_reg->off - smin_val;
dst_reg->raw = ptr_reg->raw;
break;
}
/* A new variable offset is created. If the subtrahend is known
* nonnegative, then any reg->range we had before is still good.
*/
if (signed_sub_overflows(smin_ptr, smax_val) ||
signed_sub_overflows(smax_ptr, smin_val)) {
/* Overflow possible, we know nothing */
dst_reg->smin_value = S64_MIN;
dst_reg->smax_value = S64_MAX;
} else {
dst_reg->smin_value = smin_ptr - smax_val;
dst_reg->smax_value = smax_ptr - smin_val;
}
if (umin_ptr < umax_val) {
/* Overflow possible, we know nothing */
dst_reg->umin_value = 0;
dst_reg->umax_value = U64_MAX;
} else {
/* Cannot overflow (as long as bounds are consistent) */
dst_reg->umin_value = umin_ptr - umax_val;
dst_reg->umax_value = umax_ptr - umin_val;
}
dst_reg->var_off = tnum_sub(ptr_reg->var_off, off_reg->var_off);
dst_reg->off = ptr_reg->off;
dst_reg->raw = ptr_reg->raw;
if (reg_is_pkt_pointer(ptr_reg)) {
dst_reg->id = ++env->id_gen;
/* something was added to pkt_ptr, set range to zero */
if (smin_val < 0)
dst_reg->raw = 0;
}
break;
case BPF_AND:
case BPF_OR:
case BPF_XOR:
/* bitwise ops on pointers are troublesome, prohibit. */
verbose(env, "R%d bitwise operator %s on pointer prohibited\n",
dst, bpf_alu_string[opcode >> 4]);
return -EACCES;
default:
/* other operators (e.g. MUL,LSH) produce non-pointer results */
verbose(env, "R%d pointer arithmetic with %s operator prohibited\n",
dst, bpf_alu_string[opcode >> 4]);
return -EACCES;
}
if (!check_reg_sane_offset(env, dst_reg, ptr_reg->type))
return -EINVAL;
__update_reg_bounds(dst_reg);
__reg_deduce_bounds(dst_reg);
__reg_bound_offset(dst_reg);
/* For unprivileged we require that resulting offset must be in bounds
* in order to be able to sanitize access later on.
*/
if (!env->bypass_spec_v1) {
if (dst_reg->type == PTR_TO_MAP_VALUE &&
check_map_access(env, dst, dst_reg->off, 1, false)) {
verbose(env, "R%d pointer arithmetic of map value goes out of range, "
"prohibited for !root\n", dst);
return -EACCES;
} else if (dst_reg->type == PTR_TO_STACK &&
check_stack_access(env, dst_reg, dst_reg->off +
dst_reg->var_off.value, 1)) {
verbose(env, "R%d stack pointer arithmetic goes out of range, "
"prohibited for !root\n", dst);
return -EACCES;
}
}
return 0;
} | 0 |
Chrome | 24bbdc5f95f80a7700e232a272a6ea1811c0dcaf | NOT_APPLICABLE | NOT_APPLICABLE | int ResponseWriter::Write(net::IOBuffer* buffer,
int num_bytes,
const net::CompletionCallback& callback) {
std::string chunk = std::string(buffer->data(), num_bytes);
bool encoded = false;
if (!base::IsStringUTF8(chunk)) {
encoded = true;
base::Base64Encode(chunk, &chunk);
}
base::Value* id = new base::Value(stream_id_);
base::Value* chunkValue = new base::Value(chunk);
base::Value* encodedValue = new base::Value(encoded);
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::BindOnce(&DevToolsUIBindings::CallClientFunction, bindings_,
"DevToolsAPI.streamWrite", base::Owned(id),
base::Owned(chunkValue), base::Owned(encodedValue)));
return num_bytes;
}
| 0 |
Chrome | a9cbaa7a40e2b2723cfc2f266c42f4980038a949 | CVE-2018-18352 | CWE-732 | void UrlData::MergeFrom(const scoped_refptr<UrlData>& other) {
if (ValidateDataOrigin(other->data_origin_)) {
DCHECK(thread_checker_.CalledOnValidThread());
valid_until_ = std::max(valid_until_, other->valid_until_);
set_length(other->length_);
cacheable_ |= other->cacheable_;
range_supported_ |= other->range_supported_;
if (last_modified_.is_null()) {
last_modified_ = other->last_modified_;
}
bytes_read_from_cache_ += other->bytes_read_from_cache_;
set_has_opaque_data(other->has_opaque_data_);
multibuffer()->MergeFrom(other->multibuffer());
}
}
| 1 |
mod_auth_openidc | 21e3728a825c41ab41efa75e664108051bb9665e | NOT_APPLICABLE | NOT_APPLICABLE | static int oidc_check_max_session_duration(request_rec *r, oidc_cfg *cfg,
oidc_session_t *session) {
const char *s_session_expires = NULL;
apr_time_t session_expires;
/* get the session expiry from the session data */
oidc_session_get(r, session, OIDC_SESSION_EXPIRES_SESSION_KEY,
&s_session_expires);
/* convert the string to a timestamp */
sscanf(s_session_expires, "%" APR_TIME_T_FMT, &session_expires);
/* check the expire timestamp against the current time */
if (apr_time_now() > session_expires) {
oidc_warn(r, "maximum session duration exceeded for user: %s",
session->remote_user);
oidc_session_kill(r, session);
return oidc_handle_unauthenticated_user(r, cfg);
}
/* log message about max session duration */
oidc_log_session_expires(r, "session max lifetime", session_expires);
return OK;
}
| 0 |
openssh-portable | d4697fe9a28dab7255c60433e4dd23cf7fce8a8b | NOT_APPLICABLE | NOT_APPLICABLE | mm_key_verify(Key *key, u_char *sig, u_int siglen, u_char *data, u_int datalen)
{
Buffer m;
u_char *blob;
u_int len;
int verified = 0;
debug3("%s entering", __func__);
/* Convert the key to a blob and the pass it over */
if (!key_to_blob(key, &blob, &len))
return (0);
buffer_init(&m);
buffer_put_string(&m, blob, len);
buffer_put_string(&m, sig, siglen);
buffer_put_string(&m, data, datalen);
free(blob);
mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_KEYVERIFY, &m);
debug3("%s: waiting for MONITOR_ANS_KEYVERIFY", __func__);
mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_KEYVERIFY, &m);
verified = buffer_get_int(&m);
buffer_free(&m);
return (verified);
}
| 0 |
linux | 2f36db71009304b3f0b95afacd8eba1f9f046b87 | NOT_APPLICABLE | NOT_APPLICABLE | void ecryptfs_destroy_kthread(void)
{
struct ecryptfs_open_req *req, *tmp;
mutex_lock(&ecryptfs_kthread_ctl.mux);
ecryptfs_kthread_ctl.flags |= ECRYPTFS_KTHREAD_ZOMBIE;
list_for_each_entry_safe(req, tmp, &ecryptfs_kthread_ctl.req_list,
kthread_ctl_list) {
list_del(&req->kthread_ctl_list);
*req->lower_file = ERR_PTR(-EIO);
complete(&req->done);
}
mutex_unlock(&ecryptfs_kthread_ctl.mux);
kthread_stop(ecryptfs_kthread);
wake_up(&ecryptfs_kthread_ctl.wait);
} | 0 |
poppler | a9b8ab4657dec65b8b86c225d12c533ad7e984e2 | NOT_APPLICABLE | NOT_APPLICABLE | void Splash::dumpXPath(SplashXPath *path) {
int i;
for (i = 0; i < path->length; ++i) {
printf(" %4d: x0=%8.2f y0=%8.2f x1=%8.2f y1=%8.2f %s%s%s\n",
i, (double)path->segs[i].x0, (double)path->segs[i].y0,
(double)path->segs[i].x1, (double)path->segs[i].y1,
(path->segs[i].flags & splashXPathHoriz) ? "H" : " ",
(path->segs[i].flags & splashXPathVert) ? "V" : " ",
(path->segs[i].flags & splashXPathFlip) ? "P" : " ");
}
}
| 0 |
spice-common | 762e0abae36033ccde658fd52d3235887b60862d | NOT_APPLICABLE | NOT_APPLICABLE | static void golomb_coding_slow(const QuicFamily *family, const BYTE n, const unsigned int l,
unsigned int * const codeword,
unsigned int * const codewordlen)
{
if (n < family->nGRcodewords[l]) {
(*codeword) = bitat(l) | (n & bppmask[l]);
(*codewordlen) = (n >> l) + l + 1;
} else {
(*codeword) = n - family->nGRcodewords[l];
(*codewordlen) = family->notGRcwlen[l];
}
} | 0 |
linux | 9c52057c698fb96f8f07e7a4bcf4801a092bda89 | NOT_APPLICABLE | NOT_APPLICABLE | static int btrfs_getattr(struct vfsmount *mnt,
struct dentry *dentry, struct kstat *stat)
{
struct inode *inode = dentry->d_inode;
u32 blocksize = inode->i_sb->s_blocksize;
generic_fillattr(inode, stat);
stat->dev = BTRFS_I(inode)->root->anon_dev;
stat->blksize = PAGE_CACHE_SIZE;
stat->blocks = (ALIGN(inode_get_bytes(inode), blocksize) +
ALIGN(BTRFS_I(inode)->delalloc_bytes, blocksize)) >> 9;
return 0;
}
| 0 |
linux-fbdev | bd771cf5c4254511cc4abb88f3dab3bd58bdf8e8 | NOT_APPLICABLE | NOT_APPLICABLE | static void smtcfb_setmode(struct smtcfb_info *sfb)
{
switch (sfb->fb->var.bits_per_pixel) {
case 32:
sfb->fb->fix.visual = FB_VISUAL_TRUECOLOR;
sfb->fb->fix.line_length = sfb->fb->var.xres * 4;
sfb->fb->var.red.length = 8;
sfb->fb->var.green.length = 8;
sfb->fb->var.blue.length = 8;
sfb->fb->var.red.offset = 16;
sfb->fb->var.green.offset = 8;
sfb->fb->var.blue.offset = 0;
break;
case 24:
sfb->fb->fix.visual = FB_VISUAL_TRUECOLOR;
sfb->fb->fix.line_length = sfb->fb->var.xres * 3;
sfb->fb->var.red.length = 8;
sfb->fb->var.green.length = 8;
sfb->fb->var.blue.length = 8;
sfb->fb->var.red.offset = 16;
sfb->fb->var.green.offset = 8;
sfb->fb->var.blue.offset = 0;
break;
case 8:
sfb->fb->fix.visual = FB_VISUAL_PSEUDOCOLOR;
sfb->fb->fix.line_length = sfb->fb->var.xres;
sfb->fb->var.red.length = 3;
sfb->fb->var.green.length = 3;
sfb->fb->var.blue.length = 2;
sfb->fb->var.red.offset = 5;
sfb->fb->var.green.offset = 2;
sfb->fb->var.blue.offset = 0;
break;
case 16:
default:
sfb->fb->fix.visual = FB_VISUAL_TRUECOLOR;
sfb->fb->fix.line_length = sfb->fb->var.xres * 2;
sfb->fb->var.red.length = 5;
sfb->fb->var.green.length = 6;
sfb->fb->var.blue.length = 5;
sfb->fb->var.red.offset = 11;
sfb->fb->var.green.offset = 5;
sfb->fb->var.blue.offset = 0;
break;
}
sfb->width = sfb->fb->var.xres;
sfb->height = sfb->fb->var.yres;
sfb->hz = 60;
smtc_set_timing(sfb);
} | 0 |
libssh | b36272eac1b36982598c10de7af0a501582de07a | NOT_APPLICABLE | NOT_APPLICABLE | SHA256CTX sha256_init(void)
{
int rc;
SHA256CTX c = EVP_MD_CTX_create();
if (c == NULL) {
return NULL;
}
EVP_MD_CTX_init(c);
rc = EVP_DigestInit_ex(c, EVP_sha256(), NULL);
if (rc == 0) {
EVP_MD_CTX_destroy(c);
c = NULL;
}
return c;
} | 0 |
poppler | e853106b58d6b4b0467dbd6436c9bb1cfbd372cf | NOT_APPLICABLE | NOT_APPLICABLE | GBool GfxResources::lookupXObject(char *name, Object *obj) {
GfxResources *resPtr;
for (resPtr = this; resPtr; resPtr = resPtr->next) {
if (resPtr->xObjDict.isDict()) {
if (!resPtr->xObjDict.dictLookup(name, obj)->isNull())
return gTrue;
obj->free();
}
}
error(-1, "XObject '%s' is unknown", name);
return gFalse;
}
| 0 |
Chrome | 4cf106cdb83dd6b35d3b26d06cc67d1d2d99041e | NOT_APPLICABLE | NOT_APPLICABLE | png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{
png_size_t truelen;
png_byte buf[6];
png_debug(1, "in png_handle_bKGD");
if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before bKGD");
else if (png_ptr->mode & PNG_HAVE_IDAT)
{
png_warning(png_ptr, "Invalid bKGD after IDAT");
png_crc_finish(png_ptr, length);
return;
}
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE))
{
png_warning(png_ptr, "Missing PLTE before bKGD");
png_crc_finish(png_ptr, length);
return;
}
else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD))
{
png_warning(png_ptr, "Duplicate bKGD chunk");
png_crc_finish(png_ptr, length);
return;
}
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
truelen = 1;
else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR)
truelen = 6;
else
truelen = 2;
if (length != truelen)
{
png_warning(png_ptr, "Incorrect bKGD chunk length");
png_crc_finish(png_ptr, length);
return;
}
png_crc_read(png_ptr, buf, truelen);
if (png_crc_finish(png_ptr, 0))
return;
/* We convert the index value into RGB components so that we can allow
* arbitrary RGB values for background when we have transparency, and
* so it is easy to determine the RGB values of the background color
* from the info_ptr struct. */
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
{
png_ptr->background.index = buf[0];
if (info_ptr && info_ptr->num_palette)
{
if (buf[0] >= info_ptr->num_palette)
{
png_warning(png_ptr, "Incorrect bKGD chunk index value");
return;
}
png_ptr->background.red =
(png_uint_16)png_ptr->palette[buf[0]].red;
png_ptr->background.green =
(png_uint_16)png_ptr->palette[buf[0]].green;
png_ptr->background.blue =
(png_uint_16)png_ptr->palette[buf[0]].blue;
}
}
else if (!(png_ptr->color_type & PNG_COLOR_MASK_COLOR)) /* GRAY */
{
png_ptr->background.red =
png_ptr->background.green =
png_ptr->background.blue =
png_ptr->background.gray = png_get_uint_16(buf);
}
else
{
png_ptr->background.red = png_get_uint_16(buf);
png_ptr->background.green = png_get_uint_16(buf + 2);
png_ptr->background.blue = png_get_uint_16(buf + 4);
}
png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background));
}
| 0 |
Android | e68cbc3e9e66df4231e70efa3e9c41abc12aea20 | NOT_APPLICABLE | NOT_APPLICABLE | int32_t Parcel::readExceptionCode() const
{
int32_t exception_code = readAligned<int32_t>();
if (exception_code == EX_HAS_REPLY_HEADER) {
int32_t header_start = dataPosition();
int32_t header_size = readAligned<int32_t>();
setDataPosition(header_start + header_size);
return 0;
}
return exception_code;
}
| 0 |
vim | 409510c588b1eec1ae33511ae97a21eb8e110895 | NOT_APPLICABLE | NOT_APPLICABLE | last_csearch_forward(void)
{
return lastcdir == FORWARD;
} | 0 |
mod_auth_openidc | 03e6bfb446f4e3f27c003d30d6a433e5dd8e2b3d | NOT_APPLICABLE | NOT_APPLICABLE | static int oidc_handle_logout_backchannel(request_rec *r, oidc_cfg *cfg) {
oidc_debug(r, "enter");
const char *logout_token = NULL;
oidc_jwt_t *jwt = NULL;
oidc_jose_error_t err;
oidc_jwk_t *jwk = NULL;
oidc_provider_t *provider = NULL;
char *sid = NULL, *uuid = NULL;
oidc_session_t session;
int rc = HTTP_BAD_REQUEST;
apr_table_t *params = apr_table_make(r->pool, 8);
if (oidc_util_read_post_params(r, params, FALSE, NULL) == FALSE) {
oidc_error(r,
"could not read POST-ed parameters to the logout endpoint");
goto out;
}
logout_token = apr_table_get(params, OIDC_PROTO_LOGOUT_TOKEN);
if (logout_token == NULL) {
oidc_error(r,
"backchannel lggout endpoint was called but could not find a parameter named \"%s\"",
OIDC_PROTO_LOGOUT_TOKEN);
goto out;
}
// TODO: jwk symmetric key based on provider
if (oidc_jwt_parse(r->pool, logout_token, &jwt,
oidc_util_merge_symmetric_key(r->pool, cfg->private_keys, NULL),
&err) == FALSE) {
oidc_error(r, "oidc_jwt_parse failed: %s", oidc_jose_e2s(r->pool, err));
goto out;
}
if ((jwt->header.alg == NULL) || (strcmp(jwt->header.alg, "none") == 0)) {
oidc_error(r, "logout token is not signed");
goto out;
}
provider = oidc_get_provider_for_issuer(r, cfg, jwt->payload.iss, FALSE);
if (provider == NULL) {
oidc_error(r, "no provider found for issuer: %s", jwt->payload.iss);
goto out;
}
// TODO: destroy the JWK used for decryption
jwk = NULL;
if (oidc_util_create_symmetric_key(r, provider->client_secret, 0,
NULL, TRUE, &jwk) == FALSE)
return FALSE;
oidc_jwks_uri_t jwks_uri = { provider->jwks_uri,
provider->jwks_refresh_interval, provider->ssl_validate_server };
if (oidc_proto_jwt_verify(r, cfg, jwt, &jwks_uri,
oidc_util_merge_symmetric_key(r->pool, NULL, jwk),
provider->id_token_signed_response_alg) == FALSE) {
oidc_error(r, "id_token signature could not be validated, aborting");
goto out;
}
// oidc_proto_validate_idtoken would try and require a token binding cnf
// if the policy is set to "required", so don't use that here
if (oidc_proto_validate_jwt(r, jwt,
provider->validate_issuer ? provider->issuer : NULL, FALSE, FALSE,
provider->idtoken_iat_slack,
OIDC_TOKEN_BINDING_POLICY_DISABLED) == FALSE)
goto out;
/* verify the "aud" and "azp" values */
if (oidc_proto_validate_aud_and_azp(r, cfg, provider, &jwt->payload)
== FALSE)
goto out;
json_t *events = json_object_get(jwt->payload.value.json,
OIDC_CLAIM_EVENTS);
if (events == NULL) {
oidc_error(r, "\"%s\" claim could not be found in logout token",
OIDC_CLAIM_EVENTS);
goto out;
}
json_t *blogout = json_object_get(events, OIDC_EVENTS_BLOGOUT_KEY);
if (!json_is_object(blogout)) {
oidc_error(r, "\"%s\" object could not be found in \"%s\" claim",
OIDC_EVENTS_BLOGOUT_KEY, OIDC_CLAIM_EVENTS);
goto out;
}
char *nonce = NULL;
oidc_json_object_get_string(r->pool, jwt->payload.value.json,
OIDC_CLAIM_NONCE, &nonce, NULL);
if (nonce != NULL) {
oidc_error(r,
"rejecting logout request/token since it contains a \"%s\" claim",
OIDC_CLAIM_NONCE);
goto out;
}
char *jti = NULL;
oidc_json_object_get_string(r->pool, jwt->payload.value.json,
OIDC_CLAIM_JTI, &jti, NULL);
if (jti != NULL) {
char *replay = NULL;
oidc_cache_get_jti(r, jti, &replay);
if (replay != NULL) {
oidc_error(r,
"the \"%s\" value (%s) passed in logout token was found in the cache already; possible replay attack!?",
OIDC_CLAIM_JTI, jti);
goto out;
}
}
/* jti cache duration is the configured replay prevention window for token issuance plus 10 seconds for safety */
apr_time_t jti_cache_duration = apr_time_from_sec(
provider->idtoken_iat_slack * 2 + 10);
/* store it in the cache for the calculated duration */
oidc_cache_set_jti(r, jti, jti, apr_time_now() + jti_cache_duration);
oidc_json_object_get_string(r->pool, jwt->payload.value.json,
OIDC_CLAIM_EVENTS, &sid, NULL);
// TODO: by-spec we should cater for the fact that "sid" has been provided
// in the id_token returned in the authentication request, but "sub"
// is used in the logout token but that requires a 2nd entry in the
// cache and a separate session "sub" member, ugh; we'll just assume
// that is "sid" is specified in the id_token, the OP will actually use
// this for logout
// (and probably call us multiple times or the same sub if needed)
oidc_json_object_get_string(r->pool, jwt->payload.value.json,
OIDC_CLAIM_SID, &sid, NULL);
if (sid == NULL)
sid = jwt->payload.sub;
if (sid == NULL) {
oidc_error(r, "no \"sub\" and no \"sid\" claim found in logout token");
goto out;
}
// TODO: when dealing with sub instead of a true sid, we'll be killing all sessions for
// a specific user, across hosts that share the *same* cache backend
// if those hosts haven't been configured with a different OIDCCryptoPassphrase
// - perhaps that's even acceptable since non-memory caching is encrypted by default
// and memory-based caching doesn't suffer from this (different shm segments)?
// - it will result in 400 errors returned from backchannel logout calls to the other hosts...
sid = oidc_make_sid_iss_unique(r, sid, provider->issuer);
oidc_cache_get_sid(r, sid, &uuid);
if (uuid == NULL) {
// this may happen when we are the caller
oidc_warn(r,
"could not (or no longer) find a session based on sid/sub provided in logout token: %s",
sid);
r->user = "";
rc = OK;
goto out;
}
// revoke tokens if we can get a handle on those
if (cfg->session_type != OIDC_SESSION_TYPE_CLIENT_COOKIE) {
if (oidc_session_load_cache_by_uuid(r, cfg, uuid, &session) != FALSE)
if (oidc_session_extract(r, &session) != FALSE)
oidc_revoke_tokens(r, cfg, &session);
}
// clear the session cache
oidc_cache_set_sid(r, sid, NULL, 0);
oidc_cache_set_session(r, uuid, NULL, 0);
r->user = "";
rc = OK;
out:
if (jwk != NULL) {
oidc_jwk_destroy(jwk);
jwk = NULL;
}
if (jwt != NULL) {
oidc_jwt_destroy(jwt);
jwt = NULL;
}
oidc_util_hdr_err_out_add(r, OIDC_HTTP_HDR_CACHE_CONTROL,
"no-cache, no-store");
oidc_util_hdr_err_out_add(r, OIDC_HTTP_HDR_PRAGMA, "no-cache");
return rc;
} | 0 |
linux | 4aa7afb0ee20a97fbf0c5bab3df028d5fb85fdab | NOT_APPLICABLE | NOT_APPLICABLE | static void clean_up_interface_data(struct ipmi_smi *intf)
{
int i;
struct cmd_rcvr *rcvr, *rcvr2;
struct list_head list;
tasklet_kill(&intf->recv_tasklet);
free_smi_msg_list(&intf->waiting_rcv_msgs);
free_recv_msg_list(&intf->waiting_events);
/*
* Wholesale remove all the entries from the list in the
* interface and wait for RCU to know that none are in use.
*/
mutex_lock(&intf->cmd_rcvrs_mutex);
INIT_LIST_HEAD(&list);
list_splice_init_rcu(&intf->cmd_rcvrs, &list, synchronize_rcu);
mutex_unlock(&intf->cmd_rcvrs_mutex);
list_for_each_entry_safe(rcvr, rcvr2, &list, link)
kfree(rcvr);
for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) {
if ((intf->seq_table[i].inuse)
&& (intf->seq_table[i].recv_msg))
ipmi_free_recv_msg(intf->seq_table[i].recv_msg);
}
} | 0 |
Chrome | eea3300239f0b53e172a320eb8de59d0bea65f27 | NOT_APPLICABLE | NOT_APPLICABLE | DocumentOnLoadCompletedInMainFrame() {
devtools_bindings_->DocumentOnLoadCompletedInMainFrame();
}
| 0 |
linux | fd4d9c7d0c71866ec0c2825189ebd2ce35bd95b8 | NOT_APPLICABLE | NOT_APPLICABLE | int __kmem_cache_shutdown(struct kmem_cache *s)
{
int node;
struct kmem_cache_node *n;
flush_all(s);
/* Attempt to free all objects */
for_each_kmem_cache_node(s, node, n) {
free_partial(s, n);
if (n->nr_partial || slabs_node(s, node))
return 1;
}
sysfs_slab_remove(s);
return 0;
} | 0 |
FFmpeg | e6d3fd942f772f54ab6a5ca619cdaadef26b7702 | NOT_APPLICABLE | NOT_APPLICABLE | static int mov_write_header(AVFormatContext *s)
{
AVIOContext *pb = s->pb;
MOVMuxContext *mov = s->priv_data;
AVDictionaryEntry *t, *global_tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
int i, ret, hint_track = 0, tmcd_track = 0, nb_tracks = s->nb_streams;
if (mov->mode & (MODE_MP4|MODE_MOV|MODE_IPOD) && s->nb_chapters)
nb_tracks++;
if (mov->flags & FF_MOV_FLAG_RTP_HINT) {
/* Add hint tracks for each audio and video stream */
hint_track = nb_tracks;
for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
nb_tracks++;
}
}
}
if (mov->mode == MODE_MOV || mov->mode == MODE_MP4)
tmcd_track = nb_tracks;
for (i = 0; i < s->nb_streams; i++) {
int j;
AVStream *st= s->streams[i];
MOVTrack *track= &mov->tracks[i];
/* copy extradata if it exists */
if (st->codecpar->extradata_size) {
if (st->codecpar->codec_id == AV_CODEC_ID_DVD_SUBTITLE)
mov_create_dvd_sub_decoder_specific_info(track, st);
else if (!TAG_IS_AVCI(track->tag) && st->codecpar->codec_id != AV_CODEC_ID_DNXHD) {
track->vos_len = st->codecpar->extradata_size;
track->vos_data = av_malloc(track->vos_len);
if (!track->vos_data) {
return AVERROR(ENOMEM);
}
memcpy(track->vos_data, st->codecpar->extradata, track->vos_len);
}
}
if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
track->par->channel_layout != AV_CH_LAYOUT_MONO)
continue;
for (j = 0; j < s->nb_streams; j++) {
AVStream *stj= s->streams[j];
MOVTrack *trackj= &mov->tracks[j];
if (j == i)
continue;
if (stj->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
trackj->par->channel_layout != AV_CH_LAYOUT_MONO ||
trackj->language != track->language ||
trackj->tag != track->tag
)
continue;
track->multichannel_as_mono++;
}
}
if (!(mov->flags & FF_MOV_FLAG_DELAY_MOOV)) {
if ((ret = mov_write_identification(pb, s)) < 0)
return ret;
}
if (mov->reserved_moov_size){
mov->reserved_header_pos = avio_tell(pb);
if (mov->reserved_moov_size > 0)
avio_skip(pb, mov->reserved_moov_size);
}
if (mov->flags & FF_MOV_FLAG_FRAGMENT) {
/* If no fragmentation options have been set, set a default. */
if (!(mov->flags & (FF_MOV_FLAG_FRAG_KEYFRAME |
FF_MOV_FLAG_FRAG_CUSTOM)) &&
!mov->max_fragment_duration && !mov->max_fragment_size)
mov->flags |= FF_MOV_FLAG_FRAG_KEYFRAME;
} else {
if (mov->flags & FF_MOV_FLAG_FASTSTART)
mov->reserved_header_pos = avio_tell(pb);
mov_write_mdat_tag(pb, mov);
}
ff_parse_creation_time_metadata(s, &mov->time, 1);
if (mov->time)
mov->time += 0x7C25B080; // 1970 based -> 1904 based
if (mov->chapter_track)
if ((ret = mov_create_chapter_track(s, mov->chapter_track)) < 0)
return ret;
if (mov->flags & FF_MOV_FLAG_RTP_HINT) {
/* Initialize the hint tracks for each audio and video stream */
for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
if ((ret = ff_mov_init_hinting(s, hint_track, i)) < 0)
return ret;
hint_track++;
}
}
}
if (mov->nb_meta_tmcd) {
/* Initialize the tmcd tracks */
for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
t = global_tcr;
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
AVTimecode tc;
if (!t)
t = av_dict_get(st->metadata, "timecode", NULL, 0);
if (!t)
continue;
if (mov_check_timecode_track(s, &tc, i, t->value) < 0)
continue;
if ((ret = mov_create_timecode_track(s, tmcd_track, i, tc)) < 0)
return ret;
tmcd_track++;
}
}
}
avio_flush(pb);
if (mov->flags & FF_MOV_FLAG_ISML)
mov_write_isml_manifest(pb, mov, s);
if (mov->flags & FF_MOV_FLAG_EMPTY_MOOV &&
!(mov->flags & FF_MOV_FLAG_DELAY_MOOV)) {
if ((ret = mov_write_moov_tag(pb, mov, s)) < 0)
return ret;
avio_flush(pb);
mov->moov_written = 1;
if (mov->flags & FF_MOV_FLAG_GLOBAL_SIDX)
mov->reserved_header_pos = avio_tell(pb);
}
return 0;
} | 0 |
illumos-gate | 1d276e0b382cf066dae93640746d8b4c54d15452 | NOT_APPLICABLE | NOT_APPLICABLE | pam_trace_fname(int flag)
{
if (flag & PAM_BINDING)
return (PAM_BINDING_NAME);
if (flag & PAM_INCLUDE)
return (PAM_INCLUDE_NAME);
if (flag & PAM_OPTIONAL)
return (PAM_OPTIONAL_NAME);
if (flag & PAM_REQUIRED)
return (PAM_REQUIRED_NAME);
if (flag & PAM_REQUISITE)
return (PAM_REQUISITE_NAME);
if (flag & PAM_SUFFICIENT)
return (PAM_SUFFICIENT_NAME);
return ("bad flag name");
} | 0 |
OpenJK | 376267d534476a875d8b9228149c4ee18b74a4fd | CVE-2017-6903 | CWE-269 | void CL_InitRef( void ) {
refimport_t ri;
refexport_t *ret;
#ifdef USE_RENDERER_DLOPEN
GetRefAPI_t GetRefAPI;
char dllName[MAX_OSPATH];
#endif
Com_Printf( "----- Initializing Renderer ----\n" );
#ifdef USE_RENDERER_DLOPEN
cl_renderer = Cvar_Get("cl_renderer", "opengl2", CVAR_ARCHIVE | CVAR_LATCH);
Com_sprintf(dllName, sizeof(dllName), "renderer_%s_" ARCH_STRING DLL_EXT, cl_renderer->string);
if(!(rendererLib = Sys_LoadDll(dllName, qfalse)) && strcmp(cl_renderer->string, cl_renderer->resetString))
{
Com_Printf("failed:\n\"%s\"\n", Sys_LibraryError());
Cvar_ForceReset("cl_renderer");
Com_sprintf(dllName, sizeof(dllName), "renderer_opengl2_" ARCH_STRING DLL_EXT);
rendererLib = Sys_LoadDll(dllName, qfalse);
}
if(!rendererLib)
{
Com_Printf("failed:\n\"%s\"\n", Sys_LibraryError());
Com_Error(ERR_FATAL, "Failed to load renderer");
}
GetRefAPI = Sys_LoadFunction(rendererLib, "GetRefAPI");
if(!GetRefAPI)
{
Com_Error(ERR_FATAL, "Can't load symbol GetRefAPI: '%s'", Sys_LibraryError());
}
#endif
ri.Cmd_AddCommand = Cmd_AddCommand;
ri.Cmd_RemoveCommand = Cmd_RemoveCommand;
ri.Cmd_Argc = Cmd_Argc;
ri.Cmd_Argv = Cmd_Argv;
ri.Cmd_ExecuteText = Cbuf_ExecuteText;
ri.Printf = CL_RefPrintf;
ri.Error = Com_Error;
ri.Milliseconds = CL_ScaledMilliseconds;
ri.Malloc = CL_RefMalloc;
ri.Free = Z_Free;
#ifdef HUNK_DEBUG
ri.Hunk_AllocDebug = Hunk_AllocDebug;
#else
ri.Hunk_Alloc = Hunk_Alloc;
#endif
ri.Hunk_AllocateTempMemory = Hunk_AllocateTempMemory;
ri.Hunk_FreeTempMemory = Hunk_FreeTempMemory;
ri.CM_ClusterPVS = CM_ClusterPVS;
ri.CM_DrawDebugSurface = CM_DrawDebugSurface;
ri.FS_ReadFile = FS_ReadFile;
ri.FS_FreeFile = FS_FreeFile;
ri.FS_WriteFile = FS_WriteFile;
ri.FS_FreeFileList = FS_FreeFileList;
ri.FS_ListFiles = FS_ListFiles;
ri.FS_FileIsInPAK = FS_FileIsInPAK;
ri.FS_FileExists = FS_FileExists;
ri.Cvar_Get = Cvar_Get;
ri.Cvar_Set = Cvar_Set;
ri.Cvar_SetValue = Cvar_SetValue;
ri.Cvar_CheckRange = Cvar_CheckRange;
ri.Cvar_SetDescription = Cvar_SetDescription;
ri.Cvar_VariableIntegerValue = Cvar_VariableIntegerValue;
ri.CIN_UploadCinematic = CIN_UploadCinematic;
ri.CIN_PlayCinematic = CIN_PlayCinematic;
ri.CIN_RunCinematic = CIN_RunCinematic;
ri.CL_WriteAVIVideoFrame = CL_WriteAVIVideoFrame;
ri.IN_Init = IN_Init;
ri.IN_Shutdown = IN_Shutdown;
ri.IN_Restart = IN_Restart;
ri.ftol = Q_ftol;
ri.Sys_SetEnv = Sys_SetEnv;
ri.Sys_GLimpSafeInit = Sys_GLimpSafeInit;
ri.Sys_GLimpInit = Sys_GLimpInit;
ri.Sys_LowPhysicalMemory = Sys_LowPhysicalMemory;
ret = GetRefAPI( REF_API_VERSION, &ri );
#if defined __USEA3D && defined __A3D_GEOM
hA3Dg_ExportRenderGeom (ret);
#endif
Com_Printf( "-------------------------------\n");
if ( !ret ) {
Com_Error (ERR_FATAL, "Couldn't initialize refresh" );
}
re = *ret;
Cvar_Set( "cl_paused", "0" );
}
| 1 |
xserver | b67581cf825940fdf52bf2e0af4330e695d724a4 | NOT_APPLICABLE | NOT_APPLICABLE | OsBlockSignals (void)
{
#ifdef SIG_BLOCK
if (BlockedSignalCount++ == 0)
{
sigset_t set;
sigemptyset (&set);
sigaddset (&set, SIGALRM);
sigaddset (&set, SIGVTALRM);
#ifdef SIGWINCH
sigaddset (&set, SIGWINCH);
#endif
#ifdef SIGIO
sigaddset (&set, SIGIO);
#endif
sigaddset (&set, SIGTSTP);
sigaddset (&set, SIGTTIN);
sigaddset (&set, SIGTTOU);
sigaddset (&set, SIGCHLD);
sigprocmask (SIG_BLOCK, &set, &PreviousSignalMask);
}
#endif
}
| 0 |
redcarpet | e5a10516d07114d582d13b9125b733008c61c242 | NOT_APPLICABLE | NOT_APPLICABLE | char_entity(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
{
size_t end = 1;
struct buf work = { 0, 0, 0, 0 };
if (end < size && data[end] == '#')
end++;
while (end < size && _isalnum(data[end]))
end++;
if (end < size && data[end] == ';')
end++; /* real entity */
else
return 0; /* lone '&' */
if (rndr->cb.entity) {
work.data = data;
work.size = end;
rndr->cb.entity(ob, &work, rndr->opaque);
}
else bufput(ob, data, end);
return end;
} | 0 |
fontforge | 048a91e2682c1a8936ae34dbc7bd70291ec05410 | NOT_APPLICABLE | NOT_APPLICABLE | static struct glyphvariants *SFDParseGlyphComposition(FILE *sfd,
struct glyphvariants *gv, char *tok) {
int i;
if ( gv==NULL )
gv = chunkalloc(sizeof(struct glyphvariants));
getint(sfd,&gv->part_cnt);
gv->parts = calloc(gv->part_cnt,sizeof(struct gv_part));
for ( i=0; i<gv->part_cnt; ++i ) {
int temp, ch;
getname(sfd,tok);
gv->parts[i].component = copy(tok);
while ( (ch=nlgetc(sfd))==' ' );
if ( ch!='%' ) ungetc(ch,sfd);
getint(sfd,&temp);
gv->parts[i].is_extender = temp;
while ( (ch=nlgetc(sfd))==' ' );
if ( ch!=',' ) ungetc(ch,sfd);
getint(sfd,&temp);
gv->parts[i].startConnectorLength=temp;
while ( (ch=nlgetc(sfd))==' ' );
if ( ch!=',' ) ungetc(ch,sfd);
getint(sfd,&temp);
gv->parts[i].endConnectorLength = temp;
while ( (ch=nlgetc(sfd))==' ' );
if ( ch!=',' ) ungetc(ch,sfd);
getint(sfd,&temp);
gv->parts[i].fullAdvance = temp;
}
return( gv );
} | 0 |
memcached | d35334f368817a77a6bd1f33c6a5676b2c402c02 | NOT_APPLICABLE | NOT_APPLICABLE | static inline int _get_extstore(conn *c, item *it, int iovst, int iovcnt) {
#ifdef NEED_ALIGN
item_hdr hdr;
memcpy(&hdr, ITEM_data(it), sizeof(hdr));
#else
item_hdr *hdr = (item_hdr *)ITEM_data(it);
#endif
size_t ntotal = ITEM_ntotal(it);
unsigned int clsid = slabs_clsid(ntotal);
item *new_it;
bool chunked = false;
if (ntotal > settings.slab_chunk_size_max) {
uint32_t flags;
FLAGS_CONV(settings.inline_ascii_response, it, flags);
new_it = item_alloc(ITEM_key(it), it->nkey, flags, it->exptime, it->nbytes);
assert(new_it == NULL || (new_it->it_flags & ITEM_CHUNKED));
chunked = true;
} else {
new_it = do_item_alloc_pull(ntotal, clsid);
}
if (new_it == NULL)
return -1;
assert(!c->io_queued); // FIXME: debugging.
new_it->slabs_clsid = clsid;
io_wrap *io = do_cache_alloc(c->thread->io_cache);
io->active = true;
io->miss = false;
io->badcrc = false;
io->hdr_it = it;
io->iovec_start = iovst;
io->iovec_count = iovcnt;
if (chunked) {
unsigned int ciovcnt = 1;
size_t remain = new_it->nbytes;
item_chunk *chunk = (item_chunk *) ITEM_schunk(new_it);
io->io.iov = &c->iov[c->iovused];
add_iov(c, new_it, ITEM_ntotal(new_it) - new_it->nbytes);
while (remain > 0) {
chunk = do_item_alloc_chunk(chunk, remain);
if (chunk == NULL) {
item_remove(new_it);
do_cache_free(c->thread->io_cache, io);
return -1;
}
add_iov(c, chunk->data, (remain < chunk->size) ? remain : chunk->size);
chunk->used = (remain < chunk->size) ? remain : chunk->size;
remain -= chunk->size;
ciovcnt++;
}
io->io.iovcnt = ciovcnt;
io->iovec_count += ciovcnt-1;
} else {
io->io.iov = NULL;
io->iovec_data = c->iovused;
add_iov(c, "", it->nbytes);
}
io->io.buf = (void *)new_it;
io->c = c;
if (c->io_wraplist) {
io->io.next = &c->io_wraplist->io;
} else {
io->io.next = NULL;
}
io->next = c->io_wraplist;
c->io_wraplist = io;
assert(c->io_wrapleft >= 0);
c->io_wrapleft++;
io->io.data = (void *)io;
#ifdef NEED_ALIGN
io->io.page_version = hdr.page_version;
io->io.page_id = hdr.page_id;
io->io.offset = hdr.offset;
#else
io->io.page_version = hdr->page_version;
io->io.page_id = hdr->page_id;
io->io.offset = hdr->offset;
#endif
io->io.len = ntotal;
io->io.mode = OBJ_IO_READ;
io->io.cb = _get_extstore_cb;
pthread_mutex_lock(&c->thread->stats.mutex);
c->thread->stats.get_extstore++;
pthread_mutex_unlock(&c->thread->stats.mutex);
return 0;
}
| 0 |
mutt | e5ed080c00e59701ca62ef9b2a6d2612ebf765a5 | NOT_APPLICABLE | NOT_APPLICABLE | static int valid_pgp_encrypted_handler (BODY *b, STATE *s)
{
int rc;
BODY *octetstream;
octetstream = b->parts->next;
/* clear out any mime headers before the handler, so they can't be
* spoofed. */
mutt_free_envelope (&b->mime_headers);
mutt_free_envelope (&octetstream->mime_headers);
/* Some clients improperly encode the octetstream part. */
if (octetstream->encoding != ENC7BIT)
rc = run_decode_and_handler (octetstream, s, crypt_pgp_encrypted_handler, 0);
else
rc = crypt_pgp_encrypted_handler (octetstream, s);
b->goodsig |= octetstream->goodsig;
#ifdef USE_AUTOCRYPT
b->is_autocrypt |= octetstream->is_autocrypt;
#endif
/* Relocate protected headers onto the multipart/encrypted part */
if (!rc && octetstream->mime_headers)
{
b->mime_headers = octetstream->mime_headers;
octetstream->mime_headers = NULL;
}
return rc;
} | 0 |
Chrome | c0c8978849ac57e4ecd613ddc8ff7852a2054734 | NOT_APPLICABLE | NOT_APPLICABLE | bool PlatformSensorWin::CheckSensorConfiguration(
const PlatformSensorConfiguration& configuration) {
DCHECK(task_runner_->BelongsToCurrentThread());
double minimal_reporting_interval_ms =
sensor_reader_->GetMinimalReportingIntervalMs();
if (minimal_reporting_interval_ms == 0)
return true;
double max_frequency =
base::Time::kMillisecondsPerSecond / minimal_reporting_interval_ms;
return configuration.frequency() <= max_frequency;
}
| 0 |
linux | fd4d9c7d0c71866ec0c2825189ebd2ce35bd95b8 | NOT_APPLICABLE | NOT_APPLICABLE |
static int uevent_filter(struct kset *kset, struct kobject *kobj)
{
struct kobj_type *ktype = get_ktype(kobj);
if (ktype == &slab_ktype)
return 1;
return 0; | 0 |
libsass | 38f4c3699d06b64128bebc7cf1e8b3125be74dc4 | CVE-2018-11696 | CWE-476 | void Inspect::operator()(Complex_Selector_Ptr c)
{
Compound_Selector_Obj head = c->head();
Complex_Selector_Obj tail = c->tail();
Complex_Selector::Combinator comb = c->combinator();
if (comb == Complex_Selector::ANCESTOR_OF && (!head || head->empty())) {
if (tail) tail->perform(this);
return;
}
if (c->has_line_feed()) {
if (!(c->has_parent_ref())) {
append_optional_linefeed();
append_indentation();
}
}
if (head && head->length() != 0) head->perform(this);
bool is_empty = !head || head->length() == 0 || head->is_empty_reference();
bool is_tail = head && !head->is_empty_reference() && tail;
if (output_style() == COMPRESSED && comb != Complex_Selector::ANCESTOR_OF) scheduled_space = 0;
switch (comb) {
case Complex_Selector::ANCESTOR_OF:
if (is_tail) append_mandatory_space();
break;
case Complex_Selector::PARENT_OF:
append_optional_space();
append_string(">");
append_optional_space();
break;
case Complex_Selector::ADJACENT_TO:
append_optional_space();
append_string("+");
append_optional_space();
break;
case Complex_Selector::REFERENCE:
append_mandatory_space();
append_string("/");
c->reference()->perform(this);
append_string("/");
append_mandatory_space();
break;
case Complex_Selector::PRECEDES:
if (is_empty) append_optional_space();
else append_mandatory_space();
append_string("~");
if (tail) append_mandatory_space();
else append_optional_space();
break;
default: break;
}
if (tail && comb != Complex_Selector::ANCESTOR_OF) {
if (c->has_line_break()) append_optional_linefeed();
}
if (tail) tail->perform(this);
if (!tail && c->has_line_break()) {
if (output_style() == COMPACT) {
append_mandatory_space();
}
}
} | 1 |
php | 1291d6bbee93b6109eb07e8f7916ff1b7fcc13e1 | NOT_APPLICABLE | NOT_APPLICABLE | PHP_FUNCTION(get_cfg_var)
{
char *varname;
int varname_len;
zval *retval;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &varname, &varname_len) == FAILURE) {
return;
}
retval = cfg_get_entry(varname, varname_len + 1);
if (retval) {
if (Z_TYPE_P(retval) == IS_ARRAY) {
array_init(return_value);
zend_hash_apply_with_arguments(Z_ARRVAL_P(retval) TSRMLS_CC, (apply_func_args_t) add_config_entry_cb, 1, return_value);
return;
} else {
RETURN_STRING(Z_STRVAL_P(retval), 1);
}
} else {
RETURN_FALSE;
}
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.