unique_id
int64 13
189k
| target
int64 0
1
| code
stringlengths 20
241k
| __index_level_0__
int64 0
18.9k
|
|---|---|---|---|
67,435 | 0 | static inline u64 hash_name(const void *salt, const char *name)
{
unsigned long hash = init_name_hash(salt);
unsigned long len = 0, c;
c = (unsigned char)*name;
do {
len++;
hash = partial_name_hash(c, hash);
c = (unsigned char)name[len];
} while (c && c != '/');
return hashlen_create(end_name_hash(hash), len);
}
| 15,600 |
91,286 | 0 | int ipmi_request_settime(struct ipmi_user *user,
struct ipmi_addr *addr,
long msgid,
struct kernel_ipmi_msg *msg,
void *user_msg_data,
int priority,
int retries,
unsigned int retry_time_ms)
{
unsigned char saddr = 0, lun = 0;
int rv, index;
if (!user)
return -EINVAL;
user = acquire_ipmi_user(user, &index);
if (!user)
return -ENODEV;
rv = check_addr(user->intf, addr, &saddr, &lun);
if (!rv)
rv = i_ipmi_request(user,
user->intf,
addr,
msgid,
msg,
user_msg_data,
NULL, NULL,
priority,
saddr,
lun,
retries,
retry_time_ms);
release_ipmi_user(user, index);
return rv;
}
| 15,601 |
15,168 | 0 | PHP_FUNCTION(imagepsloadfont)
{
char *file;
int file_len, f_ind, *font;
#ifdef PHP_WIN32
struct stat st;
#endif
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &file, &file_len) == FAILURE) {
return;
}
#ifdef PHP_WIN32
if (VCWD_STAT(file, &st) < 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Font file not found (%s)", file);
RETURN_FALSE;
}
#endif
f_ind = T1_AddFont(file);
if (f_ind < 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "T1Lib Error (%i): %s", f_ind, T1_StrError(f_ind));
RETURN_FALSE;
}
if (T1_LoadFont(f_ind)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't load the font");
RETURN_FALSE;
}
font = (int *) emalloc(sizeof(int));
*font = f_ind;
ZEND_REGISTER_RESOURCE(return_value, font, le_ps_font);
}
| 15,602 |
108,091 | 0 | error::Error GLES2DecoderImpl::DoTexImage2D(
GLenum target,
GLint level,
GLenum internal_format,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type,
const void* pixels,
uint32 pixels_size) {
if (!validators_->texture_target.IsValid(target)) {
SetGLError(GL_INVALID_ENUM, "glTexImage2D: target GL_INVALID_ENUM");
return error::kNoError;
}
if (!validators_->texture_format.IsValid(internal_format)) {
SetGLError(GL_INVALID_ENUM,
"glTexImage2D: internal_format GL_INVALID_ENUM");
return error::kNoError;
}
if (!validators_->texture_format.IsValid(format)) {
SetGLError(GL_INVALID_ENUM, "glTexImage2D: format GL_INVALID_ENUM");
return error::kNoError;
}
if (!validators_->pixel_type.IsValid(type)) {
SetGLError(GL_INVALID_ENUM, "glTexImage2D: type GL_INVALID_ENUM");
return error::kNoError;
}
if (format != internal_format) {
SetGLError(GL_INVALID_OPERATION, "glTexImage2D: format != internalFormat");
return error::kNoError;
}
if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
border != 0) {
SetGLError(GL_INVALID_VALUE, "glTexImage2D: dimensions out of range");
return error::kNoError;
}
TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
if (!info) {
SetGLError(GL_INVALID_OPERATION,
"glTexImage2D: unknown texture for target");
return error::kNoError;
}
scoped_array<int8> zero;
if (!pixels) {
zero.reset(new int8[pixels_size]);
memset(zero.get(), 0, pixels_size);
pixels = zero.get();
}
GLenum gl_internal_format = internal_format;
if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
if (format == GL_BGRA_EXT && internal_format == GL_BGRA_EXT) {
gl_internal_format = GL_RGBA;
} else if (type == GL_FLOAT) {
if (format == GL_RGBA) {
gl_internal_format = GL_RGBA32F_ARB;
} else if (format == GL_RGB) {
gl_internal_format = GL_RGB32F_ARB;
}
} else if (type == GL_HALF_FLOAT_OES) {
if (format == GL_RGBA) {
gl_internal_format = GL_RGBA16F_ARB;
} else if (format == GL_RGB) {
gl_internal_format = GL_RGB16F_ARB;
}
}
}
CopyRealGLErrorsToWrapper();
glTexImage2D(
target, level, gl_internal_format, width, height, border, format, type,
pixels);
GLenum error = glGetError();
if (error == GL_NO_ERROR) {
texture_manager()->SetLevelInfo(info,
target, level, internal_format, width, height, 1, border, format, type);
}
return error::kNoError;
}
| 15,603 |
15,011 | 0 | ProcQueryTree(ClientPtr client)
{
xQueryTreeReply reply;
int rc, numChildren = 0;
WindowPtr pChild, pWin, pHead;
Window *childIDs = (Window *) NULL;
REQUEST(xResourceReq);
REQUEST_SIZE_MATCH(xResourceReq);
rc = dixLookupWindow(&pWin, stuff->id, client, DixListAccess);
if (rc != Success)
return rc;
reply = (xQueryTreeReply) {
.type = X_Reply,
.sequenceNumber = client->sequence,
.root = pWin->drawable.pScreen->root->drawable.id,
.parent = (pWin->parent) ? pWin->parent->drawable.id : (Window) None
};
pHead = RealChildHead(pWin);
for (pChild = pWin->lastChild; pChild != pHead; pChild = pChild->prevSib)
numChildren++;
if (numChildren) {
int curChild = 0;
childIDs = malloc(numChildren * sizeof(Window));
if (!childIDs)
return BadAlloc;
for (pChild = pWin->lastChild; pChild != pHead;
pChild = pChild->prevSib)
childIDs[curChild++] = pChild->drawable.id;
}
reply.nChildren = numChildren;
reply.length = bytes_to_int32(numChildren * sizeof(Window));
WriteReplyToClient(client, sizeof(xQueryTreeReply), &reply);
if (numChildren) {
client->pSwapReplyFunc = (ReplySwapPtr) Swap32Write;
WriteSwappedDataToClient(client, numChildren * sizeof(Window),
childIDs);
free(childIDs);
}
return Success;
}
| 15,604 |
38,207 | 0 | static int futex_unlock_pi(u32 __user *uaddr, unsigned int flags)
{
struct futex_hash_bucket *hb;
struct futex_q *this, *next;
union futex_key key = FUTEX_KEY_INIT;
u32 uval, vpid = task_pid_vnr(current);
int ret;
retry:
if (get_user(uval, uaddr))
return -EFAULT;
/*
* We release only a lock we actually own:
*/
if ((uval & FUTEX_TID_MASK) != vpid)
return -EPERM;
ret = get_futex_key(uaddr, flags & FLAGS_SHARED, &key, VERIFY_WRITE);
if (unlikely(ret != 0))
goto out;
hb = hash_futex(&key);
spin_lock(&hb->lock);
/*
* To avoid races, try to do the TID -> 0 atomic transition
* again. If it succeeds then we can return without waking
* anyone else up:
*/
if (!(uval & FUTEX_OWNER_DIED) &&
cmpxchg_futex_value_locked(&uval, uaddr, vpid, 0))
goto pi_faulted;
/*
* Rare case: we managed to release the lock atomically,
* no need to wake anyone else up:
*/
if (unlikely(uval == vpid))
goto out_unlock;
/*
* Ok, other tasks may need to be woken up - check waiters
* and do the wakeup if necessary:
*/
plist_for_each_entry_safe(this, next, &hb->chain, list) {
if (!match_futex (&this->key, &key))
continue;
ret = wake_futex_pi(uaddr, uval, this);
/*
* The atomic access to the futex value
* generated a pagefault, so retry the
* user-access and the wakeup:
*/
if (ret == -EFAULT)
goto pi_faulted;
goto out_unlock;
}
/*
* No waiters - kernel unlocks the futex:
*/
if (!(uval & FUTEX_OWNER_DIED)) {
ret = unlock_futex_pi(uaddr, uval);
if (ret == -EFAULT)
goto pi_faulted;
}
out_unlock:
spin_unlock(&hb->lock);
put_futex_key(&key);
out:
return ret;
pi_faulted:
spin_unlock(&hb->lock);
put_futex_key(&key);
ret = fault_in_user_writeable(uaddr);
if (!ret)
goto retry;
return ret;
}
| 15,605 |
13,753 | 0 | ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC) /* {{{ */
{
zval *tmp;
zval *z_key;
size_t _len = strlen(str);
if (UNEXPECTED(_len > INT_MAX)) {
zend_error_noreturn(E_ERROR, "String overflow, max size is %d", INT_MAX);
}
MAKE_STD_ZVAL(tmp);
ZVAL_STRINGL(tmp, str, _len, duplicate);
MAKE_STD_ZVAL(z_key);
ZVAL_STRINGL(z_key, key, key_len-1, 1);
Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp, 0 TSRMLS_CC);
zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
zval_ptr_dtor(&z_key);
return SUCCESS;
}
/* }}} */
| 15,606 |
31,422 | 0 | static int pfkey_get(struct sock *sk, struct sk_buff *skb, const struct sadb_msg *hdr, void * const *ext_hdrs)
{
struct net *net = sock_net(sk);
__u8 proto;
struct sk_buff *out_skb;
struct sadb_msg *out_hdr;
struct xfrm_state *x;
if (!ext_hdrs[SADB_EXT_SA-1] ||
!present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
ext_hdrs[SADB_EXT_ADDRESS_DST-1]))
return -EINVAL;
x = pfkey_xfrm_state_lookup(net, hdr, ext_hdrs);
if (x == NULL)
return -ESRCH;
out_skb = pfkey_xfrm_state2msg(x);
proto = x->id.proto;
xfrm_state_put(x);
if (IS_ERR(out_skb))
return PTR_ERR(out_skb);
out_hdr = (struct sadb_msg *) out_skb->data;
out_hdr->sadb_msg_version = hdr->sadb_msg_version;
out_hdr->sadb_msg_type = SADB_GET;
out_hdr->sadb_msg_satype = pfkey_proto2satype(proto);
out_hdr->sadb_msg_errno = 0;
out_hdr->sadb_msg_reserved = 0;
out_hdr->sadb_msg_seq = hdr->sadb_msg_seq;
out_hdr->sadb_msg_pid = hdr->sadb_msg_pid;
pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ONE, sk, sock_net(sk));
return 0;
}
| 15,607 |
15,637 | 0 | static uint16_t tsc2102_control_register_read(
TSC210xState *s, int reg)
{
switch (reg) {
case 0x00: /* TSC ADC */
return (s->pressure << 15) | ((!s->busy) << 14) |
(s->nextfunction << 10) | (s->nextprecision << 8) | s->filter;
case 0x01: /* Status / Keypad Control */
if ((s->model & 0xff00) == 0x2100)
return (s->pin_func << 14) | ((!s->enabled) << 13) |
(s->host_mode << 12) | ((!!s->dav) << 11) | s->dav;
else
return (s->kb.intr << 15) | ((s->kb.scan || !s->kb.down) << 14) |
(s->kb.debounce << 11);
case 0x02: /* DAC Control */
if ((s->model & 0xff00) == 0x2300)
return s->dac_power & 0x8000;
else
goto bad_reg;
case 0x03: /* Reference */
return s->ref;
case 0x04: /* Reset */
return 0xffff;
case 0x05: /* Configuration */
return s->timing;
case 0x06: /* Secondary configuration */
if ((s->model & 0xff00) == 0x2100)
goto bad_reg;
return ((!s->dav) << 15) | ((s->kb.mode & 1) << 14) | s->pll[2];
case 0x10: /* Keypad Mask */
if ((s->model & 0xff00) == 0x2100)
goto bad_reg;
return s->kb.mask;
default:
bad_reg:
#ifdef TSC_VERBOSE
fprintf(stderr, "tsc2102_control_register_read: "
"no such register: 0x%02x\n", reg);
#endif
return 0xffff;
}
}
| 15,608 |
1,042 | 0 | void GfxIndexedColorSpace::getDefaultRanges(double *decodeLow,
double *decodeRange,
int maxImgPixel) {
decodeLow[0] = 0;
decodeRange[0] = maxImgPixel;
}
| 15,609 |
86,594 | 0 | generateReference(const char *custom1, const char *custom2)
{
static uint ref_counter = 0;
const char *local_cust1 = custom1;
const char *local_cust2 = custom2;
int reference_len = 4;
char *since_epoch = NULL;
reference_len += 20; /* too big */
reference_len += 40; /* too big */
if (local_cust1 == NULL) {
local_cust1 = "_empty_";
}
reference_len += strlen(local_cust1);
if (local_cust2 == NULL) {
local_cust2 = "_empty_";
}
reference_len += strlen(local_cust2);
since_epoch = calloc(1, reference_len);
if (since_epoch != NULL) {
sprintf(since_epoch, "%s-%s-%lu-%u",
local_cust1, local_cust2, (unsigned long)time(NULL), ref_counter++);
}
return since_epoch;
}
| 15,610 |
11,414 | 0 | fbFetchPixel_a8b8g8r8 (const FbBits *bits, int offset, miIndexedPtr indexed)
{
CARD32 pixel = READ((CARD32 *)bits + offset);
return ((pixel & 0xff000000) |
((pixel >> 16) & 0xff) |
(pixel & 0x0000ff00) |
((pixel & 0xff) << 16));
}
| 15,611 |
132,313 | 0 | void RenderFrameImpl::didLoadResourceFromMemoryCache(
blink::WebLocalFrame* frame,
const blink::WebURLRequest& request,
const blink::WebURLResponse& response) {
DCHECK(!frame_ || frame_ == frame);
GURL url(request.url());
if (url.SchemeIs(url::kDataScheme))
return;
render_view_->Send(new ViewHostMsg_DidLoadResourceFromMemoryCache(
render_view_->GetRoutingID(),
url,
response.securityInfo(),
request.httpMethod().utf8(),
response.mimeType().utf8(),
WebURLRequestToResourceType(request)));
}
| 15,612 |
44,911 | 0 | xfs_attr_fillstate(xfs_da_state_t *state)
{
xfs_da_state_path_t *path;
xfs_da_state_blk_t *blk;
int level;
trace_xfs_attr_fillstate(state->args);
/*
* Roll down the "path" in the state structure, storing the on-disk
* block number for those buffers in the "path".
*/
path = &state->path;
ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
if (blk->bp) {
blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
blk->bp = NULL;
} else {
blk->disk_blkno = 0;
}
}
/*
* Roll down the "altpath" in the state structure, storing the on-disk
* block number for those buffers in the "altpath".
*/
path = &state->altpath;
ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
if (blk->bp) {
blk->disk_blkno = XFS_BUF_ADDR(blk->bp);
blk->bp = NULL;
} else {
blk->disk_blkno = 0;
}
}
return(0);
}
| 15,613 |
89,305 | 0 | int hush_init_var(void)
{
ivm_analyze_eeprom(ivm_content, CONFIG_SYS_IVM_EEPROM_MAX_LEN);
return 0;
}
| 15,614 |
98,201 | 0 | void WebSocketExperimentRunner::Stop() {
if (runner.get())
runner->Cancel();
runner = NULL;
}
| 15,615 |
36,325 | 0 | getname_kernel(const char * filename)
{
struct filename *result;
char *kname;
int len;
len = strlen(filename);
if (len >= EMBEDDED_NAME_MAX)
return ERR_PTR(-ENAMETOOLONG);
result = __getname();
if (unlikely(!result))
return ERR_PTR(-ENOMEM);
kname = (char *)result + sizeof(*result);
result->name = kname;
result->uptr = NULL;
result->aname = NULL;
result->separate = false;
strlcpy(kname, filename, EMBEDDED_NAME_MAX);
return result;
}
| 15,616 |
172,432 | 0 | unsigned venc_dev::venc_flush( unsigned port)
{
struct v4l2_encoder_cmd enc;
DEBUG_PRINT_LOW("in %s", __func__);
enc.cmd = V4L2_ENC_QCOM_CMD_FLUSH;
enc.flags = V4L2_QCOM_CMD_FLUSH_OUTPUT | V4L2_QCOM_CMD_FLUSH_CAPTURE;
if (ioctl(m_nDriver_fd, VIDIOC_ENCODER_CMD, &enc)) {
DEBUG_PRINT_ERROR("Flush Port (%d) Failed ", port);
return -1;
}
return 0;
}
| 15,617 |
166,076 | 0 | void FileSystemManagerImpl::GetPlatformPathOnFileThread(
const GURL& path,
int process_id,
storage::FileSystemContext* context,
base::WeakPtr<FileSystemManagerImpl> file_system_manager,
GetPlatformPathCallback callback) {
DCHECK(context->default_file_task_runner()->RunsTasksInCurrentSequence());
SyncGetPlatformPath(
context, process_id, path,
base::BindOnce(
[](base::WeakPtr<FileSystemManagerImpl> file_system_manager,
GetPlatformPathCallback callback,
const base::FilePath& platform_path) {
base::PostTaskWithTraits(
FROM_HERE, {BrowserThread::IO},
base::BindOnce(&FileSystemManagerImpl::DidGetPlatformPath,
std::move(file_system_manager),
std::move(callback), platform_path));
},
std::move(file_system_manager), std::move(callback)));
}
| 15,618 |
151,805 | 0 | void BackgroundLoaderOffliner::SetBackgroundSnapshotControllerForTest(
std::unique_ptr<BackgroundSnapshotController> controller) {
snapshot_controller_ = std::move(controller);
}
| 15,619 |
156,087 | 0 | GURL LinkDoctorBaseURL() {
if (gUseMockLinkDoctorBaseURLForTesting)
return GURL("http://mock.linkdoctor.url/for?testing");
return GURL(LINKDOCTOR_SERVER_REQUEST_URL);
}
| 15,620 |
107,977 | 0 | bool decode(ArgumentDecoder* decoder, RetainPtr<CFArrayRef>& result)
{
uint64_t size;
if (!decoder->decodeUInt64(size))
return false;
RetainPtr<CFMutableArrayRef> array(AdoptCF, CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));
for (size_t i = 0; i < size; ++i) {
RetainPtr<CFTypeRef> element;
if (!decode(decoder, element))
return false;
CFArrayAppendValue(array.get(), element.get());
}
result.adoptCF(array.leakRef());
return true;
}
| 15,621 |
78,102 | 0 | static int asn1_decode_p15_object(sc_context_t *ctx, const u8 *in,
size_t len, struct sc_asn1_pkcs15_object *obj,
int depth)
{
struct sc_pkcs15_object *p15_obj = obj->p15_obj;
struct sc_asn1_entry asn1_c_attr[6], asn1_p15_obj[5];
struct sc_asn1_entry asn1_ac_rules[SC_PKCS15_MAX_ACCESS_RULES + 1], asn1_ac_rule[SC_PKCS15_MAX_ACCESS_RULES][3];
size_t flags_len = sizeof(p15_obj->flags);
size_t label_len = sizeof(p15_obj->label);
size_t access_mode_len = sizeof(p15_obj->access_rules[0].access_mode);
int r, ii;
for (ii=0; ii<SC_PKCS15_MAX_ACCESS_RULES; ii++)
sc_copy_asn1_entry(c_asn1_access_control_rule, asn1_ac_rule[ii]);
sc_copy_asn1_entry(c_asn1_access_control_rules, asn1_ac_rules);
sc_copy_asn1_entry(c_asn1_com_obj_attr, asn1_c_attr);
sc_copy_asn1_entry(c_asn1_p15_obj, asn1_p15_obj);
sc_format_asn1_entry(asn1_c_attr + 0, p15_obj->label, &label_len, 0);
sc_format_asn1_entry(asn1_c_attr + 1, &p15_obj->flags, &flags_len, 0);
sc_format_asn1_entry(asn1_c_attr + 2, &p15_obj->auth_id, NULL, 0);
sc_format_asn1_entry(asn1_c_attr + 3, &p15_obj->user_consent, NULL, 0);
for (ii=0; ii<SC_PKCS15_MAX_ACCESS_RULES; ii++) {
sc_format_asn1_entry(asn1_ac_rule[ii] + 0, &p15_obj->access_rules[ii].access_mode, &access_mode_len, 0);
sc_format_asn1_entry(asn1_ac_rule[ii] + 1, &p15_obj->access_rules[ii].auth_id, NULL, 0);
sc_format_asn1_entry(asn1_ac_rules + ii, asn1_ac_rule[ii], NULL, 0);
}
sc_format_asn1_entry(asn1_c_attr + 4, asn1_ac_rules, NULL, 0);
sc_format_asn1_entry(asn1_p15_obj + 0, asn1_c_attr, NULL, 0);
sc_format_asn1_entry(asn1_p15_obj + 1, obj->asn1_class_attr, NULL, 0);
sc_format_asn1_entry(asn1_p15_obj + 2, obj->asn1_subclass_attr, NULL, 0);
sc_format_asn1_entry(asn1_p15_obj + 3, obj->asn1_type_attr, NULL, 0);
r = asn1_decode(ctx, asn1_p15_obj, in, len, NULL, NULL, 0, depth + 1);
return r;
}
| 15,622 |
170,301 | 0 | 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;
}
| 15,623 |
127,999 | 0 | jlong AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
return reinterpret_cast<intptr_t>(
browser_view_renderer_.GetAwDrawGLViewContext());
}
| 15,624 |
161,309 | 0 | IOHandler::~IOHandler() {}
| 15,625 |
25,321 | 0 | static u32 ptrace_get_hbp_resource_info(void)
{
u8 num_brps, num_wrps, debug_arch, wp_len;
u32 reg = 0;
num_brps = hw_breakpoint_slots(TYPE_INST);
num_wrps = hw_breakpoint_slots(TYPE_DATA);
debug_arch = arch_get_debug_arch();
wp_len = arch_get_max_wp_len();
reg |= debug_arch;
reg <<= 8;
reg |= wp_len;
reg <<= 8;
reg |= num_wrps;
reg <<= 8;
reg |= num_brps;
return reg;
}
| 15,626 |
33,866 | 0 | cib_shutdown(int nsig)
{
struct qb_ipcs_stats srv_stats;
if (cib_shutdown_flag == FALSE) {
int disconnects = 0;
qb_ipcs_connection_t *c = NULL;
cib_shutdown_flag = TRUE;
c = qb_ipcs_connection_first_get(ipcs_rw);
while(c != NULL) {
qb_ipcs_connection_t *last = c;
c = qb_ipcs_connection_next_get(ipcs_rw, last);
crm_debug("Disconnecting r/w client %p...", last);
qb_ipcs_disconnect(last);
qb_ipcs_connection_unref(last);
disconnects++;
}
c = qb_ipcs_connection_first_get(ipcs_ro);
while(c != NULL) {
qb_ipcs_connection_t *last = c;
c = qb_ipcs_connection_next_get(ipcs_ro, last);
crm_debug("Disconnecting r/o client %p...", last);
qb_ipcs_disconnect(last);
qb_ipcs_connection_unref(last);
disconnects++;
}
c = qb_ipcs_connection_first_get(ipcs_shm);
while(c != NULL) {
qb_ipcs_connection_t *last = c;
c = qb_ipcs_connection_next_get(ipcs_shm, last);
crm_debug("Disconnecting non-blocking r/w client %p...", last);
qb_ipcs_disconnect(last);
qb_ipcs_connection_unref(last);
disconnects++;
}
disconnects += g_hash_table_size(client_list);
crm_debug("Disconnecting %d remote clients", g_hash_table_size(client_list));
g_hash_table_foreach(client_list, disconnect_remote_client, NULL);
crm_info("Disconnected %d clients", disconnects);
}
qb_ipcs_stats_get(ipcs_rw, &srv_stats, QB_FALSE);
if(g_hash_table_size(client_list) == 0) {
crm_info("All clients disconnected (%d)", srv_stats.active_connections);
initiate_exit();
} else {
crm_info("Waiting on %d clients to disconnect (%d)", g_hash_table_size(client_list), srv_stats.active_connections);
}
}
| 15,627 |
43,545 | 0 | static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len,
char __user *optval, int __user *optlen)
{
struct sctp_paddrparams params;
struct sctp_transport *trans = NULL;
struct sctp_association *asoc = NULL;
struct sctp_sock *sp = sctp_sk(sk);
if (len < sizeof(struct sctp_paddrparams))
return -EINVAL;
len = sizeof(struct sctp_paddrparams);
if (copy_from_user(¶ms, optval, len))
return -EFAULT;
/* If an address other than INADDR_ANY is specified, and
* no transport is found, then the request is invalid.
*/
if (!sctp_is_any(sk, (union sctp_addr *)¶ms.spp_address)) {
trans = sctp_addr_id2transport(sk, ¶ms.spp_address,
params.spp_assoc_id);
if (!trans) {
pr_debug("%s: failed no transport\n", __func__);
return -EINVAL;
}
}
/* Get association, if assoc_id != 0 and the socket is a one
* to many style socket, and an association was not found, then
* the id was invalid.
*/
asoc = sctp_id2assoc(sk, params.spp_assoc_id);
if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) {
pr_debug("%s: failed no association\n", __func__);
return -EINVAL;
}
if (trans) {
/* Fetch transport values. */
params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval);
params.spp_pathmtu = trans->pathmtu;
params.spp_pathmaxrxt = trans->pathmaxrxt;
params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay);
/*draft-11 doesn't say what to return in spp_flags*/
params.spp_flags = trans->param_flags;
} else if (asoc) {
/* Fetch association values. */
params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval);
params.spp_pathmtu = asoc->pathmtu;
params.spp_pathmaxrxt = asoc->pathmaxrxt;
params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay);
/*draft-11 doesn't say what to return in spp_flags*/
params.spp_flags = asoc->param_flags;
} else {
/* Fetch socket values. */
params.spp_hbinterval = sp->hbinterval;
params.spp_pathmtu = sp->pathmtu;
params.spp_sackdelay = sp->sackdelay;
params.spp_pathmaxrxt = sp->pathmaxrxt;
/*draft-11 doesn't say what to return in spp_flags*/
params.spp_flags = sp->param_flags;
}
if (copy_to_user(optval, ¶ms, len))
return -EFAULT;
if (put_user(len, optlen))
return -EFAULT;
return 0;
}
| 15,628 |
102,672 | 0 | void CCLayerTreeHost::clearPendingUpdate()
{
for (size_t surfaceIndex = 0; surfaceIndex < m_updateList.size(); ++surfaceIndex) {
LayerChromium* layer = m_updateList[surfaceIndex].get();
ASSERT(layer->renderSurface());
layer->clearRenderSurface();
}
m_updateList.clear();
}
| 15,629 |
24,497 | 0 | cifs_reclassify_socket6(struct socket *sock)
{
}
| 15,630 |
56,597 | 0 | static int ext4_nonda_switch(struct super_block *sb)
{
s64 free_clusters, dirty_clusters;
struct ext4_sb_info *sbi = EXT4_SB(sb);
/*
* switch to non delalloc mode if we are running low
* on free block. The free block accounting via percpu
* counters can get slightly wrong with percpu_counter_batch getting
* accumulated on each CPU without updating global counters
* Delalloc need an accurate free block accounting. So switch
* to non delalloc when we are near to error range.
*/
free_clusters =
percpu_counter_read_positive(&sbi->s_freeclusters_counter);
dirty_clusters =
percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
/*
* Start pushing delalloc when 1/2 of free blocks are dirty.
*/
if (dirty_clusters && (free_clusters < 2 * dirty_clusters))
try_to_writeback_inodes_sb(sb, WB_REASON_FS_FREE_SPACE);
if (2 * free_clusters < 3 * dirty_clusters ||
free_clusters < (dirty_clusters + EXT4_FREECLUSTERS_WATERMARK)) {
/*
* free block count is less than 150% of dirty blocks
* or free blocks is less than watermark
*/
return 1;
}
return 0;
}
| 15,631 |
140,110 | 0 | void HTMLMediaElement::setSrcObject(MediaStreamDescriptor* srcObject) {
BLINK_MEDIA_LOG << "setSrcObject(" << (void*)this << ")";
m_srcObject = srcObject;
invokeLoadAlgorithm();
}
| 15,632 |
110,878 | 0 | gfx::Point RootWindow::GetHostOrigin() const {
return host_->GetBounds().origin();
}
| 15,633 |
65,065 | 0 | static bool is_spillable_regtype(enum bpf_reg_type type)
{
switch (type) {
case PTR_TO_MAP_VALUE:
case PTR_TO_MAP_VALUE_OR_NULL:
case PTR_TO_MAP_VALUE_ADJ:
case PTR_TO_STACK:
case PTR_TO_CTX:
case PTR_TO_PACKET:
case PTR_TO_PACKET_END:
case FRAME_PTR:
case CONST_PTR_TO_MAP:
return true;
default:
return false;
}
}
| 15,634 |
85,147 | 0 | int key_update(key_ref_t key_ref, const void *payload, size_t plen)
{
struct key_preparsed_payload prep;
struct key *key = key_ref_to_ptr(key_ref);
int ret;
key_check(key);
/* the key must be writable */
ret = key_permission(key_ref, KEY_NEED_WRITE);
if (ret < 0)
return ret;
/* attempt to update it if supported */
if (!key->type->update)
return -EOPNOTSUPP;
memset(&prep, 0, sizeof(prep));
prep.data = payload;
prep.datalen = plen;
prep.quotalen = key->type->def_datalen;
prep.expiry = TIME_T_MAX;
if (key->type->preparse) {
ret = key->type->preparse(&prep);
if (ret < 0)
goto error;
}
down_write(&key->sem);
ret = key->type->update(key, &prep);
if (ret == 0)
/* updating a negative key instantiates it */
clear_bit(KEY_FLAG_NEGATIVE, &key->flags);
up_write(&key->sem);
error:
if (key->type->preparse)
key->type->free_preparse(&prep);
return ret;
}
| 15,635 |
100,436 | 0 | void RenderThread::OnSetNextPageID(int32 next_page_id) {
RenderView::SetNextPageID(next_page_id);
}
| 15,636 |
92,618 | 0 | static inline void nohz_newidle_balance(struct rq *this_rq) { }
| 15,637 |
172,998 | 0 | load_file(png_const_charp name, png_bytepp result)
{
FILE *fp = tmpfile();
if (fp != NULL)
{
FILE *ip = fopen(name, "rb");
if (ip != NULL)
{
size_t total = 0;
int ch;
for (;;)
{
ch = getc(ip);
if (ch == EOF) break;
putc(ch, fp);
++total;
}
if (ferror(ip))
{
perror(name);
fprintf(stderr, "%s: read error\n", name);
(void)fclose(ip);
}
else
{
(void)fclose(ip);
if (ferror(fp))
{
perror("temporary file");
fprintf(stderr, "temporary file write error\n");
}
else
{
rewind(fp);
if (total > 0)
{
/* Round up to a multiple of 4 here to allow an iCCP profile
* to be padded to a 4x boundary.
*/
png_bytep data = malloc((total+3)&~3);
if (data != NULL)
{
size_t new_size = 0;
for (;;)
{
ch = getc(fp);
if (ch == EOF) break;
data[new_size++] = (png_byte)ch;
}
if (ferror(fp) || new_size != total)
{
perror("temporary file");
fprintf(stderr, "temporary file read error\n");
free(data);
}
else
{
(void)fclose(fp);
*result = data;
return total;
}
}
else
fprintf(stderr, "%s: out of memory loading file\n", name);
}
else
fprintf(stderr, "%s: empty file\n", name);
}
}
}
else
{
perror(name);
fprintf(stderr, "%s: open failed\n", name);
}
fclose(fp);
}
else
fprintf(stderr, "makepng: %s: could not open temporary file\n", name);
exit(1);
return 0;
}
| 15,638 |
80,698 | 0 | GF_Err co64_dump(GF_Box *a, FILE * trace)
{
GF_ChunkLargeOffsetBox *p;
u32 i;
p = (GF_ChunkLargeOffsetBox *)a;
gf_isom_box_dump_start(a, "ChunkLargeOffsetBox", trace);
fprintf(trace, "EntryCount=\"%d\">\n", p->nb_entries);
if (!p->offsets && p->size) {
fprintf(trace, "<!-- Warning: No Chunk Offsets indications/>\n");
} else {
for (i=0; i<p->nb_entries; i++)
fprintf(trace, "<ChunkOffsetEntry offset=\""LLU"\"/>\n", LLU_CAST p->offsets[i]);
}
if (!p->size) {
fprintf(trace, "<ChunkOffsetEntry offset=\"\"/>\n");
}
gf_isom_box_dump_done("ChunkLargeOffsetBox", a, trace);
return GF_OK;
}
| 15,639 |
89,331 | 0 | static void eol_or_eof(char **c)
{
while (**c && **c != '\n')
(*c)++;
}
| 15,640 |
11,389 | 0 | fbCombineOutReverseU (CARD32 *dest, const CARD32 *src, int width)
{
int i;
for (i = 0; i < width; ++i) {
CARD32 d = READ(dest + i);
CARD32 a = Alpha(~READ(src + i));
FbByteMul(d, a);
WRITE(dest + i, d);
}
}
| 15,641 |
73,007 | 0 | int jas_image_getfmt(jas_stream_t *in)
{
jas_image_fmtinfo_t *fmtinfo;
int found;
int i;
/* Check for data in each of the supported formats. */
found = 0;
for (i = 0, fmtinfo = jas_image_fmtinfos; i < jas_image_numfmts; ++i,
++fmtinfo) {
if (fmtinfo->ops.validate) {
/* Is the input data valid for this format? */
if (!(*fmtinfo->ops.validate)(in)) {
found = 1;
break;
}
}
}
return found ? fmtinfo->id : (-1);
}
| 15,642 |
167,703 | 0 | void WebRuntimeFeatures::EnableFastMobileScrolling(bool enable) {
RuntimeEnabledFeatures::SetFastMobileScrollingEnabled(enable);
}
| 15,643 |
118,218 | 0 | views::BubbleBorder* AutofillDialogViews::OverlayView::GetBubbleBorder() {
views::View* frame = GetWidget()->non_client_view()->frame_view();
std::string bubble_frame_view_name(views::BubbleFrameView::kViewClassName);
if (frame->GetClassName() == bubble_frame_view_name)
return static_cast<views::BubbleFrameView*>(frame)->bubble_border();
NOTREACHED();
return NULL;
}
| 15,644 |
169,652 | 0 | TabManagerTest() : scoped_set_tick_clock_for_testing_(&test_clock_) {
test_clock_.Advance(kShortDelay);
scoped_feature_list_.InitAndEnableFeature(
features::kSiteCharacteristicsDatabase);
}
| 15,645 |
134,640 | 0 | bool OSExchangeDataProviderAuraX11::GetString(base::string16* result) const {
if (HasFile()) {
return false;
}
std::vector< ::Atom> text_atoms = ui::GetTextAtomsFrom(&atom_cache_);
std::vector< ::Atom> requested_types;
ui::GetAtomIntersection(text_atoms, GetTargets(), &requested_types);
ui::SelectionData data(format_map_.GetFirstOf(requested_types));
if (data.IsValid()) {
std::string text = data.GetText();
*result = base::UTF8ToUTF16(text);
return true;
}
return false;
}
| 15,646 |
153,317 | 0 | void Tab::AnimationEnded(const gfx::Animation* animation) {
DCHECK_EQ(animation, &title_animation_);
title_->SetBoundsRect(target_title_bounds_);
}
| 15,647 |
83,685 | 0 | const git_index_name_entry *git_index_name_get_byindex(
git_index *index, size_t n)
{
assert(index);
git_vector_sort(&index->names);
return git_vector_get(&index->names, n);
}
| 15,648 |
148,566 | 0 | void WebContentsImpl::SetShowingContextMenu(bool showing) {
DCHECK_NE(showing_context_menu_, showing);
showing_context_menu_ = showing;
if (auto* view = GetRenderWidgetHostView()) {
static_cast<RenderWidgetHostViewBase*>(view)->SetShowingContextMenu(
showing);
}
}
| 15,649 |
131,138 | 0 | static void withExecutionContextMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
{
TRACE_EVENT_SET_SAMPLING_STATE("Blink", "DOMMethod");
TestObjectV8Internal::withExecutionContextMethod(info);
TRACE_EVENT_SET_SAMPLING_STATE("V8", "V8Execution");
}
| 15,650 |
44,584 | 0 | int lxc_clear_config_network(struct lxc_conf *c)
{
struct lxc_list *it,*next;
lxc_list_for_each_safe(it, &c->network, next) {
lxc_remove_nic(it);
}
return 0;
}
| 15,651 |
2,709 | 0 | pch_suffix_context (void)
{
return p_suffix_context;
}
| 15,652 |
138,286 | 0 | Settings* AXObjectCacheImpl::settings() {
return m_document->settings();
}
| 15,653 |
47,469 | 0 | static int adf_ctl_alloc_resources(struct adf_user_cfg_ctl_data **ctl_data,
unsigned long arg)
{
struct adf_user_cfg_ctl_data *cfg_data;
cfg_data = kzalloc(sizeof(*cfg_data), GFP_KERNEL);
if (!cfg_data)
return -ENOMEM;
/* Initialize device id to NO DEVICE as 0 is a valid device id */
cfg_data->device_id = ADF_CFG_NO_DEVICE;
if (copy_from_user(cfg_data, (void __user *)arg, sizeof(*cfg_data))) {
pr_err("QAT: failed to copy from user cfg_data.\n");
kfree(cfg_data);
return -EIO;
}
*ctl_data = cfg_data;
return 0;
}
| 15,654 |
103,417 | 0 | xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt,
xmlXPathStepOpPtr op,
xmlNodeSetPtr set,
int contextSize,
int minPos,
int maxPos,
int hasNsNodes)
{
if (op->ch1 != -1) {
xmlXPathCompExprPtr comp = ctxt->comp;
if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
/*
* TODO: raise an internal error.
*/
}
contextSize = xmlXPathCompOpEvalPredicate(ctxt,
&comp->steps[op->ch1], set, contextSize, hasNsNodes);
CHECK_ERROR0;
if (contextSize <= 0)
return(0);
}
/*
* Check if the node set contains a sufficient number of nodes for
* the requested range.
*/
if (contextSize < minPos) {
xmlXPathNodeSetClear(set, hasNsNodes);
return(0);
}
if (op->ch2 == -1) {
/*
* TODO: Can this ever happen?
*/
return (contextSize);
} else {
xmlDocPtr oldContextDoc;
int i, pos = 0, newContextSize = 0, contextPos = 0, res;
xmlXPathStepOpPtr exprOp;
xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
xmlNodePtr oldContextNode, contextNode = NULL;
xmlXPathContextPtr xpctxt = ctxt->context;
#ifdef LIBXML_XPTR_ENABLED
/*
* URGENT TODO: Check the following:
* We don't expect location sets if evaluating prediates, right?
* Only filters should expect location sets, right?
*/
#endif /* LIBXML_XPTR_ENABLED */
/*
* Save old context.
*/
oldContextNode = xpctxt->node;
oldContextDoc = xpctxt->doc;
/*
* Get the expression of this predicate.
*/
exprOp = &ctxt->comp->steps[op->ch2];
for (i = 0; i < set->nodeNr; i++) {
if (set->nodeTab[i] == NULL)
continue;
contextNode = set->nodeTab[i];
xpctxt->node = contextNode;
xpctxt->contextSize = contextSize;
xpctxt->proximityPosition = ++contextPos;
/*
* Initialize the new set.
* Also set the xpath document in case things like
* key() evaluation are attempted on the predicate
*/
if ((contextNode->type != XML_NAMESPACE_DECL) &&
(contextNode->doc != NULL))
xpctxt->doc = contextNode->doc;
/*
* Evaluate the predicate expression with 1 context node
* at a time; this node is packaged into a node set; this
* node set is handed over to the evaluation mechanism.
*/
if (contextObj == NULL)
contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
else
xmlXPathNodeSetAddUnique(contextObj->nodesetval,
contextNode);
valuePush(ctxt, contextObj);
res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
xmlXPathObjectPtr tmp;
/* pop the result if any */
tmp = valuePop(ctxt);
while (tmp != contextObj) {
/*
* Free up the result
* then pop off contextObj, which will be freed later
*/
xmlXPathReleaseObject(xpctxt, tmp);
tmp = valuePop(ctxt);
}
goto evaluation_error;
}
if (res)
pos++;
if (res && (pos >= minPos) && (pos <= maxPos)) {
/*
* Fits in the requested range.
*/
newContextSize++;
if (minPos == maxPos) {
/*
* Only 1 node was requested.
*/
if (contextNode->type == XML_NAMESPACE_DECL) {
/*
* As always: take care of those nasty
* namespace nodes.
*/
set->nodeTab[i] = NULL;
}
xmlXPathNodeSetClear(set, hasNsNodes);
set->nodeNr = 1;
set->nodeTab[0] = contextNode;
goto evaluation_exit;
}
if (pos == maxPos) {
/*
* We are done.
*/
xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
goto evaluation_exit;
}
} else {
/*
* Remove the entry from the initial node set.
*/
set->nodeTab[i] = NULL;
if (contextNode->type == XML_NAMESPACE_DECL)
xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
}
if (exprRes != NULL) {
xmlXPathReleaseObject(ctxt->context, exprRes);
exprRes = NULL;
}
if (ctxt->value == contextObj) {
/*
* Don't free the temporary XPath object holding the
* context node, in order to avoid massive recreation
* inside this loop.
*/
valuePop(ctxt);
xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
} else {
/*
* The object was lost in the evaluation machinery.
* Can this happen? Maybe in case of internal-errors.
*/
contextObj = NULL;
}
}
goto evaluation_exit;
evaluation_error:
xmlXPathNodeSetClear(set, hasNsNodes);
newContextSize = 0;
evaluation_exit:
if (contextObj != NULL) {
if (ctxt->value == contextObj)
valuePop(ctxt);
xmlXPathReleaseObject(xpctxt, contextObj);
}
if (exprRes != NULL)
xmlXPathReleaseObject(ctxt->context, exprRes);
/*
* Reset/invalidate the context.
*/
xpctxt->node = oldContextNode;
xpctxt->doc = oldContextDoc;
xpctxt->contextSize = -1;
xpctxt->proximityPosition = -1;
return(newContextSize);
}
return(contextSize);
}
| 15,655 |
130,680 | 0 | static void conditionalAttr1AttributeSetter(v8::Local<v8::Value> jsValue, const v8::PropertyCallbackInfo<void>& info)
{
ExceptionState exceptionState(ExceptionState::SetterContext, "conditionalAttr1", "TestObject", info.Holder(), info.GetIsolate());
TestObject* imp = V8TestObject::toNative(info.Holder());
V8TRYCATCH_EXCEPTION_VOID(int, cppValue, toInt32(jsValue, exceptionState), exceptionState);
imp->setConditionalAttr1(cppValue);
}
| 15,656 |
176,733 | 0 | status_t Parcel::readBoolVector(std::unique_ptr<std::vector<bool>>* val) const {
const int32_t start = dataPosition();
int32_t size;
status_t status = readInt32(&size);
val->reset();
if (status != OK || size < 0) {
return status;
}
setDataPosition(start);
val->reset(new (std::nothrow) std::vector<bool>());
status = readBoolVector(val->get());
if (status != OK) {
val->reset();
}
return status;
}
| 15,657 |
183,363 | 1 | static ssize_t f_hidg_write(struct file *file, const char __user *buffer,
size_t count, loff_t *offp)
{
struct f_hidg *hidg = file->private_data;
struct usb_request *req;
unsigned long flags;
ssize_t status = -ENOMEM;
if (!access_ok(buffer, count))
return -EFAULT;
spin_lock_irqsave(&hidg->write_spinlock, flags);
#define WRITE_COND (!hidg->write_pending)
try_again:
/* write queue */
while (!WRITE_COND) {
spin_unlock_irqrestore(&hidg->write_spinlock, flags);
if (file->f_flags & O_NONBLOCK)
return -EAGAIN;
if (wait_event_interruptible_exclusive(
hidg->write_queue, WRITE_COND))
return -ERESTARTSYS;
spin_lock_irqsave(&hidg->write_spinlock, flags);
}
hidg->write_pending = 1;
req = hidg->req;
count = min_t(unsigned, count, hidg->report_length);
spin_unlock_irqrestore(&hidg->write_spinlock, flags);
status = copy_from_user(req->buf, buffer, count);
if (status != 0) {
ERROR(hidg->func.config->cdev,
"copy_from_user error\n");
status = -EINVAL;
goto release_write_pending;
}
spin_lock_irqsave(&hidg->write_spinlock, flags);
/* when our function has been disabled by host */
if (!hidg->req) {
free_ep_req(hidg->in_ep, req);
/*
* TODO
* Should we fail with error here?
*/
goto try_again;
}
req->status = 0;
req->zero = 0;
req->length = count;
req->complete = f_hidg_req_complete;
req->context = hidg;
status = usb_ep_queue(hidg->in_ep, req, GFP_ATOMIC);
if (status < 0) {
ERROR(hidg->func.config->cdev,
"usb_ep_queue error on int endpoint %zd\n", status);
goto release_write_pending_unlocked;
} else {
status = count;
}
spin_unlock_irqrestore(&hidg->write_spinlock, flags);
return status;
release_write_pending:
spin_lock_irqsave(&hidg->write_spinlock, flags);
release_write_pending_unlocked:
hidg->write_pending = 0;
spin_unlock_irqrestore(&hidg->write_spinlock, flags);
wake_up(&hidg->write_queue);
return status;
}
| 15,658 |
171,808 | 0 | static btif_hh_device_t *btif_hh_find_dev_by_bda(bt_bdaddr_t *bd_addr)
{
UINT32 i;
for (i = 0; i < BTIF_HH_MAX_HID; i++) {
if (btif_hh_cb.devices[i].dev_status != BTHH_CONN_STATE_UNKNOWN &&
memcmp(&(btif_hh_cb.devices[i].bd_addr), bd_addr, BD_ADDR_LEN) == 0)
{
return &btif_hh_cb.devices[i];
}
}
return NULL;
}
| 15,659 |
40,787 | 0 | static int x25_listen(struct socket *sock, int backlog)
{
struct sock *sk = sock->sk;
int rc = -EOPNOTSUPP;
lock_sock(sk);
if (sk->sk_state != TCP_LISTEN) {
memset(&x25_sk(sk)->dest_addr, 0, X25_ADDR_LEN);
sk->sk_max_ack_backlog = backlog;
sk->sk_state = TCP_LISTEN;
rc = 0;
}
release_sock(sk);
return rc;
}
| 15,660 |
114,624 | 0 | bool WebPluginDelegateProxy::BackgroundChanged(
gfx::NativeDrawingContext context,
const gfx::Rect& rect) {
#if defined(OS_ANDROID)
NOTIMPLEMENTED();
#else
#if defined(OS_WIN)
HBITMAP hbitmap = static_cast<HBITMAP>(GetCurrentObject(context, OBJ_BITMAP));
if (hbitmap == NULL) {
NOTREACHED();
return true;
}
BITMAP bitmap = { 0 };
int result = GetObject(hbitmap, sizeof(bitmap), &bitmap);
if (!result) {
NOTREACHED();
return true;
}
XFORM xf;
if (!GetWorldTransform(context, &xf)) {
NOTREACHED();
return true;
}
gfx::Rect bitmap_rect(static_cast<int>(-xf.eDx), static_cast<int>(-xf.eDy),
bitmap.bmWidth, bitmap.bmHeight);
gfx::Rect check_rect = rect.Intersect(bitmap_rect);
int row_byte_size = check_rect.width() * (bitmap.bmBitsPixel / 8);
for (int y = check_rect.y(); y < check_rect.bottom(); y++) {
char* hdc_row_start = static_cast<char*>(bitmap.bmBits) +
(y + static_cast<int>(xf.eDy)) * bitmap.bmWidthBytes +
(check_rect.x() + static_cast<int>(xf.eDx)) * (bitmap.bmBitsPixel / 8);
uint32_t* canvas_row_start =
background_store_.canvas->getDevice()->accessBitmap(true).getAddr32(
check_rect.x() - plugin_rect_.x(), y - plugin_rect_.y());
if (memcmp(hdc_row_start, canvas_row_start, row_byte_size) != 0)
return true;
}
#else
#if defined(OS_MACOSX)
CGAffineTransform transform = CGContextGetCTM(context);
bool flipped = fabs(transform.d + 1) < 0.0001;
CGFloat context_offset_x = -transform.tx;
CGFloat context_offset_y = flipped ? transform.ty -
CGBitmapContextGetHeight(context)
: -transform.ty;
gfx::Rect full_content_rect(context_offset_x, context_offset_y,
CGBitmapContextGetWidth(context),
CGBitmapContextGetHeight(context));
#else
cairo_surface_t* page_surface = cairo_get_target(context);
DCHECK_EQ(cairo_surface_get_type(page_surface), CAIRO_SURFACE_TYPE_IMAGE);
DCHECK_EQ(cairo_image_surface_get_format(page_surface), CAIRO_FORMAT_ARGB32);
double page_x_double = rect.x();
double page_y_double = rect.y();
cairo_user_to_device(context, &page_x_double, &page_y_double);
gfx::Rect full_content_rect(0, 0,
cairo_image_surface_get_width(page_surface),
cairo_image_surface_get_height(page_surface));
#endif
gfx::Rect content_rect = rect.Intersect(full_content_rect);
#if defined(OS_MACOSX)
const unsigned char* page_bytes = static_cast<const unsigned char*>(
CGBitmapContextGetData(context));
int page_stride = CGBitmapContextGetBytesPerRow(context);
int page_start_x = content_rect.x() - context_offset_x;
int page_start_y = content_rect.y() - context_offset_y;
skia::ScopedPlatformPaint scoped_platform_paint(
background_store_.canvas.get());
CGContextRef bg_context = scoped_platform_paint.GetPlatformSurface();
DCHECK_EQ(CGBitmapContextGetBitsPerPixel(context),
CGBitmapContextGetBitsPerPixel(bg_context));
const unsigned char* bg_bytes = static_cast<const unsigned char*>(
CGBitmapContextGetData(bg_context));
int full_bg_width = CGBitmapContextGetWidth(bg_context);
int full_bg_height = CGBitmapContextGetHeight(bg_context);
int bg_stride = CGBitmapContextGetBytesPerRow(bg_context);
int bg_last_row = CGBitmapContextGetHeight(bg_context) - 1;
int bytes_per_pixel = CGBitmapContextGetBitsPerPixel(context) / 8;
#else
cairo_surface_flush(page_surface);
const unsigned char* page_bytes = cairo_image_surface_get_data(page_surface);
int page_stride = cairo_image_surface_get_stride(page_surface);
int page_start_x = static_cast<int>(page_x_double);
int page_start_y = static_cast<int>(page_y_double);
skia::ScopedPlatformPaint scoped_platform_paint(
background_store_.canvas.get());
cairo_surface_t* bg_surface =cairo_get_target(
scoped_platform_paint.GetPlatformSurface());
DCHECK_EQ(cairo_surface_get_type(bg_surface), CAIRO_SURFACE_TYPE_IMAGE);
DCHECK_EQ(cairo_image_surface_get_format(bg_surface), CAIRO_FORMAT_ARGB32);
cairo_surface_flush(bg_surface);
const unsigned char* bg_bytes = cairo_image_surface_get_data(bg_surface);
int full_bg_width = cairo_image_surface_get_width(bg_surface);
int full_bg_height = cairo_image_surface_get_height(bg_surface);
int bg_stride = cairo_image_surface_get_stride(bg_surface);
int bytes_per_pixel = 4; // ARGB32 = 4 bytes per pixel.
#endif
int damage_width = content_rect.width();
int damage_height = content_rect.height();
int bg_start_x = rect.x() - plugin_rect_.x();
int bg_start_y = rect.y() - plugin_rect_.y();
DCHECK_LE(bg_start_x + damage_width, full_bg_width);
DCHECK_LE(bg_start_y + damage_height, full_bg_height);
int bg_x_byte_offset = bg_start_x * bytes_per_pixel;
int page_x_byte_offset = page_start_x * bytes_per_pixel;
for (int row = 0; row < damage_height; ++row) {
int page_offset = page_stride * (page_start_y + row) + page_x_byte_offset;
int bg_y = bg_start_y + row;
#if defined(OS_MACOSX)
bg_y = bg_last_row - bg_y;
#endif
int bg_offset = bg_stride * bg_y + bg_x_byte_offset;
if (memcmp(page_bytes + page_offset,
bg_bytes + bg_offset,
damage_width * bytes_per_pixel) != 0)
return true;
}
#endif
#endif // OS_ANDROID
return false;
}
| 15,661 |
110,096 | 0 | virtual void OnConnectionTypeChanged(
net::NetworkChangeNotifier::ConnectionType type) {
process_host_->Send(new PpapiMsg_SetNetworkState(
type != net::NetworkChangeNotifier::CONNECTION_NONE));
}
| 15,662 |
178,473 | 1 | ftp_genlist(ftpbuf_t *ftp, const char *cmd, const char *path TSRMLS_DC)
{
php_stream *tmpstream = NULL;
databuf_t *data = NULL;
char *ptr;
int ch, lastch;
size_t size, rcvd;
size_t lines;
char **ret = NULL;
char **entry;
char *text;
if ((tmpstream = php_stream_fopen_tmpfile()) == NULL) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to create temporary file. Check permissions in temporary files directory.");
return NULL;
}
if (!ftp_type(ftp, FTPTYPE_ASCII)) {
goto bail;
}
if ((data = ftp_getdata(ftp TSRMLS_CC)) == NULL) {
goto bail;
}
ftp->data = data;
if (!ftp_putcmd(ftp, cmd, path)) {
goto bail;
}
if (!ftp_getresp(ftp) || (ftp->resp != 150 && ftp->resp != 125 && ftp->resp != 226)) {
goto bail;
}
/* some servers don't open a ftp-data connection if the directory is empty */
if (ftp->resp == 226) {
ftp->data = data_close(ftp, data);
php_stream_close(tmpstream);
return ecalloc(1, sizeof(char*));
}
/* pull data buffer into tmpfile */
if ((data = data_accept(data, ftp TSRMLS_CC)) == NULL) {
goto bail;
}
size = 0;
lines = 0;
lastch = 0;
while ((rcvd = my_recv(ftp, data->fd, data->buf, FTP_BUFSIZE))) {
if (rcvd == -1 || rcvd > ((size_t)(-1))-size) {
goto bail;
}
php_stream_write(tmpstream, data->buf, rcvd);
size += rcvd;
for (ptr = data->buf; rcvd; rcvd--, ptr++) {
if (*ptr == '\n' && lastch == '\r') {
lines++;
} else {
size++;
}
lastch = *ptr;
}
lastch = *ptr;
}
}
| 15,663 |
16,514 | 0 | bool param_get_location(
const char *parameter,
MyString &filename,
int &line_number)
{
bool found_it;
if (parameter != NULL && extra_info != NULL) {
found_it = extra_info->GetParam(parameter, filename, line_number);
} else {
found_it = false;
}
return found_it;
}
| 15,664 |
171,551 | 0 | String8::String8(const char16_t* o, size_t len)
: mString(allocFromUTF16(o, len))
{
}
| 15,665 |
79,397 | 0 | static int mov_write_stbl_tag(AVFormatContext *s, AVIOContext *pb, MOVMuxContext *mov, MOVTrack *track)
{
int64_t pos = avio_tell(pb);
int ret;
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "stbl");
mov_write_stsd_tag(s, pb, mov, track);
mov_write_stts_tag(pb, track);
if ((track->par->codec_type == AVMEDIA_TYPE_VIDEO ||
track->par->codec_tag == MKTAG('r','t','p',' ')) &&
track->has_keyframes && track->has_keyframes < track->entry)
mov_write_stss_tag(pb, track, MOV_SYNC_SAMPLE);
if (track->par->codec_type == AVMEDIA_TYPE_VIDEO && track->has_disposable)
mov_write_sdtp_tag(pb, track);
if (track->mode == MODE_MOV && track->flags & MOV_TRACK_STPS)
mov_write_stss_tag(pb, track, MOV_PARTIAL_SYNC_SAMPLE);
if (track->par->codec_type == AVMEDIA_TYPE_VIDEO &&
track->flags & MOV_TRACK_CTTS && track->entry) {
if ((ret = mov_write_ctts_tag(s, pb, track)) < 0)
return ret;
}
mov_write_stsc_tag(pb, track);
mov_write_stsz_tag(pb, track);
mov_write_stco_tag(pb, track);
if (track->cenc.aes_ctr) {
ff_mov_cenc_write_stbl_atoms(&track->cenc, pb);
}
if (track->par->codec_id == AV_CODEC_ID_OPUS || track->par->codec_id == AV_CODEC_ID_AAC) {
mov_preroll_write_stbl_atoms(pb, track);
}
return update_size(pb, pos);
}
| 15,666 |
103,271 | 0 | net::SocketStreamJob* WebSocketJobFactory(
const GURL& url, net::SocketStream::Delegate* delegate) {
net::WebSocketJob* job = new net::WebSocketJob(delegate);
job->InitSocketStream(new net::SocketStream(url, job));
return job;
}
| 15,667 |
37,748 | 0 | static int dr_interception(struct vcpu_svm *svm)
{
int reg, dr;
unsigned long val;
int err;
if (svm->vcpu.guest_debug == 0) {
/*
* No more DR vmexits; force a reload of the debug registers
* and reenter on this instruction. The next vmexit will
* retrieve the full state of the debug registers.
*/
clr_dr_intercepts(svm);
svm->vcpu.arch.switch_db_regs |= KVM_DEBUGREG_WONT_EXIT;
return 1;
}
if (!boot_cpu_has(X86_FEATURE_DECODEASSISTS))
return emulate_on_interception(svm);
reg = svm->vmcb->control.exit_info_1 & SVM_EXITINFO_REG_MASK;
dr = svm->vmcb->control.exit_code - SVM_EXIT_READ_DR0;
if (dr >= 16) { /* mov to DRn */
val = kvm_register_read(&svm->vcpu, reg);
kvm_set_dr(&svm->vcpu, dr - 16, val);
} else {
err = kvm_get_dr(&svm->vcpu, dr, &val);
if (!err)
kvm_register_write(&svm->vcpu, reg, val);
}
skip_emulated_instruction(&svm->vcpu);
return 1;
}
| 15,668 |
142,467 | 0 | void ShelfLayoutManager::OnPinnedStateChanged(aura::Window* pinned_window) {
UpdateVisibilityState();
}
| 15,669 |
37,805 | 0 | static int pause_interception(struct vcpu_svm *svm)
{
kvm_vcpu_on_spin(&(svm->vcpu));
return 1;
}
| 15,670 |
3,097 | 0 | static int iccdomain(i_ctx_t * i_ctx_p, ref *space, float *ptr)
{
int components, i, code = 0;
ref *tempref, ICCdict, valref;
code = array_get(imemory, space, 1, &ICCdict);
if (code < 0)
return code;
code = dict_find_string(&ICCdict, "N", &tempref);
if (code < 0)
return code;
if (code == 0)
return gs_note_error(gs_error_undefined);
components = tempref->value.intval;
code = dict_find_string(&ICCdict, "Range", &tempref);
if (code > 0 && !r_has_type(tempref, t_null)) {
for (i=0;i<components * 2;i++) {
code = array_get(imemory, tempref, i, &valref);
if (code < 0)
return code;
if (r_has_type(&valref, t_integer))
ptr[i * 2] = (float)valref.value.intval;
else
ptr[i * 2] = valref.value.realval;
}
} else {
for (i=0;i<components;i++) {
ptr[i * 2] = 0;
ptr[(i * 2) + 1] = 1;
}
}
return 0;
}
| 15,671 |
87,773 | 0 | static int autocomplete_type(const char* strflag) {
int i;
for (i = 0; i < R_CORE_AUTOCMPLT_END; ++i) {
if (autocomplete_flags[i].desc && !strncmp (strflag, autocomplete_flags[i].name, 5)) {
return autocomplete_flags[i].type;
}
}
eprintf ("Invalid flag '%s'\n", strflag);
return R_CORE_AUTOCMPLT_END;
}
| 15,672 |
83,630 | 0 | int zgfx_decompress(ZGFX_CONTEXT* zgfx, const BYTE* pSrcData, UINT32 SrcSize, BYTE** ppDstData,
UINT32* pDstSize, UINT32 flags)
{
int status = -1;
BYTE descriptor;
wStream* stream = Stream_New((BYTE*)pSrcData, SrcSize);
if (!stream)
return -1;
if (Stream_GetRemainingLength(stream) < 1)
goto fail;
Stream_Read_UINT8(stream, descriptor); /* descriptor (1 byte) */
if (descriptor == ZGFX_SEGMENTED_SINGLE)
{
if (!zgfx_decompress_segment(zgfx, stream, Stream_GetRemainingLength(stream)))
goto fail;
*ppDstData = NULL;
if (zgfx->OutputCount > 0)
*ppDstData = (BYTE*) malloc(zgfx->OutputCount);
if (!*ppDstData)
goto fail;
*pDstSize = zgfx->OutputCount;
CopyMemory(*ppDstData, zgfx->OutputBuffer, zgfx->OutputCount);
}
else if (descriptor == ZGFX_SEGMENTED_MULTIPART)
{
UINT32 segmentSize;
UINT16 segmentNumber;
UINT16 segmentCount;
UINT32 uncompressedSize;
BYTE* pConcatenated;
size_t used = 0;
if (Stream_GetRemainingLength(stream) < 6)
goto fail;
Stream_Read_UINT16(stream, segmentCount); /* segmentCount (2 bytes) */
Stream_Read_UINT32(stream, uncompressedSize); /* uncompressedSize (4 bytes) */
if (Stream_GetRemainingLength(stream) < segmentCount * sizeof(UINT32))
goto fail;
pConcatenated = (BYTE*) malloc(uncompressedSize);
if (!pConcatenated)
goto fail;
*ppDstData = pConcatenated;
*pDstSize = uncompressedSize;
for (segmentNumber = 0; segmentNumber < segmentCount; segmentNumber++)
{
if (Stream_GetRemainingLength(stream) < sizeof(UINT32))
goto fail;
Stream_Read_UINT32(stream, segmentSize); /* segmentSize (4 bytes) */
if (!zgfx_decompress_segment(zgfx, stream, segmentSize))
goto fail;
if (zgfx->OutputCount > UINT32_MAX - used)
goto fail;
if (used + zgfx->OutputCount > uncompressedSize)
goto fail;
CopyMemory(pConcatenated, zgfx->OutputBuffer, zgfx->OutputCount);
pConcatenated += zgfx->OutputCount;
used += zgfx->OutputCount;
}
}
else
{
goto fail;
}
status = 1;
fail:
Stream_Free(stream, FALSE);
return status;
}
| 15,673 |
174,046 | 0 | void WriteOutput(char *filename, u8 *data, u32 picSize)
{
/* foutput is global file pointer */
if (foutput == NULL)
{
/* open output file for writing, can be disabled with define.
* If file open fails -> exit */
if (strcmp(filename, "none") != 0)
{
#if !defined(_NO_OUT)
foutput = fopen(filename, "wb");
if (foutput == NULL)
{
DEBUG(("UNABLE TO OPEN OUTPUT FILE\n"));
exit(100);
}
#endif
}
}
if (foutput && data)
fwrite(data, 1, picSize, foutput);
}
| 15,674 |
75,858 | 0 | snmp_vrrp_handler(__attribute__((unused)) vector_t *strvec)
{
global_data->enable_snmp_vrrp = true;
}
| 15,675 |
29,457 | 0 | static int set_multidrop_mode(struct sb_uart_port *port, unsigned int mode)
{
int mdr = SB105XA_MDR_NPS;
if (mode & MDMODE_ENABLE)
{
mdr |= SB105XA_MDR_MDE;
}
if (1) //(mode & MDMODE_AUTO)
{
int efr = 0;
mdr |= SB105XA_MDR_AME;
efr = sb1054_get_register(port, PAGE_3, SB105X_EFR);
efr |= SB105X_EFR_SCD;
sb1054_set_register(port, PAGE_3, SB105X_EFR, efr);
}
sb1054_set_register(port, PAGE_1, SB105XA_MDR, mdr);
port->mdmode &= ~0x6;
port->mdmode |= mode;
printk("[%d] multidrop init: %x\n", port->line, port->mdmode);
return 0;
}
| 15,676 |
114,055 | 0 | void TaskManagerView::Layout() {
const int kTableButtonSpacing = 12;
gfx::Size size = kill_button_->GetPreferredSize();
int prefered_width = size.width();
int prefered_height = size.height();
tab_table_->SetBounds(
x() + views::kPanelHorizMargin,
y() + views::kPanelVertMargin,
width() - 2 * views::kPanelHorizMargin,
height() - 2 * views::kPanelVertMargin - prefered_height);
gfx::Rect parent_bounds = parent()->GetContentsBounds();
int y_buttons =
parent_bounds.bottom() - prefered_height - views::kButtonVEdgeMargin;
kill_button_->SetBounds(
x() + width() - prefered_width - views::kPanelHorizMargin,
y_buttons,
prefered_width,
prefered_height);
if (purge_memory_button_) {
size = purge_memory_button_->GetPreferredSize();
purge_memory_button_->SetBounds(
kill_button_->x() - size.width() -
views::kUnrelatedControlHorizontalSpacing,
y_buttons, size.width(), size.height());
}
size = about_memory_link_->GetPreferredSize();
int link_prefered_width = size.width();
int link_prefered_height = size.height();
int link_y_offset = std::max(0, prefered_height - link_prefered_height) / 2;
about_memory_link_->SetBounds(
x() + views::kPanelHorizMargin,
y_buttons + prefered_height - link_prefered_height - link_y_offset,
link_prefered_width,
link_prefered_height);
}
| 15,677 |
156,193 | 0 | void RendererSchedulerImpl::EndIdlePeriodForTesting(
const base::Closure& callback,
base::TimeTicks time_remaining) {
main_thread_only().in_idle_period_for_testing = false;
EndIdlePeriod();
callback.Run();
}
| 15,678 |
99,662 | 0 | VaapiVideoDecodeAccelerator::VaapiVP8Accelerator::VaapiVP8Accelerator(
VaapiVideoDecodeAccelerator* vaapi_dec,
VaapiWrapper* vaapi_wrapper)
: vaapi_wrapper_(vaapi_wrapper), vaapi_dec_(vaapi_dec) {
DCHECK(vaapi_wrapper_);
DCHECK(vaapi_dec_);
}
| 15,679 |
19,483 | 0 | netdev_tx_t efx_hard_start_xmit(struct sk_buff *skb,
struct net_device *net_dev)
{
struct efx_nic *efx = netdev_priv(net_dev);
struct efx_tx_queue *tx_queue;
unsigned index, type;
EFX_WARN_ON_PARANOID(!netif_device_present(net_dev));
index = skb_get_queue_mapping(skb);
type = skb->ip_summed == CHECKSUM_PARTIAL ? EFX_TXQ_TYPE_OFFLOAD : 0;
if (index >= efx->n_tx_channels) {
index -= efx->n_tx_channels;
type |= EFX_TXQ_TYPE_HIGHPRI;
}
tx_queue = efx_get_tx_queue(efx, index, type);
return efx_enqueue_skb(tx_queue, skb);
}
| 15,680 |
110,005 | 0 | RenderObject* HTMLSelectElement::createRenderer(RenderStyle*)
{
if (usesMenuList())
return new (document()->renderArena()) RenderMenuList(this);
return new (document()->renderArena()) RenderListBox(this);
}
| 15,681 |
107,140 | 0 | void LayerTreeHostQt::removeTile(WebLayerID layerID, int tileID)
{
m_webPage->send(Messages::LayerTreeHostProxy::RemoveTileForLayer(layerID, tileID));
}
| 15,682 |
152,064 | 0 | void RenderFrameHostImpl::RenderProcessGone(SiteInstanceImpl* site_instance) {
DCHECK_EQ(site_instance_.get(), site_instance);
if (GetNavigationHandle())
GetNavigationHandle()->set_net_error_code(net::ERR_ABORTED);
ResetNavigationRequests();
ResetLoadingState();
set_nav_entry_id(0);
OnAudibleStateChanged(false);
}
| 15,683 |
88,257 | 0 | dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms) {
HASH_TABLE_ITER iter;
hashTableIterInit(&iter, &(p->elementTypes));
for (;;) {
ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
if (! e)
break;
if (e->allocDefaultAtts != 0)
ms->free_fcn(e->defaultAtts);
}
hashTableDestroy(&(p->generalEntities));
#ifdef XML_DTD
hashTableDestroy(&(p->paramEntities));
#endif /* XML_DTD */
hashTableDestroy(&(p->elementTypes));
hashTableDestroy(&(p->attributeIds));
hashTableDestroy(&(p->prefixes));
poolDestroy(&(p->pool));
poolDestroy(&(p->entityValuePool));
if (isDocEntity) {
ms->free_fcn(p->scaffIndex);
ms->free_fcn(p->scaffold);
}
ms->free_fcn(p);
}
| 15,684 |
5,200 | 0 | PHP_FUNCTION(pg_insert)
{
zval *pgsql_link, *values;
char *table;
size_t table_len;
zend_ulong option = PGSQL_DML_EXEC, return_sql;
PGconn *pg_link;
PGresult *pg_result;
ExecStatusType status;
pgsql_result_handle *pgsql_handle;
zend_string *sql = NULL;
int id = -1, argc = ZEND_NUM_ARGS();
if (zend_parse_parameters(argc, "rsa|l",
&pgsql_link, &table, &table_len, &values, &option) == FAILURE) {
return;
}
if (option & ~(PGSQL_CONV_OPTS|PGSQL_DML_NO_CONV|PGSQL_DML_EXEC|PGSQL_DML_ASYNC|PGSQL_DML_STRING|PGSQL_DML_ESCAPE)) {
php_error_docref(NULL, E_WARNING, "Invalid option is specified");
RETURN_FALSE;
}
ZEND_FETCH_RESOURCE2(pg_link, PGconn *, pgsql_link, id, "PostgreSQL link", le_link, le_plink);
if (php_pgsql_flush_query(pg_link)) {
php_error_docref(NULL, E_NOTICE, "Detected unhandled result(s) in connection");
}
return_sql = option & PGSQL_DML_STRING;
if (option & PGSQL_DML_EXEC) {
/* return resource when executed */
option = option & ~PGSQL_DML_EXEC;
if (php_pgsql_insert(pg_link, table, values, option|PGSQL_DML_STRING, &sql) == FAILURE) {
RETURN_FALSE;
}
pg_result = PQexec(pg_link, sql->val);
if ((PGG(auto_reset_persistent) & 2) && PQstatus(pg_link) != CONNECTION_OK) {
PQclear(pg_result);
PQreset(pg_link);
pg_result = PQexec(pg_link, sql->val);
}
efree(sql);
if (pg_result) {
status = PQresultStatus(pg_result);
} else {
status = (ExecStatusType) PQstatus(pg_link);
}
switch (status) {
case PGRES_EMPTY_QUERY:
case PGRES_BAD_RESPONSE:
case PGRES_NONFATAL_ERROR:
case PGRES_FATAL_ERROR:
PHP_PQ_ERROR("Query failed: %s", pg_link);
PQclear(pg_result);
RETURN_FALSE;
break;
case PGRES_COMMAND_OK: /* successful command that did not return rows */
default:
if (pg_result) {
pgsql_handle = (pgsql_result_handle *) emalloc(sizeof(pgsql_result_handle));
pgsql_handle->conn = pg_link;
pgsql_handle->result = pg_result;
pgsql_handle->row = 0;
ZEND_REGISTER_RESOURCE(return_value, pgsql_handle, le_result);
return;
} else {
PQclear(pg_result);
RETURN_FALSE;
}
break;
}
} else if (php_pgsql_insert(pg_link, table, values, option, &sql) == FAILURE) {
RETURN_FALSE;
}
if (return_sql) {
RETURN_STR(sql);
return;
}
RETURN_TRUE;
}
| 15,685 |
35,499 | 0 | static int __do_insn_fetch_bytes(struct x86_emulate_ctxt *ctxt, int op_size)
{
int rc;
unsigned size;
unsigned long linear;
int cur_size = ctxt->fetch.end - ctxt->fetch.data;
struct segmented_address addr = { .seg = VCPU_SREG_CS,
.ea = ctxt->eip + cur_size };
size = 15UL ^ cur_size;
rc = __linearize(ctxt, addr, size, false, true, &linear);
if (unlikely(rc != X86EMUL_CONTINUE))
return rc;
size = min_t(unsigned, size, PAGE_SIZE - offset_in_page(linear));
/*
* One instruction can only straddle two pages,
* and one has been loaded at the beginning of
* x86_decode_insn. So, if not enough bytes
* still, we must have hit the 15-byte boundary.
*/
if (unlikely(size < op_size))
return X86EMUL_UNHANDLEABLE;
rc = ctxt->ops->fetch(ctxt, linear, ctxt->fetch.end,
size, &ctxt->exception);
if (unlikely(rc != X86EMUL_CONTINUE))
return rc;
ctxt->fetch.end += size;
return X86EMUL_CONTINUE;
}
| 15,686 |
132,271 | 0 | bool RenderFrameImpl::ShouldDisplayErrorPageForFailedLoad(
int error_code,
const GURL& unreachable_url) {
if (error_code == net::ERR_ABORTED)
return false;
if (error_code == net::ERR_BLOCKED_BY_CLIENT &&
render_view_->renderer_preferences_.disable_client_blocked_error_page) {
return false;
}
if (GetContentClient()->renderer()->ShouldSuppressErrorPage(
this, unreachable_url)) {
return false;
}
if (RenderThreadImpl::current() &&
RenderThreadImpl::current()->layout_test_mode()) {
return false;
}
return true;
}
| 15,687 |
61,577 | 0 | static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
{
int i, j, nb_segments = 0;
MXFIndexTableSegment **unsorted_segments;
int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
/* count number of segments, allocate arrays and copy unsorted segments */
for (i = 0; i < mxf->metadata_sets_count; i++)
if (mxf->metadata_sets[i]->type == IndexTableSegment)
nb_segments++;
if (!nb_segments)
return AVERROR_INVALIDDATA;
if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
!(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
av_freep(sorted_segments);
av_free(unsorted_segments);
return AVERROR(ENOMEM);
}
for (i = j = 0; i < mxf->metadata_sets_count; i++)
if (mxf->metadata_sets[i]->type == IndexTableSegment)
unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
*nb_sorted_segments = 0;
/* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
for (i = 0; i < nb_segments; i++) {
int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
uint64_t best_index_duration = 0;
for (j = 0; j < nb_segments; j++) {
MXFIndexTableSegment *s = unsorted_segments[j];
/* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
* We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
* If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
*/
if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
(best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
(s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
best = j;
best_body_sid = s->body_sid;
best_index_sid = s->index_sid;
best_index_start = s->index_start_position;
best_index_duration = s->index_duration;
}
}
/* no suitable entry found -> we're done */
if (best == -1)
break;
(*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
last_body_sid = best_body_sid;
last_index_sid = best_index_sid;
last_index_start = best_index_start;
}
av_free(unsorted_segments);
return 0;
}
| 15,688 |
106,401 | 0 | WebKeyboardEvent* BuildKeyEvent(const PP_InputEvent& event) {
WebKeyboardEvent* key_event = new WebKeyboardEvent();
switch (event.type) {
case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
key_event->type = WebInputEvent::RawKeyDown;
break;
case PP_INPUTEVENT_TYPE_KEYDOWN:
key_event->type = WebInputEvent::KeyDown;
break;
case PP_INPUTEVENT_TYPE_KEYUP:
key_event->type = WebInputEvent::KeyUp;
break;
default:
NOTREACHED();
}
key_event->timeStampSeconds = event.time_stamp;
key_event->modifiers = event.u.key.modifier;
key_event->windowsKeyCode = event.u.key.key_code;
return key_event;
}
| 15,689 |
161,520 | 0 | void RenderFrameDevToolsAgentHost::WasShown() {
#if defined(OS_ANDROID)
GetWakeLock()->RequestWakeLock();
#endif
}
| 15,690 |
50,289 | 0 | static void abort_connection(struct mt_connection *curconn, struct mt_mactelnet_hdr *pkthdr, char *message) {
struct mt_packet pdata;
init_packet(&pdata, MT_PTYPE_DATA, pkthdr->dstaddr, pkthdr->srcaddr, pkthdr->seskey, curconn->outcounter);
add_control_packet(&pdata, MT_CPTYPE_PLAINDATA, message, strlen(message));
send_udp(curconn, &pdata);
/* Make connection time out; lets the previous message get acked before disconnecting */
curconn->state = STATE_CLOSED;
init_packet(&pdata, MT_PTYPE_END, pkthdr->dstaddr, pkthdr->srcaddr, pkthdr->seskey, curconn->outcounter);
send_udp(curconn, &pdata);
}
| 15,691 |
72,357 | 0 | process_sign_request2(SocketEntry *e)
{
u_char *blob, *data, *signature = NULL;
size_t blen, dlen, slen = 0;
u_int compat = 0, flags;
int r, ok = -1;
struct sshbuf *msg;
struct sshkey *key;
struct identity *id;
if ((msg = sshbuf_new()) == NULL)
fatal("%s: sshbuf_new failed", __func__);
if ((r = sshbuf_get_string(e->request, &blob, &blen)) != 0 ||
(r = sshbuf_get_string(e->request, &data, &dlen)) != 0 ||
(r = sshbuf_get_u32(e->request, &flags)) != 0)
fatal("%s: buffer error: %s", __func__, ssh_err(r));
if (flags & SSH_AGENT_OLD_SIGNATURE)
compat = SSH_BUG_SIGBLOB;
if ((r = sshkey_from_blob(blob, blen, &key)) != 0) {
error("%s: cannot parse key blob: %s", __func__, ssh_err(r));
goto send;
}
if ((id = lookup_identity(key, 2)) == NULL) {
verbose("%s: %s key not found", __func__, sshkey_type(key));
goto send;
}
if (id->confirm && confirm_key(id) != 0) {
verbose("%s: user refused key", __func__);
goto send;
}
if ((r = sshkey_sign(id->key, &signature, &slen,
data, dlen, agent_decode_alg(key, flags), compat)) != 0) {
error("%s: sshkey_sign: %s", __func__, ssh_err(r));
goto send;
}
/* Success */
ok = 0;
send:
sshkey_free(key);
if (ok == 0) {
if ((r = sshbuf_put_u8(msg, SSH2_AGENT_SIGN_RESPONSE)) != 0 ||
(r = sshbuf_put_string(msg, signature, slen)) != 0)
fatal("%s: buffer error: %s", __func__, ssh_err(r));
} else if ((r = sshbuf_put_u8(msg, SSH_AGENT_FAILURE)) != 0)
fatal("%s: buffer error: %s", __func__, ssh_err(r));
if ((r = sshbuf_put_stringb(e->output, msg)) != 0)
fatal("%s: buffer error: %s", __func__, ssh_err(r));
sshbuf_free(msg);
free(data);
free(blob);
free(signature);
}
| 15,692 |
109,280 | 0 | void InspectorPageAgent::deleteCookie(ErrorString*, const String& cookieName, const String& url)
{
KURL parsedURL(ParsedURLString, url);
for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext(m_page->mainFrame()))
WebCore::deleteCookie(frame->document(), parsedURL, cookieName);
}
| 15,693 |
91,112 | 0 | static struct rtable *__mkroute_output(const struct fib_result *res,
const struct flowi4 *fl4, int orig_oif,
struct net_device *dev_out,
unsigned int flags)
{
struct fib_info *fi = res->fi;
struct fib_nh_exception *fnhe;
struct in_device *in_dev;
u16 type = res->type;
struct rtable *rth;
bool do_cache;
in_dev = __in_dev_get_rcu(dev_out);
if (!in_dev)
return ERR_PTR(-EINVAL);
if (likely(!IN_DEV_ROUTE_LOCALNET(in_dev)))
if (ipv4_is_loopback(fl4->saddr) &&
!(dev_out->flags & IFF_LOOPBACK) &&
!netif_is_l3_master(dev_out))
return ERR_PTR(-EINVAL);
if (ipv4_is_lbcast(fl4->daddr))
type = RTN_BROADCAST;
else if (ipv4_is_multicast(fl4->daddr))
type = RTN_MULTICAST;
else if (ipv4_is_zeronet(fl4->daddr))
return ERR_PTR(-EINVAL);
if (dev_out->flags & IFF_LOOPBACK)
flags |= RTCF_LOCAL;
do_cache = true;
if (type == RTN_BROADCAST) {
flags |= RTCF_BROADCAST | RTCF_LOCAL;
fi = NULL;
} else if (type == RTN_MULTICAST) {
flags |= RTCF_MULTICAST | RTCF_LOCAL;
if (!ip_check_mc_rcu(in_dev, fl4->daddr, fl4->saddr,
fl4->flowi4_proto))
flags &= ~RTCF_LOCAL;
else
do_cache = false;
/* If multicast route do not exist use
* default one, but do not gateway in this case.
* Yes, it is hack.
*/
if (fi && res->prefixlen < 4)
fi = NULL;
} else if ((type == RTN_LOCAL) && (orig_oif != 0) &&
(orig_oif != dev_out->ifindex)) {
/* For local routes that require a particular output interface
* we do not want to cache the result. Caching the result
* causes incorrect behaviour when there are multiple source
* addresses on the interface, the end result being that if the
* intended recipient is waiting on that interface for the
* packet he won't receive it because it will be delivered on
* the loopback interface and the IP_PKTINFO ipi_ifindex will
* be set to the loopback interface as well.
*/
do_cache = false;
}
fnhe = NULL;
do_cache &= fi != NULL;
if (fi) {
struct rtable __rcu **prth;
struct fib_nh *nh = &FIB_RES_NH(*res);
fnhe = find_exception(nh, fl4->daddr);
if (!do_cache)
goto add;
if (fnhe) {
prth = &fnhe->fnhe_rth_output;
} else {
if (unlikely(fl4->flowi4_flags &
FLOWI_FLAG_KNOWN_NH &&
!(nh->nh_gw &&
nh->nh_scope == RT_SCOPE_LINK))) {
do_cache = false;
goto add;
}
prth = raw_cpu_ptr(nh->nh_pcpu_rth_output);
}
rth = rcu_dereference(*prth);
if (rt_cache_valid(rth) && dst_hold_safe(&rth->dst))
return rth;
}
add:
rth = rt_dst_alloc(dev_out, flags, type,
IN_DEV_CONF_GET(in_dev, NOPOLICY),
IN_DEV_CONF_GET(in_dev, NOXFRM),
do_cache);
if (!rth)
return ERR_PTR(-ENOBUFS);
rth->rt_iif = orig_oif;
RT_CACHE_STAT_INC(out_slow_tot);
if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
if (flags & RTCF_LOCAL &&
!(dev_out->flags & IFF_LOOPBACK)) {
rth->dst.output = ip_mc_output;
RT_CACHE_STAT_INC(out_slow_mc);
}
#ifdef CONFIG_IP_MROUTE
if (type == RTN_MULTICAST) {
if (IN_DEV_MFORWARD(in_dev) &&
!ipv4_is_local_multicast(fl4->daddr)) {
rth->dst.input = ip_mr_input;
rth->dst.output = ip_mc_output;
}
}
#endif
}
rt_set_nexthop(rth, fl4->daddr, res, fnhe, fi, type, 0, do_cache);
lwtunnel_set_redirect(&rth->dst);
return rth;
}
| 15,694 |
36,727 | 0 | process_mic(OM_uint32 *minor_status, gss_buffer_t mic_in,
spnego_gss_ctx_id_t sc, gss_buffer_t *mic_out,
OM_uint32 *negState, send_token_flag *tokflag)
{
OM_uint32 ret, tmpmin;
gss_qop_t qop_state;
gss_buffer_desc tmpmic = GSS_C_EMPTY_BUFFER;
ret = GSS_S_FAILURE;
if (mic_in != GSS_C_NO_BUFFER) {
ret = gss_verify_mic(minor_status, sc->ctx_handle,
&sc->DER_mechTypes,
mic_in, &qop_state);
if (ret != GSS_S_COMPLETE) {
*negState = REJECT;
*tokflag = ERROR_TOKEN_SEND;
return ret;
}
/* If we got a MIC, we must send a MIC. */
sc->mic_reqd = 1;
sc->mic_rcvd = 1;
}
if (sc->mic_reqd && !sc->mic_sent) {
ret = gss_get_mic(minor_status, sc->ctx_handle,
GSS_C_QOP_DEFAULT,
&sc->DER_mechTypes,
&tmpmic);
if (ret != GSS_S_COMPLETE) {
gss_release_buffer(&tmpmin, &tmpmic);
*tokflag = NO_TOKEN_SEND;
return ret;
}
*mic_out = malloc(sizeof(gss_buffer_desc));
if (*mic_out == GSS_C_NO_BUFFER) {
gss_release_buffer(&tmpmin, &tmpmic);
*tokflag = NO_TOKEN_SEND;
return GSS_S_FAILURE;
}
**mic_out = tmpmic;
sc->mic_sent = 1;
}
return GSS_S_COMPLETE;
}
| 15,695 |
156,221 | 0 | base::TimeDelta RendererSchedulerImpl::MostRecentExpectedQueueingTime() {
return main_thread_only().most_recent_expected_queueing_time;
}
| 15,696 |
21,392 | 0 | static int __init max_swapfiles_check(void)
{
MAX_SWAPFILES_CHECK();
return 0;
}
| 15,697 |
121,927 | 0 | void ChromeNetworkDelegate::SetEnableClientHints() {
client_hints_.reset(new ClientHints());
client_hints_->Init();
}
| 15,698 |
135,634 | 0 | static String ExtractSelectedText(const FrameSelection& selection,
TextIteratorBehavior behavior) {
const VisibleSelectionInFlatTree& visible_selection =
selection.ComputeVisibleSelectionInFlatTree();
const EphemeralRangeInFlatTree& range =
visible_selection.ToNormalizedEphemeralRange();
return PlainText(range, behavior).Replace(0, "");
}
| 15,699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.