unique_id
int64 13
189k
| target
int64 0
1
| code
stringlengths 20
241k
| __index_level_0__
int64 0
18.9k
|
|---|---|---|---|
24,038 | 0 | static int header_len(__le16 ctl)
{
u16 fc = le16_to_cpu(ctl);
switch (fc & 0xc) {
case 4:
if ((fc & 0xe0) == 0xc0)
return 10; /* one-address control packet */
return 16; /* two-address control packet */
case 8:
if ((fc & 0x300) == 0x300)
return 30; /* WDS packet */
}
return 24;
}
| 6,700 |
33,688 | 0 | pkinit_process_td_trusted_certifiers(
krb5_context context,
pkinit_plg_crypto_context plg_cryptoctx,
pkinit_req_crypto_context req_cryptoctx,
pkinit_identity_crypto_context id_cryptoctx,
krb5_external_principal_identifier **krb5_trusted_certifiers,
int td_type)
{
krb5_error_code retval = ENOMEM;
STACK_OF(X509_NAME) *sk_xn = NULL;
X509_NAME *xn = NULL;
PKCS7_ISSUER_AND_SERIAL *is = NULL;
ASN1_OCTET_STRING *id = NULL;
const unsigned char *p = NULL;
char buf[DN_BUF_LEN];
int i = 0;
if (td_type == TD_TRUSTED_CERTIFIERS)
pkiDebug("received trusted certifiers\n");
else
pkiDebug("received invalid certificate\n");
sk_xn = sk_X509_NAME_new_null();
while(krb5_trusted_certifiers[i] != NULL) {
if (krb5_trusted_certifiers[i]->subjectName.data != NULL) {
p = (unsigned char *)krb5_trusted_certifiers[i]->subjectName.data;
xn = d2i_X509_NAME(NULL, &p,
(int)krb5_trusted_certifiers[i]->subjectName.length);
if (xn == NULL)
goto cleanup;
X509_NAME_oneline(xn, buf, sizeof(buf));
if (td_type == TD_TRUSTED_CERTIFIERS)
pkiDebug("#%d cert = %s is trusted by kdc\n", i, buf);
else
pkiDebug("#%d cert = %s is invalid\n", i, buf);
sk_X509_NAME_push(sk_xn, xn);
}
if (krb5_trusted_certifiers[i]->issuerAndSerialNumber.data != NULL) {
p = (unsigned char *)
krb5_trusted_certifiers[i]->issuerAndSerialNumber.data;
is = d2i_PKCS7_ISSUER_AND_SERIAL(NULL, &p,
(int)krb5_trusted_certifiers[i]->issuerAndSerialNumber.length);
if (is == NULL)
goto cleanup;
X509_NAME_oneline(is->issuer, buf, sizeof(buf));
if (td_type == TD_TRUSTED_CERTIFIERS)
pkiDebug("#%d issuer = %s serial = %ld is trusted bu kdc\n", i,
buf, ASN1_INTEGER_get(is->serial));
else
pkiDebug("#%d issuer = %s serial = %ld is invalid\n", i, buf,
ASN1_INTEGER_get(is->serial));
PKCS7_ISSUER_AND_SERIAL_free(is);
}
if (krb5_trusted_certifiers[i]->subjectKeyIdentifier.data != NULL) {
p = (unsigned char *)
krb5_trusted_certifiers[i]->subjectKeyIdentifier.data;
id = d2i_ASN1_OCTET_STRING(NULL, &p,
(int)krb5_trusted_certifiers[i]->subjectKeyIdentifier.length);
if (id == NULL)
goto cleanup;
/* XXX */
ASN1_OCTET_STRING_free(id);
}
i++;
}
/* XXX Since we not doing anything with received trusted certifiers
* return an error. this is the place where we can pick a different
* client certificate based on the information in td_trusted_certifiers
*/
retval = KRB5KDC_ERR_PREAUTH_FAILED;
cleanup:
if (sk_xn != NULL)
sk_X509_NAME_pop_free(sk_xn, X509_NAME_free);
return retval;
}
| 6,701 |
100,427 | 0 | void RenderThread::OnGetCacheResourceStats() {
EnsureWebKitInitialized();
WebCache::ResourceTypeStats stats;
WebCache::getResourceTypeStats(&stats);
Send(new ViewHostMsg_ResourceTypeStats(stats));
}
| 6,702 |
186,903 | 1 | static void ProxyLocaltimeCallToBrowser(time_t input, struct tm* output,
char* timezone_out,
size_t timezone_out_len) {
base::Pickle request;
request.WriteInt(LinuxSandbox::METHOD_LOCALTIME);
request.WriteString(
std::string(reinterpret_cast<char*>(&input), sizeof(input)));
uint8_t reply_buf[512];
const ssize_t r = base::UnixDomainSocket::SendRecvMsg(
GetSandboxFD(), reply_buf, sizeof(reply_buf), NULL, request);
if (r == -1) {
memset(output, 0, sizeof(struct tm));
return;
}
base::Pickle reply(reinterpret_cast<char*>(reply_buf), r);
base::PickleIterator iter(reply);
std::string result;
std::string timezone;
if (!iter.ReadString(&result) ||
!iter.ReadString(&timezone) ||
result.size() != sizeof(struct tm)) {
memset(output, 0, sizeof(struct tm));
return;
}
memcpy(output, result.data(), sizeof(struct tm));
if (timezone_out_len) {
const size_t copy_len = std::min(timezone_out_len - 1, timezone.size());
memcpy(timezone_out, timezone.data(), copy_len);
timezone_out[copy_len] = 0;
output->tm_zone = timezone_out;
} else {
base::AutoLock lock(g_timezones_lock.Get());
auto ret_pair = g_timezones.Get().insert(timezone);
output->tm_zone = ret_pair.first->c_str();
}
}
| 6,703 |
144,771 | 0 | LocalSiteCharacteristicsWebContentsObserver* observer() {
return observer_.get();
}
| 6,704 |
58,119 | 0 | static void __migrate_swap_task(struct task_struct *p, int cpu)
{
if (p->on_rq) {
struct rq *src_rq, *dst_rq;
src_rq = task_rq(p);
dst_rq = cpu_rq(cpu);
deactivate_task(src_rq, p, 0);
set_task_cpu(p, cpu);
activate_task(dst_rq, p, 0);
check_preempt_curr(dst_rq, p, 0);
} else {
/*
* Task isn't running anymore; make it appear like we migrated
* it before it went to sleep. This means on wakeup we make the
* previous cpu our targer instead of where it really is.
*/
p->wake_cpu = cpu;
}
}
| 6,705 |
85,467 | 0 | int sas_discover_event(struct asd_sas_port *port, enum discover_event ev)
{
struct sas_discovery *disc;
if (!port)
return 0;
disc = &port->disc;
BUG_ON(ev >= DISC_NUM_EVENTS);
sas_chain_event(ev, &disc->pending, &disc->disc_work[ev].work, port->ha);
return 0;
}
| 6,706 |
57,360 | 0 | static int sco_sock_create(struct net *net, struct socket *sock, int protocol,
int kern)
{
struct sock *sk;
BT_DBG("sock %p", sock);
sock->state = SS_UNCONNECTED;
if (sock->type != SOCK_SEQPACKET)
return -ESOCKTNOSUPPORT;
sock->ops = &sco_sock_ops;
sk = sco_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
if (!sk)
return -ENOMEM;
sco_sock_init(sk, NULL);
return 0;
}
| 6,707 |
88,362 | 0 | uint32_t faad_origbitbuffer_size(bitfile *ld)
{
return ld->buffer_size;
}
| 6,708 |
160,431 | 0 | void RenderFrameHostImpl::CreateUsbChooserService(
device::mojom::UsbChooserServiceRequest request) {
GetContentClient()->browser()->CreateUsbChooserService(this,
std::move(request));
}
| 6,709 |
175,481 | 0 | static uint32_t out_get_channels(const struct audio_stream *stream)
{
struct stream_out *out = (struct stream_out *)stream;
return out->channel_mask;
}
| 6,710 |
81,176 | 0 | static int posix_get_boottime(const clockid_t which_clock, struct timespec64 *tp)
{
ktime_get_boottime_ts64(tp);
return 0;
}
| 6,711 |
21,694 | 0 | static struct kiocb *lookup_kiocb(struct kioctx *ctx, struct iocb __user *iocb,
u32 key)
{
struct list_head *pos;
assert_spin_locked(&ctx->ctx_lock);
/* TODO: use a hash or array, this sucks. */
list_for_each(pos, &ctx->active_reqs) {
struct kiocb *kiocb = list_kiocb(pos);
if (kiocb->ki_obj.user == iocb && kiocb->ki_key == key)
return kiocb;
}
return NULL;
}
| 6,712 |
18,769 | 0 | static int dccp_v6_init_sock(struct sock *sk)
{
static __u8 dccp_v6_ctl_sock_initialized;
int err = dccp_init_sock(sk, dccp_v6_ctl_sock_initialized);
if (err == 0) {
if (unlikely(!dccp_v6_ctl_sock_initialized))
dccp_v6_ctl_sock_initialized = 1;
inet_csk(sk)->icsk_af_ops = &dccp_ipv6_af_ops;
}
return err;
}
| 6,713 |
46,902 | 0 | static void __exit cast6_exit(void)
{
crypto_unregister_algs(cast6_algs, ARRAY_SIZE(cast6_algs));
}
| 6,714 |
53,518 | 0 | parse_escapes(char *src, struct mtree_entry *mentry)
{
char *dest = src;
char c;
if (mentry != NULL && strcmp(src, ".") == 0)
mentry->full = 1;
while (*src != '\0') {
c = *src++;
if (c == '/' && mentry != NULL)
mentry->full = 1;
if (c == '\\') {
switch (src[0]) {
case '0':
if (src[1] < '0' || src[1] > '7') {
c = 0;
++src;
break;
}
/* FALLTHROUGH */
case '1':
case '2':
case '3':
if (src[1] >= '0' && src[1] <= '7' &&
src[2] >= '0' && src[2] <= '7') {
c = (src[0] - '0') << 6;
c |= (src[1] - '0') << 3;
c |= (src[2] - '0');
src += 3;
}
break;
case 'a':
c = '\a';
++src;
break;
case 'b':
c = '\b';
++src;
break;
case 'f':
c = '\f';
++src;
break;
case 'n':
c = '\n';
++src;
break;
case 'r':
c = '\r';
++src;
break;
case 's':
c = ' ';
++src;
break;
case 't':
c = '\t';
++src;
break;
case 'v':
c = '\v';
++src;
break;
case '\\':
c = '\\';
++src;
break;
}
}
*dest++ = c;
}
*dest = '\0';
}
| 6,715 |
61,259 | 0 | mboxlist_delayed_deletemailbox(const char *name, int isadmin,
const char *userid,
const struct auth_state *auth_state,
struct mboxevent *mboxevent,
int checkacl,
int localonly,
int force)
{
mbentry_t *mbentry = NULL;
strarray_t existing = STRARRAY_INITIALIZER;
int i;
char newname[MAX_MAILBOX_BUFFER];
int r = 0;
long myrights;
if (!isadmin && force) return IMAP_PERMISSION_DENIED;
/* delete of a user.X folder */
mbname_t *mbname = mbname_from_intname(name);
if (mbname_userid(mbname) && !strarray_size(mbname_boxes(mbname))) {
/* Can't DELETE INBOX (your own inbox) */
if (!strcmpsafe(mbname_userid(mbname), userid)) {
r = IMAP_MAILBOX_NOTSUPPORTED;
goto done;
}
/* Only admins may delete user */
if (!isadmin) {
r = IMAP_PERMISSION_DENIED;
goto done;
}
}
if (!isadmin && mbname_userid(mbname)) {
struct buf attrib = BUF_INITIALIZER;
annotatemore_lookup(mbname_intname(mbname), "/specialuse", mbname_userid(mbname), &attrib);
if (attrib.len)
r = IMAP_MAILBOX_SPECIALUSE;
buf_free(&attrib);
if (r) goto done;
}
r = mboxlist_lookup(name, &mbentry, NULL);
if (r) goto done;
/* check if user has Delete right (we've already excluded non-admins
* from deleting a user mailbox) */
if (checkacl) {
myrights = cyrus_acl_myrights(auth_state, mbentry->acl);
if (!(myrights & ACL_DELETEMBOX)) {
/* User has admin rights over their own mailbox namespace */
if (mboxname_userownsmailbox(userid, name) &&
(config_implicitrights & ACL_ADMIN)) {
isadmin = 1;
}
/* Lie about error if privacy demands */
r = (isadmin || (myrights & ACL_LOOKUP)) ?
IMAP_PERMISSION_DENIED : IMAP_MAILBOX_NONEXISTENT;
goto done;
}
}
/* check if there are already too many! */
mboxname_todeleted(name, newname, 0);
r = mboxlist_mboxtree(newname, addmbox_to_list, &existing, MBOXTREE_SKIP_ROOT);
if (r) goto done;
/* keep the last 19, so the new one is the 20th */
for (i = 0; i < (int)existing.count - 19; i++) {
const char *subname = strarray_nth(&existing, i);
syslog(LOG_NOTICE, "too many subfolders for %s, deleting %s (%d / %d)",
newname, subname, i+1, (int)existing.count);
r = mboxlist_deletemailbox(subname, 1, userid, auth_state, NULL, 0, 1, 1);
if (r) goto done;
}
/* get the deleted name */
mboxname_todeleted(name, newname, 1);
/* Get mboxlist_renamemailbox to do the hard work. No ACL checks needed */
r = mboxlist_renamemailbox((char *)name, newname, mbentry->partition,
0 /* uidvalidity */,
1 /* isadmin */, userid,
auth_state,
mboxevent,
localonly /* local_only */,
force, 1);
done:
strarray_fini(&existing);
mboxlist_entry_free(&mbentry);
mbname_free(&mbname);
return r;
}
| 6,716 |
125,976 | 0 | void NavigationNotificationObserver::Observe(
int type, const content::NotificationSource& source,
const content::NotificationDetails& details) {
if (!automation_) {
delete this;
return;
}
if (type == content::NOTIFICATION_NAV_ENTRY_COMMITTED ||
type == content::NOTIFICATION_LOAD_START) {
navigation_started_ = true;
} else if (type == content::NOTIFICATION_LOAD_STOP) {
if (navigation_started_) {
navigation_started_ = false;
if (--navigations_remaining_ == 0)
ConditionMet(AUTOMATION_MSG_NAVIGATION_SUCCESS);
}
} else if (type == chrome::NOTIFICATION_AUTH_SUPPLIED ||
type == chrome::NOTIFICATION_AUTH_CANCELLED) {
navigation_started_ = true;
} else if (type == chrome::NOTIFICATION_AUTH_NEEDED) {
navigation_started_ = false;
ConditionMet(AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED);
} else if (type == chrome::NOTIFICATION_APP_MODAL_DIALOG_SHOWN) {
ConditionMet(AUTOMATION_MSG_NAVIGATION_BLOCKED_BY_MODAL_DIALOG);
} else {
NOTREACHED();
}
}
| 6,717 |
5,162 | 0 | PHP_FUNCTION(pg_lo_write)
{
zval *pgsql_id;
char *str;
zend_long z_len;
size_t str_len, nbytes;
size_t len;
pgLofp *pgsql;
int argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc, "rs|l", &pgsql_id, &str, &str_len, &z_len) == FAILURE) {
return;
}
if (argc > 2) {
if (z_len > (zend_long)str_len) {
php_error_docref(NULL, E_WARNING, "Cannot write more than buffer size %d. Tried to write %pd", str_len, z_len);
RETURN_FALSE;
}
if (z_len < 0) {
php_error_docref(NULL, E_WARNING, "Buffer size must be larger than 0, but %pd was specified", z_len);
RETURN_FALSE;
}
len = z_len;
}
else {
len = str_len;
}
ZEND_FETCH_RESOURCE(pgsql, pgLofp *, pgsql_id, -1, "PostgreSQL large object", le_lofp);
if ((nbytes = lo_write((PGconn *)pgsql->conn, pgsql->lofd, str, len)) == -1) {
RETURN_FALSE;
}
RETURN_LONG(nbytes);
}
| 6,718 |
102,489 | 0 | void LayerTreeCoordinator::sizeDidChange(const WebCore::IntSize& newSize)
{
if (m_rootLayer->size() == newSize)
return;
m_rootLayer->setSize(newSize);
FloatSize oldSize = m_nonCompositedContentLayer->size();
m_nonCompositedContentLayer->setSize(newSize);
if (newSize.width() > oldSize.width()) {
float height = std::min(static_cast<float>(newSize.height()), oldSize.height());
m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(oldSize.width(), 0, newSize.width() - oldSize.width(), height));
}
if (newSize.height() > oldSize.height())
m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(0, oldSize.height(), newSize.width(), newSize.height() - oldSize.height()));
if (m_pageOverlayLayer)
m_pageOverlayLayer->setSize(newSize);
scheduleLayerFlush();
}
| 6,719 |
71,817 | 0 | static void ipa_device_begin(wmfAPI * API)
{
char
comment[MaxTextExtent];
wmf_magick_t
*ddata = WMF_MAGICK_GetData(API);
/* Make SVG output happy */
(void) PushDrawingWand(WmfDrawingWand);
DrawSetViewbox(WmfDrawingWand, 0, 0, ddata->image->columns, ddata->image->rows );
(void) FormatLocaleString(comment,MaxTextExtent,"Created by ImageMagick %s",
GetMagickVersion((size_t *) NULL));
DrawComment(WmfDrawingWand,comment);
/* Scale width and height to image */
DrawScale(WmfDrawingWand, ddata->scale_x, ddata->scale_y);
/* Translate to TL corner of bounding box */
DrawTranslate(WmfDrawingWand, ddata->translate_x, ddata->translate_y);
/* Apply rotation */
DrawRotate(WmfDrawingWand, ddata->rotate);
if (ddata->image_info->texture == NULL)
{
PixelWand
*background_color;
/* Draw rectangle in background color */
background_color=NewPixelWand();
PixelSetQuantumColor(background_color,&ddata->image->background_color);
DrawSetFillColor(WmfDrawingWand,background_color);
background_color=DestroyPixelWand(background_color);
DrawRectangle(WmfDrawingWand,
XC(ddata->bbox.TL.x),YC(ddata->bbox.TL.y),
XC(ddata->bbox.BR.x),YC(ddata->bbox.BR.y));
}
else
{
/* Draw rectangle with texture image the SVG way */
Image
*image;
ImageInfo
*image_info;
ExceptionInfo
*exception;
exception=AcquireExceptionInfo();
image_info = CloneImageInfo((ImageInfo *) 0);
(void) CopyMagickString(image_info->filename,ddata->image_info->texture,
MaxTextExtent);
if ( ddata->image_info->size )
CloneString(&image_info->size,ddata->image_info->size);
image = ReadImage(image_info,exception);
image_info=DestroyImageInfo(image_info);
if (image)
{
char
pattern_id[30];
MagickWand
*magick_wand;
(void) CopyMagickString(image->magick,"MIFF",MaxTextExtent);
DrawPushDefs(WmfDrawingWand);
draw_pattern_push(API,ddata->pattern_id,image->columns,image->rows);
magick_wand=NewMagickWandFromImage(image);
(void) DrawComposite(WmfDrawingWand,CopyCompositeOp,0,0,
image->columns,image->rows,magick_wand);
magick_wand=DestroyMagickWand(magick_wand);
(void) DrawPopPattern(WmfDrawingWand);
DrawPopDefs(WmfDrawingWand);
(void) FormatLocaleString(pattern_id,MaxTextExtent,"#brush_%lu",
ddata->pattern_id);
(void) DrawSetFillPatternURL(WmfDrawingWand,pattern_id);
++ddata->pattern_id;
DrawRectangle(WmfDrawingWand,
XC(ddata->bbox.TL.x),YC(ddata->bbox.TL.y),
XC(ddata->bbox.BR.x),YC(ddata->bbox.BR.y));
image=DestroyImageList(image);
}
else
{
LogMagickEvent(CoderEvent,GetMagickModule(),
"reading texture image failed!");
InheritException(&ddata->image->exception,exception);
}
(void) DestroyExceptionInfo(exception);
}
DrawSetClipRule(WmfDrawingWand,EvenOddRule); /* Default for WMF is ALTERNATE polygon fill mode */
draw_fill_color_string(WmfDrawingWand,"none"); /* Default brush is WHITE_BRUSH */
draw_stroke_color_string(WmfDrawingWand,"none"); /* Default pen is BLACK_PEN */
DrawSetStrokeLineCap(WmfDrawingWand,ButtCap); /* Default linecap is PS_ENDCAP_FLAT */
DrawSetStrokeLineJoin(WmfDrawingWand,MiterJoin); /* Default linejoin is PS_JOIN_MITER */
draw_under_color_string(WmfDrawingWand,"white"); /* Default text box is white */
}
| 6,720 |
168,481 | 0 | explicit StringWrapper(std::string json) : json_(std::move(json)) {}
| 6,721 |
127,414 | 0 | PassRefPtr<RenderStyle> StyleResolver::styleForText(Text* textNode)
{
ASSERT(textNode);
NodeRenderingTraversal::ParentDetails parentDetails;
Node* parentNode = NodeRenderingTraversal::parent(textNode, &parentDetails);
if (!parentNode || !parentNode->renderStyle() || parentDetails.resetStyleInheritance())
return defaultStyleForElement();
return parentNode->renderStyle();
}
| 6,722 |
14,618 | 0 | PHP_FUNCTION(pathinfo)
{
zval tmp;
char *path, *dirname;
size_t path_len;
int have_basename;
zend_long opt = PHP_PATHINFO_ALL;
zend_string *ret = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &path, &path_len, &opt) == FAILURE) {
return;
}
have_basename = ((opt & PHP_PATHINFO_BASENAME) == PHP_PATHINFO_BASENAME);
array_init(&tmp);
if ((opt & PHP_PATHINFO_DIRNAME) == PHP_PATHINFO_DIRNAME) {
dirname = estrndup(path, path_len);
php_dirname(dirname, path_len);
if (*dirname) {
add_assoc_string(&tmp, "dirname", dirname);
}
efree(dirname);
}
if (have_basename) {
ret = php_basename(path, path_len, NULL, 0);
add_assoc_str(&tmp, "basename", zend_string_copy(ret));
}
if ((opt & PHP_PATHINFO_EXTENSION) == PHP_PATHINFO_EXTENSION) {
const char *p;
ptrdiff_t idx;
if (!have_basename) {
ret = php_basename(path, path_len, NULL, 0);
}
p = zend_memrchr(ZSTR_VAL(ret), '.', ZSTR_LEN(ret));
if (p) {
idx = p - ZSTR_VAL(ret);
add_assoc_stringl(&tmp, "extension", ZSTR_VAL(ret) + idx + 1, ZSTR_LEN(ret) - idx - 1);
}
}
if ((opt & PHP_PATHINFO_FILENAME) == PHP_PATHINFO_FILENAME) {
const char *p;
ptrdiff_t idx;
/* Have we already looked up the basename? */
if (!have_basename && !ret) {
ret = php_basename(path, path_len, NULL, 0);
}
p = zend_memrchr(ZSTR_VAL(ret), '.', ZSTR_LEN(ret));
idx = p ? (p - ZSTR_VAL(ret)) : ZSTR_LEN(ret);
add_assoc_stringl(&tmp, "filename", ZSTR_VAL(ret), idx);
}
if (ret) {
zend_string_release(ret);
}
if (opt == PHP_PATHINFO_ALL) {
ZVAL_COPY_VALUE(return_value, &tmp);
} else {
zval *element;
if ((element = zend_hash_get_current_data(Z_ARRVAL(tmp))) != NULL) {
ZVAL_DEREF(element);
ZVAL_COPY(return_value, element);
} else {
ZVAL_EMPTY_STRING(return_value);
}
zval_ptr_dtor(&tmp);
}
}
| 6,723 |
23,808 | 0 | static rx_handler_result_t macvlan_handle_frame(struct sk_buff **pskb)
{
struct macvlan_port *port;
struct sk_buff *skb = *pskb;
const struct ethhdr *eth = eth_hdr(skb);
const struct macvlan_dev *vlan;
const struct macvlan_dev *src;
struct net_device *dev;
unsigned int len = 0;
int ret = NET_RX_DROP;
port = macvlan_port_get_rcu(skb->dev);
if (is_multicast_ether_addr(eth->h_dest)) {
src = macvlan_hash_lookup(port, eth->h_source);
if (!src)
/* frame comes from an external address */
macvlan_broadcast(skb, port, NULL,
MACVLAN_MODE_PRIVATE |
MACVLAN_MODE_VEPA |
MACVLAN_MODE_PASSTHRU|
MACVLAN_MODE_BRIDGE);
else if (src->mode == MACVLAN_MODE_VEPA)
/* flood to everyone except source */
macvlan_broadcast(skb, port, src->dev,
MACVLAN_MODE_VEPA |
MACVLAN_MODE_BRIDGE);
else if (src->mode == MACVLAN_MODE_BRIDGE)
/*
* flood only to VEPA ports, bridge ports
* already saw the frame on the way out.
*/
macvlan_broadcast(skb, port, src->dev,
MACVLAN_MODE_VEPA);
return RX_HANDLER_PASS;
}
if (port->passthru)
vlan = list_first_entry(&port->vlans, struct macvlan_dev, list);
else
vlan = macvlan_hash_lookup(port, eth->h_dest);
if (vlan == NULL)
return RX_HANDLER_PASS;
dev = vlan->dev;
if (unlikely(!(dev->flags & IFF_UP))) {
kfree_skb(skb);
return RX_HANDLER_CONSUMED;
}
len = skb->len + ETH_HLEN;
skb = skb_share_check(skb, GFP_ATOMIC);
if (!skb)
goto out;
skb->dev = dev;
skb->pkt_type = PACKET_HOST;
ret = vlan->receive(skb);
out:
macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, 0);
return RX_HANDLER_CONSUMED;
}
| 6,724 |
133,522 | 0 | float MinGlowAlphaToDisableRefresh() {
if (IsAndroidLOrNewer())
return kMinGlowAlphaToDisableRefreshOnL;
return 1.01f;
}
| 6,725 |
117,304 | 0 | xmlXPtrEvalFullXPtr(xmlXPathParserContextPtr ctxt, xmlChar *name) {
if (name == NULL)
name = xmlXPathParseName(ctxt);
if (name == NULL)
XP_ERROR(XPATH_EXPR_ERROR);
while (name != NULL) {
ctxt->error = XPATH_EXPRESSION_OK;
xmlXPtrEvalXPtrPart(ctxt, name);
/* in case of syntax error, break here */
if ((ctxt->error != XPATH_EXPRESSION_OK) &&
(ctxt->error != XML_XPTR_UNKNOWN_SCHEME))
return;
/*
* If the returned value is a non-empty nodeset
* or location set, return here.
*/
if (ctxt->value != NULL) {
xmlXPathObjectPtr obj = ctxt->value;
switch (obj->type) {
case XPATH_LOCATIONSET: {
xmlLocationSetPtr loc = ctxt->value->user;
if ((loc != NULL) && (loc->locNr > 0))
return;
break;
}
case XPATH_NODESET: {
xmlNodeSetPtr loc = ctxt->value->nodesetval;
if ((loc != NULL) && (loc->nodeNr > 0))
return;
break;
}
default:
break;
}
/*
* Evaluating to improper values is equivalent to
* a sub-resource error, clean-up the stack
*/
do {
obj = valuePop(ctxt);
if (obj != NULL) {
xmlXPathFreeObject(obj);
}
} while (obj != NULL);
}
/*
* Is there another XPointer part.
*/
SKIP_BLANKS;
name = xmlXPathParseName(ctxt);
}
}
| 6,726 |
11,221 | 0 | static void netsnmp_session_free(php_snmp_session **session) /* {{{ */
{
if (*session) {
PHP_SNMP_SESSION_FREE(peername);
PHP_SNMP_SESSION_FREE(community);
PHP_SNMP_SESSION_FREE(securityName);
PHP_SNMP_SESSION_FREE(contextEngineID);
efree(*session);
*session = NULL;
}
}
/* }}} */
| 6,727 |
94,359 | 0 | static inline int blk_send_start_stop(struct request_queue *q,
struct gendisk *bd_disk, int data)
{
return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
}
| 6,728 |
168,981 | 0 | bool CredentialManagerImpl::IsZeroClickAllowed() const {
return *auto_signin_enabled_ && !client_->IsIncognito();
}
| 6,729 |
25,464 | 0 | static unsigned long read_pmc(int idx)
{
unsigned long val;
switch (idx) {
case 0:
val = mfpmr(PMRN_PMC0);
break;
case 1:
val = mfpmr(PMRN_PMC1);
break;
case 2:
val = mfpmr(PMRN_PMC2);
break;
case 3:
val = mfpmr(PMRN_PMC3);
break;
default:
printk(KERN_ERR "oops trying to read PMC%d\n", idx);
val = 0;
}
return val;
}
| 6,730 |
183,745 | 1 | virtual void scheduleBeginFrameAndCommit()
{
CCMainThread::postTask(m_proxy->createBeginFrameAndCommitTaskOnCCThread());
}
| 6,731 |
17,869 | 0 | static ssize_t local_preadv(FsContext *ctx, V9fsFidOpenState *fs,
const struct iovec *iov,
int iovcnt, off_t offset)
{
#ifdef CONFIG_PREADV
return preadv(fs->fd, iov, iovcnt, offset);
#else
int err = lseek(fs->fd, offset, SEEK_SET);
if (err == -1) {
return err;
} else {
return readv(fs->fd, iov, iovcnt);
}
#endif
}
| 6,732 |
82,016 | 0 | static int java_analyze_fns( RAnal *anal, ut64 start, ut64 end, int reftype, int depth) {
RBinJavaObj *bin = NULL;// = get_java_bin_obj (anal);
RBinJavaField *method = NULL;
RListIter *methods_iter, *bin_obs_iter;
RList * bin_objs_list = get_java_bin_obj_list (anal);
ut8 analyze_all = 0;
int result = R_ANAL_RET_ERROR;
if (end == UT64_MAX) {
analyze_all = 1;
}
if (!bin_objs_list || r_list_empty (bin_objs_list)) {
r_list_free (bin_objs_list);
return java_analyze_fns_from_buffer (anal, start, end, reftype, depth);
}
r_list_foreach (bin_objs_list, bin_obs_iter, bin) {
java_update_anal_types (anal, bin);
RList *methods_list = (RList *) r_bin_java_get_methods_list (bin);
ut64 loadaddr = bin->loadaddr;
r_list_foreach (methods_list, methods_iter, method) {
if ((method && analyze_all) ||
(check_addr_less_start (method, end) ||
check_addr_in_code (method, end))) {
RAnalFunction *fcn = r_anal_fcn_new ();
fcn->cc = r_str_const (r_anal_cc_default (anal));
java_set_function_prototype (anal, fcn, method);
result = analyze_from_code_attr (anal, fcn, method, loadaddr);
if (result == R_ANAL_RET_ERROR) {
return result;
}
r_anal_fcn_update_tinyrange_bbs (fcn);
r_anal_fcn_tree_insert (&anal->fcn_tree, fcn);
r_list_append (anal->fcns, fcn);
}
} // End of methods loop
}// end of bin_objs list loop
return result;
}
| 6,733 |
15,778 | 0 | static int ahci_state_post_load(void *opaque, int version_id)
{
int i;
struct AHCIDevice *ad;
AHCIState *s = opaque;
for (i = 0; i < s->ports; i++) {
ad = &s->dev[i];
AHCIPortRegs *pr = &ad->port_regs;
map_page(&ad->lst,
((uint64_t)pr->lst_addr_hi << 32) | pr->lst_addr, 1024);
map_page(&ad->res_fis,
((uint64_t)pr->fis_addr_hi << 32) | pr->fis_addr, 256);
/*
* All pending i/o should be flushed out on a migrate. However,
* we might not have cleared the busy_slot since this is done
* in a bh. Also, issue i/o against any slots that are pending.
*/
if ((ad->busy_slot != -1) &&
!(ad->port.ifs[0].status & (BUSY_STAT|DRQ_STAT))) {
pr->cmd_issue &= ~(1 << ad->busy_slot);
ad->busy_slot = -1;
}
check_cmd(s, i);
}
return 0;
}
| 6,734 |
144,690 | 0 | void WebContentsImpl::StoreFocus() {
view_->StoreFocus();
}
| 6,735 |
44,148 | 0 | pipe_poll(struct file *filp, poll_table *wait)
{
unsigned int mask;
struct pipe_inode_info *pipe = filp->private_data;
int nrbufs;
poll_wait(filp, &pipe->wait, wait);
/* Reading only -- no need for acquiring the semaphore. */
nrbufs = pipe->nrbufs;
mask = 0;
if (filp->f_mode & FMODE_READ) {
mask = (nrbufs > 0) ? POLLIN | POLLRDNORM : 0;
if (!pipe->writers && filp->f_version != pipe->w_counter)
mask |= POLLHUP;
}
if (filp->f_mode & FMODE_WRITE) {
mask |= (nrbufs < pipe->buffers) ? POLLOUT | POLLWRNORM : 0;
/*
* Most Unices do not set POLLERR for FIFOs but on Linux they
* behave exactly like pipes for poll().
*/
if (!pipe->readers)
mask |= POLLERR;
}
return mask;
}
| 6,736 |
61,343 | 0 | static void json_print_int(WriterContext *wctx, const char *key, long long int value)
{
JSONContext *json = wctx->priv;
AVBPrint buf;
if (wctx->nb_item[wctx->level])
printf("%s", json->item_sep);
if (!json->compact)
JSON_INDENT();
av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
printf("\"%s\": %lld", json_escape_str(&buf, key, wctx), value);
av_bprint_finalize(&buf, NULL);
}
| 6,737 |
156,172 | 0 | RendererSchedulerImpl::CompositorTaskRunner() {
helper_.CheckOnValidThread();
return compositor_task_queue_;
}
| 6,738 |
67,179 | 0 | static void migrate_page_add(struct page *page, struct list_head *pagelist,
unsigned long flags)
{
/*
* Avoid migrating a page that is shared with others.
*/
if ((flags & MPOL_MF_MOVE_ALL) || page_mapcount(page) == 1) {
if (!isolate_lru_page(page)) {
list_add_tail(&page->lru, pagelist);
inc_node_page_state(page, NR_ISOLATED_ANON +
page_is_file_cache(page));
}
}
}
| 6,739 |
170,692 | 0 | static EAS_RESULT Parse_ins (SDLS_SYNTHESIZER_DATA *pDLSData, EAS_I32 pos, EAS_I32 size)
{
EAS_RESULT result;
EAS_U32 temp;
EAS_I32 chunkPos;
EAS_I32 endChunk;
EAS_I32 lrgnPos;
EAS_I32 lrgnSize;
EAS_I32 lartPos;
EAS_I32 lartSize;
EAS_I32 lar2Pos;
EAS_I32 lar2Size;
EAS_I32 inshPos;
EAS_U32 regionCount;
EAS_U32 locale;
S_DLS_ART_VALUES art;
S_PROGRAM *pProgram;
EAS_U16 artIndex;
/* seek to start of chunk */
if ((result = EAS_HWFileSeek(pDLSData->hwInstData, pDLSData->fileHandle, pos)) != EAS_SUCCESS)
return result;
/* no chunks yet */
lrgnPos = lrgnSize = lartPos = lartSize = lar2Pos = lar2Size = inshPos = artIndex = 0;
/* read to end of chunk */
endChunk = pos + size;
while (pos < endChunk)
{
chunkPos = pos;
/* get the next chunk type */
if ((result = NextChunk(pDLSData, &pos, &temp, &size)) != EAS_SUCCESS)
return result;
/* parse useful chunks */
switch (temp)
{
case CHUNK_INSH:
inshPos = chunkPos + 8;
break;
case CHUNK_LART:
lartPos = chunkPos + 12;
lartSize = size;
break;
case CHUNK_LAR2:
lar2Pos = chunkPos + 12;
lar2Size = size;
break;
case CHUNK_LRGN:
lrgnPos = chunkPos + 12;
lrgnSize = size;
break;
default:
break;
}
}
/* must have an lrgn to be useful */
if (!lrgnPos)
{
{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "DLS ins chunk has no lrgn chunk\n"); */ }
return EAS_ERROR_UNRECOGNIZED_FORMAT;
}
/* must have an insh to be useful */
if (!inshPos)
{
{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "DLS ins chunk has no insh chunk\n"); */ }
return EAS_ERROR_UNRECOGNIZED_FORMAT;
}
/* parse the instrument header */
if ((result = Parse_insh(pDLSData, inshPos, ®ionCount, &locale)) != EAS_SUCCESS)
return result;
/* initialize and parse the global data first */
EAS_HWMemCpy(&art, &defaultArt, sizeof(S_DLS_ART_VALUES));
if (lartPos)
if ((result = Parse_lart(pDLSData, lartPos, lartSize, &art)) != EAS_SUCCESS)
return result;
if (lar2Pos)
if ((result = Parse_lart(pDLSData, lar2Pos, lar2Size, &art)) != EAS_SUCCESS)
return result;
if (art.values[PARAM_MODIFIED])
{
artIndex = (EAS_U16) pDLSData->artCount;
pDLSData->artCount++;
}
/* convert data on second pass */
if (pDLSData->pDLS)
{
if (art.values[PARAM_MODIFIED])
Convert_art(pDLSData, &art, artIndex);
/* setup pointers */
pProgram = &pDLSData->pDLS->pDLSPrograms[pDLSData->instCount];
/* initialize instrument */
pProgram->locale = locale;
pProgram->regionIndex = (EAS_U16) pDLSData->regionCount | FLAG_RGN_IDX_DLS_SYNTH;
}
/* parse the region data */
if ((result = Parse_lrgn(pDLSData, lrgnPos, lrgnSize, artIndex, regionCount)) != EAS_SUCCESS)
return result;
/* bump instrument count */
pDLSData->instCount++;
return EAS_SUCCESS;
}
| 6,740 |
149,518 | 0 | void LoadingDataCollector::RecordFirstContentfulPaint(
const NavigationID& navigation_id,
const base::TimeTicks& first_contentful_paint) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
auto nav_it = inflight_navigations_.find(navigation_id);
if (nav_it != inflight_navigations_.end())
nav_it->second->first_contentful_paint = first_contentful_paint;
}
| 6,741 |
22,611 | 0 | inline int task_curr(const struct task_struct *p)
{
return cpu_curr(task_cpu(p)) == p;
}
| 6,742 |
148,256 | 0 | PepperRendererConnection::PepperRendererConnection(int render_process_id)
: BrowserMessageFilter(kFilteredMessageClasses,
arraysize(kFilteredMessageClasses)),
render_process_id_(render_process_id) {
in_process_host_.reset(new BrowserPpapiHostImpl(this,
ppapi::PpapiPermissions(),
"",
base::FilePath(),
base::FilePath(),
true /* in_process */,
false /* external_plugin */));
}
| 6,743 |
172,281 | 0 | static jint android_net_wifi_start_rssi_monitoring_native(JNIEnv *env, jclass cls, jint iface,
jint idx, jbyte maxRssi, jbyte minRssi) {
JNIHelper helper(env);
wifi_interface_handle handle = getIfaceHandle(helper, cls, iface);
ALOGD("Start Rssi monitoring = %p", handle);
ALOGD("MinRssi %d MaxRssi %d", minRssi, maxRssi);
wifi_error ret;
wifi_request_id id = idx;
wifi_rssi_event_handler eh;
eh.on_rssi_threshold_breached = onRssiThresholdbreached;
ret = hal_fn.wifi_start_rssi_monitoring(id, handle, maxRssi, minRssi, eh);
return ret;
}
| 6,744 |
23,646 | 0 | isdn_net_getpeer(isdn_net_ioctl_phone *phone, isdn_net_ioctl_phone __user *peer)
{
isdn_net_dev *p = isdn_net_findif(phone->name);
int ch, dv, idx;
if (!p)
return -ENODEV;
/*
* Theoretical race: while this executes, the remote number might
* become invalid (hang up) or change (new connection), resulting
* in (partially) wrong number copied to user. This race
* currently ignored.
*/
ch = p->local->isdn_channel;
dv = p->local->isdn_device;
if(ch < 0 && dv < 0)
return -ENOTCONN;
idx = isdn_dc2minor(dv, ch);
if (idx <0 )
return -ENODEV;
/* for pre-bound channels, we need this extra check */
if (strncmp(dev->num[idx], "???", 3) == 0)
return -ENOTCONN;
strncpy(phone->phone, dev->num[idx], ISDN_MSNLEN);
phone->outgoing = USG_OUTGOING(dev->usage[idx]);
if (copy_to_user(peer, phone, sizeof(*peer)))
return -EFAULT;
return 0;
}
| 6,745 |
84,204 | 0 | selCopy(SEL *sel)
{
l_int32 sx, sy, cx, cy, i, j;
SEL *csel;
PROCNAME("selCopy");
if (!sel)
return (SEL *)ERROR_PTR("sel not defined", procName, NULL);
if ((csel = (SEL *)LEPT_CALLOC(1, sizeof(SEL))) == NULL)
return (SEL *)ERROR_PTR("csel not made", procName, NULL);
selGetParameters(sel, &sy, &sx, &cy, &cx);
csel->sy = sy;
csel->sx = sx;
csel->cy = cy;
csel->cx = cx;
if ((csel->data = create2dIntArray(sy, sx)) == NULL) {
LEPT_FREE(csel);
return (SEL *)ERROR_PTR("sel data not made", procName, NULL);
}
for (i = 0; i < sy; i++)
for (j = 0; j < sx; j++)
csel->data[i][j] = sel->data[i][j];
if (sel->name)
csel->name = stringNew(sel->name);
return csel;
}
| 6,746 |
124,829 | 0 | LayoutUnit RenderBox::computeContentLogicalHeight(const Length& height, LayoutUnit intrinsicContentHeight) const
{
LayoutUnit heightIncludingScrollbar = computeContentAndScrollbarLogicalHeightUsing(height, intrinsicContentHeight);
if (heightIncludingScrollbar == -1)
return -1;
return std::max<LayoutUnit>(0, adjustContentBoxLogicalHeightForBoxSizing(heightIncludingScrollbar) - scrollbarLogicalHeight());
}
| 6,747 |
123,847 | 0 | WebKit::WebPlugin* RenderViewImpl::CreatePluginReplacement(
const base::FilePath& file_path) {
return GetContentClient()->renderer()->CreatePluginReplacement(
this, file_path);
}
| 6,748 |
129,015 | 0 | bool writeCryptoKey(const blink::WebCryptoKey& key)
{
append(static_cast<uint8_t>(CryptoKeyTag));
switch (key.algorithm().paramsType()) {
case blink::WebCryptoKeyAlgorithmParamsTypeAes:
doWriteAesKey(key);
break;
case blink::WebCryptoKeyAlgorithmParamsTypeHmac:
doWriteHmacKey(key);
break;
case blink::WebCryptoKeyAlgorithmParamsTypeRsaHashed:
doWriteRsaHashedKey(key);
break;
case blink::WebCryptoKeyAlgorithmParamsTypeNone:
ASSERT_NOT_REACHED();
return false;
}
doWriteKeyUsages(key.usages(), key.extractable());
blink::WebVector<uint8_t> keyData;
if (!blink::Platform::current()->crypto()->serializeKeyForClone(key, keyData))
return false;
doWriteUint32(keyData.size());
append(keyData.data(), keyData.size());
return true;
}
| 6,749 |
115,056 | 0 | void TestingAutomationProvider::WaitForBookmarkModelToLoad(
int handle,
IPC::Message* reply_message) {
if (browser_tracker_->ContainsHandle(handle)) {
Browser* browser = browser_tracker_->GetResource(handle);
BookmarkModel* model = browser->profile()->GetBookmarkModel();
if (model->IsLoaded()) {
AutomationMsg_WaitForBookmarkModelToLoad::WriteReplyParams(
reply_message, true);
Send(reply_message);
} else {
new AutomationProviderBookmarkModelObserver(this, reply_message,
model);
}
}
}
| 6,750 |
35,826 | 0 | static int vcpu_enter_guest(struct kvm_vcpu *vcpu)
{
int r;
bool req_int_win = !irqchip_in_kernel(vcpu->kvm) &&
vcpu->run->request_interrupt_window;
bool req_immediate_exit = false;
if (vcpu->requests) {
if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu))
kvm_mmu_unload(vcpu);
if (kvm_check_request(KVM_REQ_MIGRATE_TIMER, vcpu))
__kvm_migrate_timers(vcpu);
if (kvm_check_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu))
kvm_gen_update_masterclock(vcpu->kvm);
if (kvm_check_request(KVM_REQ_GLOBAL_CLOCK_UPDATE, vcpu))
kvm_gen_kvmclock_update(vcpu);
if (kvm_check_request(KVM_REQ_CLOCK_UPDATE, vcpu)) {
r = kvm_guest_time_update(vcpu);
if (unlikely(r))
goto out;
}
if (kvm_check_request(KVM_REQ_MMU_SYNC, vcpu))
kvm_mmu_sync_roots(vcpu);
if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu))
kvm_x86_ops->tlb_flush(vcpu);
if (kvm_check_request(KVM_REQ_REPORT_TPR_ACCESS, vcpu)) {
vcpu->run->exit_reason = KVM_EXIT_TPR_ACCESS;
r = 0;
goto out;
}
if (kvm_check_request(KVM_REQ_TRIPLE_FAULT, vcpu)) {
vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;
r = 0;
goto out;
}
if (kvm_check_request(KVM_REQ_DEACTIVATE_FPU, vcpu)) {
vcpu->fpu_active = 0;
kvm_x86_ops->fpu_deactivate(vcpu);
}
if (kvm_check_request(KVM_REQ_APF_HALT, vcpu)) {
/* Page is swapped out. Do synthetic halt */
vcpu->arch.apf.halted = true;
r = 1;
goto out;
}
if (kvm_check_request(KVM_REQ_STEAL_UPDATE, vcpu))
record_steal_time(vcpu);
if (kvm_check_request(KVM_REQ_NMI, vcpu))
process_nmi(vcpu);
if (kvm_check_request(KVM_REQ_PMU, vcpu))
kvm_handle_pmu_event(vcpu);
if (kvm_check_request(KVM_REQ_PMI, vcpu))
kvm_deliver_pmi(vcpu);
if (kvm_check_request(KVM_REQ_SCAN_IOAPIC, vcpu))
vcpu_scan_ioapic(vcpu);
}
if (kvm_check_request(KVM_REQ_EVENT, vcpu) || req_int_win) {
kvm_apic_accept_events(vcpu);
if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) {
r = 1;
goto out;
}
if (inject_pending_event(vcpu, req_int_win) != 0)
req_immediate_exit = true;
/* enable NMI/IRQ window open exits if needed */
else if (vcpu->arch.nmi_pending)
kvm_x86_ops->enable_nmi_window(vcpu);
else if (kvm_cpu_has_injectable_intr(vcpu) || req_int_win)
kvm_x86_ops->enable_irq_window(vcpu);
if (kvm_lapic_enabled(vcpu)) {
/*
* Update architecture specific hints for APIC
* virtual interrupt delivery.
*/
if (kvm_x86_ops->hwapic_irr_update)
kvm_x86_ops->hwapic_irr_update(vcpu,
kvm_lapic_find_highest_irr(vcpu));
update_cr8_intercept(vcpu);
kvm_lapic_sync_to_vapic(vcpu);
}
}
r = kvm_mmu_reload(vcpu);
if (unlikely(r)) {
goto cancel_injection;
}
preempt_disable();
kvm_x86_ops->prepare_guest_switch(vcpu);
if (vcpu->fpu_active)
kvm_load_guest_fpu(vcpu);
kvm_load_guest_xcr0(vcpu);
vcpu->mode = IN_GUEST_MODE;
srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
/* We should set ->mode before check ->requests,
* see the comment in make_all_cpus_request.
*/
smp_mb__after_srcu_read_unlock();
local_irq_disable();
if (vcpu->mode == EXITING_GUEST_MODE || vcpu->requests
|| need_resched() || signal_pending(current)) {
vcpu->mode = OUTSIDE_GUEST_MODE;
smp_wmb();
local_irq_enable();
preempt_enable();
vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
r = 1;
goto cancel_injection;
}
if (req_immediate_exit)
smp_send_reschedule(vcpu->cpu);
kvm_guest_enter();
if (unlikely(vcpu->arch.switch_db_regs)) {
set_debugreg(0, 7);
set_debugreg(vcpu->arch.eff_db[0], 0);
set_debugreg(vcpu->arch.eff_db[1], 1);
set_debugreg(vcpu->arch.eff_db[2], 2);
set_debugreg(vcpu->arch.eff_db[3], 3);
set_debugreg(vcpu->arch.dr6, 6);
}
trace_kvm_entry(vcpu->vcpu_id);
kvm_x86_ops->run(vcpu);
/*
* Do this here before restoring debug registers on the host. And
* since we do this before handling the vmexit, a DR access vmexit
* can (a) read the correct value of the debug registers, (b) set
* KVM_DEBUGREG_WONT_EXIT again.
*/
if (unlikely(vcpu->arch.switch_db_regs & KVM_DEBUGREG_WONT_EXIT)) {
int i;
WARN_ON(vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP);
kvm_x86_ops->sync_dirty_debug_regs(vcpu);
for (i = 0; i < KVM_NR_DB_REGS; i++)
vcpu->arch.eff_db[i] = vcpu->arch.db[i];
}
/*
* If the guest has used debug registers, at least dr7
* will be disabled while returning to the host.
* If we don't have active breakpoints in the host, we don't
* care about the messed up debug address registers. But if
* we have some of them active, restore the old state.
*/
if (hw_breakpoint_active())
hw_breakpoint_restore();
vcpu->arch.last_guest_tsc = kvm_x86_ops->read_l1_tsc(vcpu,
native_read_tsc());
vcpu->mode = OUTSIDE_GUEST_MODE;
smp_wmb();
/* Interrupt is enabled by handle_external_intr() */
kvm_x86_ops->handle_external_intr(vcpu);
++vcpu->stat.exits;
/*
* We must have an instruction between local_irq_enable() and
* kvm_guest_exit(), so the timer interrupt isn't delayed by
* the interrupt shadow. The stat.exits increment will do nicely.
* But we need to prevent reordering, hence this barrier():
*/
barrier();
kvm_guest_exit();
preempt_enable();
vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
/*
* Profile KVM exit RIPs:
*/
if (unlikely(prof_on == KVM_PROFILING)) {
unsigned long rip = kvm_rip_read(vcpu);
profile_hit(KVM_PROFILING, (void *)rip);
}
if (unlikely(vcpu->arch.tsc_always_catchup))
kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu);
if (vcpu->arch.apic_attention)
kvm_lapic_sync_from_vapic(vcpu);
r = kvm_x86_ops->handle_exit(vcpu);
return r;
cancel_injection:
kvm_x86_ops->cancel_injection(vcpu);
if (unlikely(vcpu->arch.apic_attention))
kvm_lapic_sync_from_vapic(vcpu);
out:
return r;
}
| 6,751 |
127,162 | 0 | base::FilePath DownloadPathReservationTrackerTest::GetPathInDownloadsDirectory(
const base::FilePath::CharType* suffix) {
return default_download_path().Append(suffix).NormalizePathSeparators();
}
| 6,752 |
34,555 | 0 | static ssize_t macvtap_aio_write(struct kiocb *iocb, const struct iovec *iv,
unsigned long count, loff_t pos)
{
struct file *file = iocb->ki_filp;
ssize_t result = -ENOLINK;
struct macvtap_queue *q = file->private_data;
result = macvtap_get_user(q, NULL, iv, iov_length(iv, count), count,
file->f_flags & O_NONBLOCK);
return result;
}
| 6,753 |
126,456 | 0 | bool BrowserWindowGtk::UsingCustomPopupFrame() const {
GtkThemeService* theme_provider = GtkThemeService::GetFrom(
browser()->profile());
return !theme_provider->UsingNativeTheme() && browser()->is_type_popup();
}
| 6,754 |
25,276 | 0 | static void armv7pmu_reset(void *info)
{
u32 idx, nb_cnt = armpmu->num_events;
/* The counter and interrupt enable registers are unknown at reset. */
for (idx = 1; idx < nb_cnt; ++idx)
armv7pmu_disable_event(NULL, idx);
/* Initialize & Reset PMNC: C and P bits */
armv7_pmnc_write(ARMV7_PMNC_P | ARMV7_PMNC_C);
}
| 6,755 |
68,461 | 0 | static bool name_is_in_groupnames(char *name, char **groupnames)
{
while (groupnames != NULL) {
if (strcmp(name, *groupnames) == 0)
return true;
groupnames++;
}
return false;
}
| 6,756 |
46,388 | 0 | ssize_t splice_from_pipe(struct pipe_inode_info *pipe, struct file *out,
loff_t *ppos, size_t len, unsigned int flags,
splice_actor *actor)
{
ssize_t ret;
struct splice_desc sd = {
.total_len = len,
.flags = flags,
.pos = *ppos,
.u.file = out,
};
pipe_lock(pipe);
ret = __splice_from_pipe(pipe, &sd, actor);
pipe_unlock(pipe);
return ret;
}
| 6,757 |
153,841 | 0 | GLboolean GLES2Implementation::UnmapBuffer(GLenum target) {
GPU_CLIENT_SINGLE_THREAD_CHECK();
GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUnmapBuffer("
<< GLES2Util::GetStringEnum(target) << ")");
switch (target) {
case GL_ARRAY_BUFFER:
case GL_ATOMIC_COUNTER_BUFFER:
case GL_ELEMENT_ARRAY_BUFFER:
case GL_COPY_READ_BUFFER:
case GL_COPY_WRITE_BUFFER:
case GL_PIXEL_PACK_BUFFER:
case GL_PIXEL_UNPACK_BUFFER:
case GL_SHADER_STORAGE_BUFFER:
case GL_TRANSFORM_FEEDBACK_BUFFER:
case GL_UNIFORM_BUFFER:
break;
default:
SetGLError(GL_INVALID_ENUM, "glUnmapBuffer", "invalid target");
return GL_FALSE;
}
GLuint buffer = GetBoundBufferHelper(target);
if (buffer == 0) {
SetGLError(GL_INVALID_OPERATION, "glUnmapBuffer", "no buffer bound");
return GL_FALSE;
}
auto iter = mapped_buffer_range_map_.find(buffer);
if (iter == mapped_buffer_range_map_.end()) {
SetGLError(GL_INVALID_OPERATION, "glUnmapBuffer", "buffer is unmapped");
return GL_FALSE;
}
bool was_mapped_by_readback_tracker = false;
if (auto* buffer_object =
readback_buffer_shadow_tracker_->GetBuffer(buffer)) {
was_mapped_by_readback_tracker = buffer_object->UnmapReadbackShm();
}
if (!was_mapped_by_readback_tracker) {
helper_->UnmapBuffer(target);
InvalidateReadbackBufferShadowDataCHROMIUM(GetBoundBufferHelper(target));
}
RemoveMappedBufferRangeById(buffer);
GPU_CLIENT_LOG(" returned " << GL_TRUE);
CheckGLError();
return GL_TRUE;
}
| 6,758 |
125,817 | 0 | bool ParamTraits<LOGFONT>::Read(const Message* m, PickleIterator* iter,
param_type* r) {
const char *data;
int data_size = 0;
if (m->ReadData(iter, &data, &data_size) && data_size == sizeof(LOGFONT)) {
const LOGFONT *font = reinterpret_cast<LOGFONT*>(const_cast<char*>(data));
if (_tcsnlen(font->lfFaceName, LF_FACESIZE) < LF_FACESIZE) {
memcpy(r, data, sizeof(LOGFONT));
return true;
}
}
NOTREACHED();
return false;
}
| 6,759 |
66,427 | 0 | static inline TCGMemOp mo_stacksize(DisasContext *s)
{
return CODE64(s) ? MO_64 : s->ss32 ? MO_32 : MO_16;
}
| 6,760 |
51,545 | 0 | static void tcp_ecn_withdraw_cwr(struct tcp_sock *tp)
{
tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}
| 6,761 |
106,098 | 0 | JSValue jsTestObjCONST_VALUE_4(ExecState* exec, JSValue, const Identifier&)
{
UNUSED_PARAM(exec);
return jsNumber(static_cast<int>(4));
}
| 6,762 |
107,262 | 0 | void AutomationProvider::ReloadAsync(int tab_handle) {
if (tab_tracker_->ContainsHandle(tab_handle)) {
NavigationController* tab = tab_tracker_->GetResource(tab_handle);
if (!tab) {
NOTREACHED();
return;
}
const bool check_for_repost = true;
tab->Reload(check_for_repost);
}
}
| 6,763 |
186,714 | 1 | IDNSpoofChecker::IDNSpoofChecker() {
UErrorCode status = U_ZERO_ERROR;
checker_ = uspoof_open(&status);
if (U_FAILURE(status)) {
checker_ = nullptr;
return;
}
// At this point, USpoofChecker has all the checks enabled except
// for USPOOF_CHAR_LIMIT (USPOOF_{RESTRICTION_LEVEL, INVISIBLE,
// MIXED_SCRIPT_CONFUSABLE, WHOLE_SCRIPT_CONFUSABLE, MIXED_NUMBERS, ANY_CASE})
// This default configuration is adjusted below as necessary.
// Set the restriction level to high. It allows mixing Latin with one logical
// CJK script (+ COMMON and INHERITED), but does not allow any other script
// mixing (e.g. Latin + Cyrillic, Latin + Armenian, Cyrillic + Greek). Note
// that each of {Han + Bopomofo} for Chinese, {Hiragana, Katakana, Han} for
// Japanese, and {Hangul, Han} for Korean is treated as a single logical
// script.
// See http://www.unicode.org/reports/tr39/#Restriction_Level_Detection
uspoof_setRestrictionLevel(checker_, USPOOF_HIGHLY_RESTRICTIVE);
// Sets allowed characters in IDN labels and turns on USPOOF_CHAR_LIMIT.
SetAllowedUnicodeSet(&status);
// Enable the return of auxillary (non-error) information.
// We used to disable WHOLE_SCRIPT_CONFUSABLE check explicitly, but as of
// ICU 58.1, WSC is a no-op in a single string check API.
int32_t checks = uspoof_getChecks(checker_, &status) | USPOOF_AUX_INFO;
uspoof_setChecks(checker_, checks, &status);
// Four characters handled differently by IDNA 2003 and IDNA 2008. UTS46
// transitional processing treats them as IDNA 2003 does; maps U+00DF and
// U+03C2 and drops U+200[CD].
deviation_characters_ = icu::UnicodeSet(
UNICODE_STRING_SIMPLE("[\\u00df\\u03c2\\u200c\\u200d]"), status);
deviation_characters_.freeze();
// Latin letters outside ASCII. 'Script_Extensions=Latin' is not necessary
// because additional characters pulled in with scx=Latn are not included in
// the allowed set.
non_ascii_latin_letters_ =
icu::UnicodeSet(UNICODE_STRING_SIMPLE("[[:Latin:] - [a-zA-Z]]"), status);
non_ascii_latin_letters_.freeze();
// The following two sets are parts of |dangerous_patterns_|.
kana_letters_exceptions_ = icu::UnicodeSet(
UNICODE_STRING_SIMPLE("[\\u3078-\\u307a\\u30d8-\\u30da\\u30fb-\\u30fe]"),
status);
kana_letters_exceptions_.freeze();
combining_diacritics_exceptions_ =
icu::UnicodeSet(UNICODE_STRING_SIMPLE("[\\u0300-\\u0339]"), status);
combining_diacritics_exceptions_.freeze();
// These Cyrillic letters look like Latin. A domain label entirely made of
// these letters is blocked as a simplified whole-script-spoofable.
cyrillic_letters_latin_alike_ = icu::UnicodeSet(
icu::UnicodeString::fromUTF8("[асԁеһіјӏорԛѕԝхуъЬҽпгѵѡ]"), status);
cyrillic_letters_latin_alike_.freeze();
cyrillic_letters_ =
icu::UnicodeSet(UNICODE_STRING_SIMPLE("[[:Cyrl:]]"), status);
cyrillic_letters_.freeze();
DCHECK(U_SUCCESS(status));
// This set is used to determine whether or not to apply a slow
// transliteration to remove diacritics to a given hostname before the
// confusable skeleton calculation for comparison with top domain names. If
// it has any character outside the set, the expensive step will be skipped
// because it cannot match any of top domain names.
// The last ([\u0300-\u0339] is a shorthand for "[:Identifier_Status=Allowed:]
// & [:Script_Extensions=Inherited:] - [\\u200C\\u200D]". The latter is a
// subset of the former but it does not matter because hostnames with
// characters outside the latter set would be rejected in an earlier step.
lgc_letters_n_ascii_ = icu::UnicodeSet(
UNICODE_STRING_SIMPLE("[[:Latin:][:Greek:][:Cyrillic:][0-9\\u002e_"
"\\u002d][\\u0300-\\u0339]]"),
status);
lgc_letters_n_ascii_.freeze();
// Used for diacritics-removal before the skeleton calculation. Add
// "ł > l; ø > o; đ > d" that are not handled by "NFD; Nonspacing mark
// removal; NFC".
// TODO(jshin): Revisit "ł > l; ø > o" mapping.
UParseError parse_error;
diacritic_remover_.reset(icu::Transliterator::createFromRules(
UNICODE_STRING_SIMPLE("DropAcc"),
icu::UnicodeString::fromUTF8("::NFD; ::[:Nonspacing Mark:] Remove; ::NFC;"
" ł > l; ø > o; đ > d;"),
UTRANS_FORWARD, parse_error, status));
// Supplement the Unicode confusable list by the following mapping.
// - {U+00FE (þ), U+03FC (ϼ), U+048F (ҏ)} => p
// - {U+0127 (ħ), U+043D (н), U+045B (ћ), U+04A3 (ң), U+04A5 (ҥ),
// U+04C8 (ӈ), U+0527 (ԧ), U+0529 (ԩ)} => h
// - {U+0138 (ĸ), U+03BA (κ), U+043A (к), U+049B (қ), U+049D (ҝ),
// U+049F (ҟ), U+04A1(ҡ), U+04C4 (ӄ), U+051F (ԟ)} => k
// - {U+0167 (ŧ), U+0442 (т), U+04AD (ҭ)} => t
// - {U+0185 (ƅ), U+044C (ь), U+048D (ҍ), U+0432 (в)} => b
// - {U+03C9 (ω), U+0448 (ш), U+0449 (щ)} => w
// - {U+043C (м), U+04CE (ӎ)} => m
// - U+043F(п) => n
// - U+0491 (ґ) => r
// - U+0493 (ғ) => f
// - U+04AB (ҫ) => c
// - U+04B1 (ұ) => y
// - U+03C7 (χ), U+04B3 (ҳ), U+04FD (ӽ), U+04FF (ӿ) => x
// - U+04BD (ҽ), U+04BF (ҿ) => e
// - U+04CF (ӏ) => i (on Windows), l (elsewhere)
// - U+0503 (ԃ) => d
// - U+050D (ԍ) => g
// - U+0D1F (ട) => s
extra_confusable_mapper_.reset(icu::Transliterator::createFromRules(
UNICODE_STRING_SIMPLE("ExtraConf"),
icu::UnicodeString::fromUTF8("[þϼҏ] > p; [ħнћңҥӈԧԩ] > h;"
"[ĸκкқҝҟҡӄԟ] > k; [ŧтҭ] > t;"
"[ƅьҍв] > b; [ωшщ] > w; [мӎ] > m;"
"п > n; ћ > h; ґ > r; ғ > f; ҫ > c;"
"ұ > y; [χҳӽӿ] > x; [ҽҿ] > e;"
#if defined(OS_WIN)
"ӏ > i;"
#else
"ӏ > l;"
#endif
"ԃ > d; ԍ > g; ട > s"),
UTRANS_FORWARD, parse_error, status));
DCHECK(U_SUCCESS(status))
<< "Spoofchecker initalization failed due to an error: "
<< u_errorName(status);
}
| 6,764 |
159,173 | 0 | void DownloadItemImpl::OnDownloadCompleting() {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (state_ != IN_PROGRESS_INTERNAL)
return;
DVLOG(20) << __func__ << "() " << DebugString(true);
DCHECK(!GetTargetFilePath().empty());
DCHECK(!IsDangerous());
DCHECK(download_file_.get());
DownloadFile::RenameCompletionCallback callback =
base::Bind(&DownloadItemImpl::OnDownloadRenamedToFinalName,
weak_ptr_factory_.GetWeakPtr());
GetDownloadTaskRunner()->PostTask(
FROM_HERE,
base::BindOnce(&DownloadFile::RenameAndAnnotate,
base::Unretained(download_file_.get()),
GetTargetFilePath(),
delegate_->GetApplicationClientIdForFileScanning(),
GetURL(), GetReferrerUrl(), callback));
}
| 6,765 |
181,618 | 1 | static int emulate_store_desc_ptr(struct x86_emulate_ctxt *ctxt,
void (*get)(struct x86_emulate_ctxt *ctxt,
struct desc_ptr *ptr))
{
struct desc_ptr desc_ptr;
if (ctxt->mode == X86EMUL_MODE_PROT64)
ctxt->op_bytes = 8;
get(ctxt, &desc_ptr);
if (ctxt->op_bytes == 2) {
ctxt->op_bytes = 4;
desc_ptr.address &= 0x00ffffff;
}
/* Disable writeback. */
ctxt->dst.type = OP_NONE;
return segmented_write(ctxt, ctxt->dst.addr.mem,
&desc_ptr, 2 + ctxt->op_bytes);
}
| 6,766 |
60,250 | 0 | static long keyring_read(const struct key *keyring,
char __user *buffer, size_t buflen)
{
struct keyring_read_iterator_context ctx;
unsigned long nr_keys;
int ret;
kenter("{%d},,%zu", key_serial(keyring), buflen);
if (buflen & (sizeof(key_serial_t) - 1))
return -EINVAL;
nr_keys = keyring->keys.nr_leaves_on_tree;
if (nr_keys == 0)
return 0;
/* Calculate how much data we could return */
if (!buffer || !buflen)
return nr_keys * sizeof(key_serial_t);
/* Copy the IDs of the subscribed keys into the buffer */
ctx.buffer = (key_serial_t __user *)buffer;
ctx.buflen = buflen;
ctx.count = 0;
ret = assoc_array_iterate(&keyring->keys, keyring_read_iterator, &ctx);
if (ret < 0) {
kleave(" = %d [iterate]", ret);
return ret;
}
kleave(" = %zu [ok]", ctx.count);
return ctx.count;
}
| 6,767 |
113,690 | 0 | xsltRegisterAllFunctions(xmlXPathContextPtr ctxt)
{
xmlXPathRegisterFunc(ctxt, (const xmlChar *) "current",
xsltCurrentFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *) "document",
xsltDocumentFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *) "key", xsltKeyFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *) "unparsed-entity-uri",
xsltUnparsedEntityURIFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *) "format-number",
xsltFormatNumberFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *) "generate-id",
xsltGenerateIdFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *) "system-property",
xsltSystemPropertyFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *) "element-available",
xsltElementAvailableFunction);
xmlXPathRegisterFunc(ctxt, (const xmlChar *) "function-available",
xsltFunctionAvailableFunction);
}
| 6,768 |
170,492 | 0 | status_t Parcel::restartWrite(size_t desired)
{
if (mOwner) {
freeData();
return continueWrite(desired);
}
uint8_t* data = (uint8_t*)realloc(mData, desired);
if (!data && desired > mDataCapacity) {
mError = NO_MEMORY;
return NO_MEMORY;
}
releaseObjects();
if (data) {
LOG_ALLOC("Parcel %p: restart from %zu to %zu capacity", this, mDataCapacity, desired);
pthread_mutex_lock(&gParcelGlobalAllocSizeLock);
gParcelGlobalAllocSize += desired;
gParcelGlobalAllocSize -= mDataCapacity;
pthread_mutex_unlock(&gParcelGlobalAllocSizeLock);
mData = data;
mDataCapacity = desired;
}
mDataSize = mDataPos = 0;
ALOGV("restartWrite Setting data size of %p to %zu", this, mDataSize);
ALOGV("restartWrite Setting data pos of %p to %zu", this, mDataPos);
free(mObjects);
mObjects = NULL;
mObjectsSize = mObjectsCapacity = 0;
mNextObjectHint = 0;
mHasFds = false;
mFdsKnown = true;
mAllowFds = true;
return NO_ERROR;
}
| 6,769 |
59,450 | 0 | xmlParseAttribute(xmlParserCtxtPtr ctxt, xmlChar **value) {
const xmlChar *name;
xmlChar *val;
*value = NULL;
GROW;
name = xmlParseName(ctxt);
if (name == NULL) {
xmlFatalErrMsg(ctxt, XML_ERR_NAME_REQUIRED,
"error parsing attribute name\n");
return(NULL);
}
/*
* read the value
*/
SKIP_BLANKS;
if (RAW == '=') {
NEXT;
SKIP_BLANKS;
val = xmlParseAttValue(ctxt);
ctxt->instate = XML_PARSER_CONTENT;
} else {
xmlFatalErrMsgStr(ctxt, XML_ERR_ATTRIBUTE_WITHOUT_VALUE,
"Specification mandates value for attribute %s\n", name);
return(NULL);
}
/*
* Check that xml:lang conforms to the specification
* No more registered as an error, just generate a warning now
* since this was deprecated in XML second edition
*/
if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
if (!xmlCheckLanguageID(val)) {
xmlWarningMsg(ctxt, XML_WAR_LANG_VALUE,
"Malformed value for xml:lang : %s\n",
val, NULL);
}
}
/*
* Check that xml:space conforms to the specification
*/
if (xmlStrEqual(name, BAD_CAST "xml:space")) {
if (xmlStrEqual(val, BAD_CAST "default"))
*(ctxt->space) = 0;
else if (xmlStrEqual(val, BAD_CAST "preserve"))
*(ctxt->space) = 1;
else {
xmlWarningMsg(ctxt, XML_WAR_SPACE_VALUE,
"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
val, NULL);
}
}
*value = val;
return(name);
}
| 6,770 |
74,135 | 0 | config_ntpd(
config_tree *ptree
)
{
config_nic_rules(ptree);
io_open_sockets();
config_monitor(ptree);
config_auth(ptree);
config_tos(ptree);
config_access(ptree);
config_tinker(ptree);
config_system_opts(ptree);
config_logconfig(ptree);
config_phone(ptree);
config_setvar(ptree);
config_ttl(ptree);
config_trap(ptree);
config_vars(ptree);
config_other_modes(ptree);
config_peers(ptree);
config_unpeers(ptree);
config_fudge(ptree);
config_qos(ptree);
#ifdef TEST_BLOCKING_WORKER
{
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
getaddrinfo_sometime("www.cnn.com", "ntp", &hints,
INITIAL_DNS_RETRY,
gai_test_callback, (void *)1);
hints.ai_family = AF_INET6;
getaddrinfo_sometime("ipv6.google.com", "ntp", &hints,
INITIAL_DNS_RETRY,
gai_test_callback, (void *)0x600);
}
#endif
}
| 6,771 |
108,880 | 0 | WebKit::WebNode RenderViewImpl::GetFocusedNode() const {
if (!webview())
return WebNode();
WebFrame* focused_frame = webview()->focusedFrame();
if (focused_frame) {
WebDocument doc = focused_frame->document();
if (!doc.isNull())
return doc.focusedNode();
}
return WebNode();
}
| 6,772 |
106,471 | 0 | void WebPageProxy::didChangeScrollbarsForMainFrame(bool hasHorizontalScrollbar, bool hasVerticalScrollbar)
{
m_mainFrameHasHorizontalScrollbar = hasHorizontalScrollbar;
m_mainFrameHasVerticalScrollbar = hasVerticalScrollbar;
m_pageClient->didChangeScrollbarsForMainFrame();
}
| 6,773 |
6,439 | 0 | MenuCacheItem* menu_cache_item_from_path( MenuCache* cache, const char* path )
{
char** names = g_strsplit( path + 1, "/", -1 );
int i;
MenuCacheDir* dir;
MenuCacheItem* item = NULL;
if( !names )
return NULL;
if( G_UNLIKELY(!names[0]) )
{
g_strfreev(names);
return NULL;
}
/* the topmost dir of the path should be the root menu dir. */
MENU_CACHE_LOCK;
dir = cache->root_dir;
if( G_UNLIKELY(!dir) || strcmp(names[0], MENU_CACHE_ITEM(dir)->id) != 0 )
goto _end;
for( i = 1; names[i]; ++i )
{
GSList* l;
item = NULL;
if( !dir )
break;
l = dir->children;
dir = NULL;
for( ; l; l = l->next )
{
item = MENU_CACHE_ITEM(l->data);
if( g_strcmp0( item->id, names[i] ) == 0 )
{
if( item->type == MENU_CACHE_TYPE_DIR )
dir = MENU_CACHE_DIR(item);
break;
}
item = NULL;
}
if( !item )
break;
}
if(item)
menu_cache_item_ref(item);
_end:
MENU_CACHE_UNLOCK;
g_strfreev(names);
return item;
}
| 6,774 |
171,442 | 0 | static vpx_codec_err_t ctrl_set_postproc(vpx_codec_alg_priv_t *ctx,
va_list args) {
#if CONFIG_VP9_POSTPROC
vp8_postproc_cfg_t *data = va_arg(args, vp8_postproc_cfg_t *);
if (data) {
ctx->postproc_cfg_set = 1;
ctx->postproc_cfg = *((vp8_postproc_cfg_t *)data);
return VPX_CODEC_OK;
} else {
return VPX_CODEC_INVALID_PARAM;
}
#else
(void)ctx;
(void)args;
return VPX_CODEC_INCAPABLE;
#endif
}
| 6,775 |
109,368 | 0 | void InspectorResourceAgent::didReceiveScriptResponse(unsigned long identifier)
{
m_resourcesData->setResourceType(IdentifiersFactory::requestId(identifier), InspectorPageAgent::ScriptResource);
}
| 6,776 |
125,740 | 0 | void TabSpecificContentSettings::CookieChanged(
int render_process_id,
int render_view_id,
const GURL& url,
const GURL& frame_url,
const std::string& cookie_line,
const net::CookieOptions& options,
bool blocked_by_policy) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
TabSpecificContentSettings* settings = Get(render_process_id, render_view_id);
if (settings)
settings->OnCookieChanged(url, frame_url, cookie_line, options,
blocked_by_policy);
}
| 6,777 |
80,601 | 0 | GF_Err trgt_Size(GF_Box *s)
{
GF_TrackGroupBox *ptr = (GF_TrackGroupBox *)s;
ptr->size+= 4;
return GF_OK;
}
| 6,778 |
124,184 | 0 | AccessTokenStore* ContentBrowserClient::CreateAccessTokenStore() {
return NULL;
}
| 6,779 |
141,085 | 0 | IntersectionObserverController* Document::GetIntersectionObserverController() {
return intersection_observer_controller_;
}
| 6,780 |
26,381 | 0 | static int is_hardlockup(void)
{
unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
return 1;
__this_cpu_write(hrtimer_interrupts_saved, hrint);
return 0;
}
| 6,781 |
47,056 | 0 | static void __exit sha512_ssse3_mod_fini(void)
{
crypto_unregister_shashes(algs, ARRAY_SIZE(algs));
}
| 6,782 |
20,208 | 0 | struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
gfp_t priority)
{
if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
struct sk_buff *skb = alloc_skb(size, priority);
if (skb) {
skb_set_owner_w(skb, sk);
return skb;
}
}
return NULL;
}
| 6,783 |
35,044 | 0 | static int sctp_setsockopt_default_send_param(struct sock *sk,
char __user *optval, int optlen)
{
struct sctp_sndrcvinfo info;
struct sctp_association *asoc;
struct sctp_sock *sp = sctp_sk(sk);
if (optlen != sizeof(struct sctp_sndrcvinfo))
return -EINVAL;
if (copy_from_user(&info, optval, optlen))
return -EFAULT;
asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
return -EINVAL;
if (asoc) {
asoc->default_stream = info.sinfo_stream;
asoc->default_flags = info.sinfo_flags;
asoc->default_ppid = info.sinfo_ppid;
asoc->default_context = info.sinfo_context;
asoc->default_timetolive = info.sinfo_timetolive;
} else {
sp->default_stream = info.sinfo_stream;
sp->default_flags = info.sinfo_flags;
sp->default_ppid = info.sinfo_ppid;
sp->default_context = info.sinfo_context;
sp->default_timetolive = info.sinfo_timetolive;
}
return 0;
}
| 6,784 |
28,491 | 0 | void qeth_clear_cmd_buffers(struct qeth_channel *channel)
{
int cnt;
for (cnt = 0; cnt < QETH_CMD_BUFFER_NO; cnt++)
qeth_release_buffer(channel, &channel->iob[cnt]);
channel->buf_no = 0;
channel->io_buf_no = 0;
}
| 6,785 |
152,817 | 0 | PaintArtifactCompositor* paint_artifact_compositor() {
return MainFrame().GetFrameView()->GetPaintArtifactCompositorForTesting();
}
| 6,786 |
16,344 | 0 | void BaseShadow::removeJob( const char* reason )
{
this->removeJobPre(reason);
DC_Exit( JOB_SHOULD_REMOVE );
}
| 6,787 |
101,648 | 0 | void Browser::FocusChromeOSStatus() {
UserMetrics::RecordAction(UserMetricsAction("FocusChromeOSStatus"));
window_->FocusChromeOSStatus();
}
| 6,788 |
132,968 | 0 | void RenderWidgetHostViewAura::InternalSetBounds(const gfx::Rect& rect) {
if (HasDisplayPropertyChanged(window_))
host_->InvalidateScreenInfo();
if (!in_bounds_changed_)
window_->SetBounds(rect);
host_->WasResized();
MaybeCreateResizeLock();
if (touch_editing_client_) {
touch_editing_client_->OnSelectionOrCursorChanged(selection_anchor_rect_,
selection_focus_rect_);
}
#if defined(OS_WIN)
if (!plugin_parent_window_ && GetNativeViewId()) {
plugin_parent_window_ = ::CreateWindowEx(
0, L"Static", NULL, WS_CHILDWINDOW, 0, 0, 0, 0,
reinterpret_cast<HWND>(GetNativeViewId()), NULL, NULL, NULL);
if (::IsWindow(plugin_parent_window_))
::SetProp(plugin_parent_window_, content::kPluginDummyParentProperty,
reinterpret_cast<HANDLE>(true));
}
if (::IsWindow(plugin_parent_window_)) {
gfx::Rect window_bounds = window_->GetBoundsInRootWindow();
::SetWindowPos(plugin_parent_window_, NULL, window_bounds.x(),
window_bounds.y(), window_bounds.width(),
window_bounds.height(), 0);
}
#endif
}
| 6,789 |
53,873 | 0 | void acpi_os_unmap_generic_address(struct acpi_generic_address *gas)
{
u64 addr;
struct acpi_ioremap *map;
if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
return;
/* Handle possible alignment issues */
memcpy(&addr, &gas->address, sizeof(addr));
if (!addr || !gas->bit_width)
return;
mutex_lock(&acpi_ioremap_lock);
map = acpi_map_lookup(addr, gas->bit_width / 8);
if (!map) {
mutex_unlock(&acpi_ioremap_lock);
return;
}
acpi_os_drop_map_ref(map);
mutex_unlock(&acpi_ioremap_lock);
acpi_os_map_cleanup(map);
}
| 6,790 |
167,565 | 0 | int RenderFrameHostManager::CreateRenderFrameProxy(SiteInstance* instance) {
CHECK(instance);
CHECK_NE(instance, render_frame_host_->GetSiteInstance());
RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
if (proxy && proxy->is_render_frame_proxy_live())
return proxy->GetRoutingID();
RenderViewHostImpl* render_view_host =
frame_tree_node_->frame_tree()->GetRenderViewHost(instance);
if (!proxy) {
if (!render_view_host) {
CHECK(frame_tree_node_->IsMainFrame());
render_view_host = frame_tree_node_->frame_tree()->CreateRenderViewHost(
instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE, MSG_ROUTING_NONE, true,
true);
}
proxy = CreateRenderFrameProxyHost(instance, render_view_host);
}
if (frame_tree_node_->IsMainFrame() && render_view_host) {
InitRenderView(render_view_host, proxy);
} else {
proxy->InitRenderFrameProxy();
}
return proxy->GetRoutingID();
}
| 6,791 |
122,876 | 0 | int RenderProcessHostImpl::GetID() const {
return id_;
}
| 6,792 |
22,592 | 0 | static void set_rq_online(struct rq *rq)
{
if (!rq->online) {
const struct sched_class *class;
cpumask_set_cpu(rq->cpu, rq->rd->online);
rq->online = 1;
for_each_class(class) {
if (class->rq_online)
class->rq_online(rq);
}
}
}
| 6,793 |
179,820 | 1 | acc_ctx_new(OM_uint32 *minor_status,
gss_buffer_t buf,
gss_ctx_id_t *ctx,
spnego_gss_cred_id_t spcred,
gss_buffer_t *mechToken,
gss_buffer_t *mechListMIC,
OM_uint32 *negState,
send_token_flag *return_token)
{
OM_uint32 tmpmin, ret, req_flags;
gss_OID_set supported_mechSet, mechTypes;
gss_buffer_desc der_mechTypes;
gss_OID mech_wanted;
spnego_gss_ctx_id_t sc = NULL;
ret = GSS_S_DEFECTIVE_TOKEN;
der_mechTypes.length = 0;
der_mechTypes.value = NULL;
*mechToken = *mechListMIC = GSS_C_NO_BUFFER;
supported_mechSet = mechTypes = GSS_C_NO_OID_SET;
*return_token = ERROR_TOKEN_SEND;
*negState = REJECT;
*minor_status = 0;
ret = get_negTokenInit(minor_status, buf, &der_mechTypes,
&mechTypes, &req_flags,
mechToken, mechListMIC);
if (ret != GSS_S_COMPLETE) {
goto cleanup;
}
ret = get_negotiable_mechs(minor_status, spcred, GSS_C_ACCEPT,
&supported_mechSet);
if (ret != GSS_S_COMPLETE) {
*return_token = NO_TOKEN_SEND;
goto cleanup;
}
/*
* Select the best match between the list of mechs
* that the initiator requested and the list that
* the acceptor will support.
*/
mech_wanted = negotiate_mech(supported_mechSet, mechTypes, negState);
if (*negState == REJECT) {
ret = GSS_S_BAD_MECH;
goto cleanup;
}
sc = (spnego_gss_ctx_id_t)*ctx;
if (sc != NULL) {
gss_release_buffer(&tmpmin, &sc->DER_mechTypes);
assert(mech_wanted != GSS_C_NO_OID);
} else
sc = create_spnego_ctx();
if (sc == NULL) {
ret = GSS_S_FAILURE;
*return_token = NO_TOKEN_SEND;
goto cleanup;
}
sc->mech_set = mechTypes;
mechTypes = GSS_C_NO_OID_SET;
sc->internal_mech = mech_wanted;
sc->DER_mechTypes = der_mechTypes;
der_mechTypes.length = 0;
der_mechTypes.value = NULL;
if (*negState == REQUEST_MIC)
sc->mic_reqd = 1;
*return_token = INIT_TOKEN_SEND;
sc->firstpass = 1;
*ctx = (gss_ctx_id_t)sc;
ret = GSS_S_COMPLETE;
cleanup:
gss_release_oid_set(&tmpmin, &mechTypes);
gss_release_oid_set(&tmpmin, &supported_mechSet);
if (der_mechTypes.length != 0)
gss_release_buffer(&tmpmin, &der_mechTypes);
return ret;
}
| 6,794 |
85,161 | 0 | static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
{
struct address_space *mapping = iocb->ki_filp->f_mapping;
struct inode *inode = mapping->host;
size_t count = iov_iter_count(iter);
loff_t offset = iocb->ki_pos;
int rw = iov_iter_rw(iter);
int err;
err = check_direct_IO(inode, iter, offset);
if (err)
return err;
if (__force_buffered_io(inode, rw))
return 0;
trace_f2fs_direct_IO_enter(inode, offset, count, rw);
down_read(&F2FS_I(inode)->dio_rwsem[rw]);
err = blockdev_direct_IO(iocb, inode, iter, get_data_block_dio);
up_read(&F2FS_I(inode)->dio_rwsem[rw]);
if (rw == WRITE) {
if (err > 0)
set_inode_flag(inode, FI_UPDATE_WRITE);
else if (err < 0)
f2fs_write_failed(mapping, offset + count);
}
trace_f2fs_direct_IO_exit(inode, offset, count, rw, err);
return err;
}
| 6,795 |
92,898 | 0 | do_cmd2(char *host, char *remuser, int port, char *cmd, int fdin, int fdout)
{
pid_t pid;
int status;
if (verbose_mode)
fmprintf(stderr,
"Executing: 2nd program %s host %s, user %s, command %s\n",
ssh_program, host,
remuser ? remuser : "(unspecified)", cmd);
if (port == -1)
port = sshport;
/* Fork a child to execute the command on the remote host using ssh. */
pid = fork();
if (pid == 0) {
dup2(fdin, 0);
dup2(fdout, 1);
replacearg(&args, 0, "%s", ssh_program);
if (port != -1) {
addargs(&args, "-p");
addargs(&args, "%d", port);
}
if (remuser != NULL) {
addargs(&args, "-l");
addargs(&args, "%s", remuser);
}
addargs(&args, "--");
addargs(&args, "%s", host);
addargs(&args, "%s", cmd);
execvp(ssh_program, args.list);
perror(ssh_program);
exit(1);
} else if (pid == -1) {
fatal("fork: %s", strerror(errno));
}
while (waitpid(pid, &status, 0) == -1)
if (errno != EINTR)
fatal("do_cmd2: waitpid: %s", strerror(errno));
return 0;
}
| 6,796 |
184,008 | 1 | static void UpdatePropertyCallback(IBusPanelService* panel,
IBusProperty* ibus_prop,
gpointer user_data) {
g_return_if_fail(user_data);
InputMethodStatusConnection* self
= static_cast<InputMethodStatusConnection*>(user_data);
self->UpdateProperty(ibus_prop);
}
| 6,797 |
87,684 | 0 | void hsr_register_frame_in(struct hsr_node *node, struct hsr_port *port,
u16 sequence_nr)
{
/* Don't register incoming frames without a valid sequence number. This
* ensures entries of restarted nodes gets pruned so that they can
* re-register and resume communications.
*/
if (seq_nr_before(sequence_nr, node->seq_out[port->type]))
return;
node->time_in[port->type] = jiffies;
node->time_in_stale[port->type] = false;
}
| 6,798 |
111,803 | 0 | void SyncBackendHost::HandleNigoriConfigurationCompletedOnFrontendLoop(
const WeakHandle<JsBackend>& js_backend,
const syncable::ModelTypeSet failed_configuration_types) {
HandleInitializationCompletedOnFrontendLoop(
js_backend, failed_configuration_types.Empty());
}
| 6,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.