idx
int64 | func
string | target
int64 |
|---|---|---|
127,226
|
posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl,
void *buffer, size_t size)
{
posix_acl_xattr_header *ext_acl = (posix_acl_xattr_header *)buffer;
posix_acl_xattr_entry *ext_entry;
int real_size, n;
real_size = posix_acl_xattr_size(acl->a_count);
if (!buffer)
return real_size;
if (real_size > size)
return -ERANGE;
ext_entry = ext_acl->a_entries;
ext_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
for (n=0; n < acl->a_count; n++, ext_entry++) {
const struct posix_acl_entry *acl_e = &acl->a_entries[n];
ext_entry->e_tag = cpu_to_le16(acl_e->e_tag);
ext_entry->e_perm = cpu_to_le16(acl_e->e_perm);
switch(acl_e->e_tag) {
case ACL_USER:
ext_entry->e_id =
cpu_to_le32(from_kuid(user_ns, acl_e->e_uid));
break;
case ACL_GROUP:
ext_entry->e_id =
cpu_to_le32(from_kgid(user_ns, acl_e->e_gid));
break;
default:
ext_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID);
break;
}
}
return real_size;
}
| 0
|
375,076
|
decompile_conbin(HeapTuple contup, TupleDesc tupdesc)
{
Form_pg_constraint con;
bool isnull;
Datum attr;
Datum expr;
con = (Form_pg_constraint) GETSTRUCT(contup);
attr = heap_getattr(contup, Anum_pg_constraint_conbin, tupdesc, &isnull);
if (isnull)
elog(ERROR, "null conbin for constraint %u", HeapTupleGetOid(contup));
expr = DirectFunctionCall2(pg_get_expr, attr,
ObjectIdGetDatum(con->conrelid));
return TextDatumGetCString(expr);
}
| 0
|
324,295
|
static void h264_h_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
{
h264_loop_filter_chroma_intra_c(pix, 1, stride, alpha, beta);
}
| 0
|
220,443
|
aspath_str2aspath (const char *str)
{
enum as_token token = as_token_unknown;
u_short as_type;
u_long asno = 0;
struct aspath *aspath;
int needtype;
aspath = aspath_new ();
/* We start default type as AS_SEQUENCE. */
as_type = AS_SEQUENCE;
needtype = 1;
while ((str = aspath_gettoken (str, &token, &asno)) != NULL)
{
switch (token)
{
case as_token_asval:
if (needtype)
{
aspath_segment_add (aspath, as_type);
needtype = 0;
}
aspath_as_add (aspath, asno);
break;
case as_token_set_start:
as_type = AS_SET;
aspath_segment_add (aspath, as_type);
needtype = 0;
break;
case as_token_set_end:
as_type = AS_SEQUENCE;
needtype = 1;
break;
case as_token_confed_seq_start:
as_type = AS_CONFED_SEQUENCE;
aspath_segment_add (aspath, as_type);
needtype = 0;
break;
case as_token_confed_seq_end:
as_type = AS_SEQUENCE;
needtype = 1;
break;
case as_token_confed_set_start:
as_type = AS_CONFED_SET;
aspath_segment_add (aspath, as_type);
needtype = 0;
break;
case as_token_confed_set_end:
as_type = AS_SEQUENCE;
needtype = 1;
break;
case as_token_unknown:
default:
aspath_free (aspath);
return NULL;
}
}
aspath_make_str_count (aspath);
return aspath;
}
| 0
|
13,531
|
void MediaStreamDispatcherHost::DoGenerateStream(
int32_t page_request_id,
const StreamControls& controls,
bool user_gesture,
GenerateStreamCallback callback,
MediaDeviceSaltAndOrigin salt_and_origin) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
salt_and_origin.origin)) {
std::move(callback).Run(MEDIA_DEVICE_INVALID_SECURITY_ORIGIN, std::string(),
MediaStreamDevices(), MediaStreamDevices());
return;
}
media_stream_manager_->GenerateStream(
render_process_id_, render_frame_id_, page_request_id, controls,
std::move(salt_and_origin), user_gesture, std::move(callback),
base::BindRepeating(&MediaStreamDispatcherHost::OnDeviceStopped,
weak_factory_.GetWeakPtr()),
base::BindRepeating(&MediaStreamDispatcherHost::OnDeviceChanged,
weak_factory_.GetWeakPtr()));
}
| 1
|
280,153
|
void ProfileImplIOData::Handle::LazyInitialize() const {
if (!initialized_) {
io_data_->InitializeOnUIThread(profile_);
PrefService* pref_service = profile_->GetPrefs();
io_data_->http_server_properties_manager_.reset(
new chrome_browser_net::HttpServerPropertiesManager(pref_service));
ChromeNetworkDelegate::InitializeReferrersEnabled(
io_data_->enable_referrers(), pref_service);
io_data_->clear_local_state_on_exit()->Init(
prefs::kClearSiteDataOnExit, pref_service, NULL);
io_data_->clear_local_state_on_exit()->MoveToThread(BrowserThread::IO);
#if defined(ENABLE_SAFE_BROWSING)
io_data_->safe_browsing_enabled()->Init(prefs::kSafeBrowsingEnabled,
pref_service, NULL);
io_data_->safe_browsing_enabled()->MoveToThread(BrowserThread::IO);
#endif
initialized_ = true;
}
}
| 0
|
388,141
|
gdm_session_start_reauthentication (GdmSession *session,
GPid pid_of_caller,
uid_t uid_of_caller)
{
GdmSessionConversation *conversation = session->priv->session_conversation;
g_return_if_fail (conversation != NULL);
conversation->reauth_pid_of_caller = pid_of_caller;
gdm_dbus_worker_call_start_reauthentication (conversation->worker_proxy,
(int) pid_of_caller,
(int) uid_of_caller,
conversation->worker_cancellable,
(GAsyncReadyCallback) on_reauthentication_started_cb,
conversation);
}
| 0
|
108,433
|
int wc_ecc_export_point_der(const int curve_idx, ecc_point* point, byte* out,
word32* outLen)
{
int ret = MP_OKAY;
word32 numlen;
#ifndef WOLFSSL_ATECC508A
#ifdef WOLFSSL_SMALL_STACK
byte* buf;
#else
byte buf[ECC_BUFSIZE];
#endif
#endif /* !WOLFSSL_ATECC508A */
if ((curve_idx < 0) || (wc_ecc_is_valid_idx(curve_idx) == 0))
return ECC_BAD_ARG_E;
/* return length needed only */
if (point != NULL && out == NULL && outLen != NULL) {
numlen = ecc_sets[curve_idx].size;
*outLen = 1 + 2*numlen;
return LENGTH_ONLY_E;
}
if (point == NULL || out == NULL || outLen == NULL)
return ECC_BAD_ARG_E;
numlen = ecc_sets[curve_idx].size;
if (*outLen < (1 + 2*numlen)) {
*outLen = 1 + 2*numlen;
return BUFFER_E;
}
#ifdef WOLFSSL_ATECC508A
/* TODO: Implement equiv call to ATECC508A */
ret = BAD_COND_E;
#else
/* store byte point type */
out[0] = ECC_POINT_UNCOMP;
#ifdef WOLFSSL_SMALL_STACK
buf = (byte*)XMALLOC(ECC_BUFSIZE, NULL, DYNAMIC_TYPE_ECC_BUFFER);
if (buf == NULL)
return MEMORY_E;
#endif
/* pad and store x */
XMEMSET(buf, 0, ECC_BUFSIZE);
ret = mp_to_unsigned_bin(point->x, buf +
(numlen - mp_unsigned_bin_size(point->x)));
if (ret != MP_OKAY)
goto done;
XMEMCPY(out+1, buf, numlen);
/* pad and store y */
XMEMSET(buf, 0, ECC_BUFSIZE);
ret = mp_to_unsigned_bin(point->y, buf +
(numlen - mp_unsigned_bin_size(point->y)));
if (ret != MP_OKAY)
goto done;
XMEMCPY(out+1+numlen, buf, numlen);
*outLen = 1 + 2*numlen;
done:
#ifdef WOLFSSL_SMALL_STACK
XFREE(buf, NULL, DYNAMIC_TYPE_ECC_BUFFER);
#endif
#endif /* WOLFSSL_ATECC508A */
return ret;
}
| 0
|
233,018
|
mem_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cont)
{
struct mem_cgroup *memcg, *parent;
long error = -ENOMEM;
int node;
memcg = mem_cgroup_alloc();
if (!memcg)
return ERR_PTR(error);
for_each_node(node)
if (alloc_mem_cgroup_per_zone_info(memcg, node))
goto free_out;
/* root ? */
if (cont->parent == NULL) {
int cpu;
enable_swap_cgroup();
parent = NULL;
if (mem_cgroup_soft_limit_tree_init())
goto free_out;
root_mem_cgroup = memcg;
for_each_possible_cpu(cpu) {
struct memcg_stock_pcp *stock =
&per_cpu(memcg_stock, cpu);
INIT_WORK(&stock->work, drain_local_stock);
}
hotcpu_notifier(memcg_cpu_hotplug_callback, 0);
} else {
parent = mem_cgroup_from_cont(cont->parent);
memcg->use_hierarchy = parent->use_hierarchy;
memcg->oom_kill_disable = parent->oom_kill_disable;
}
if (parent && parent->use_hierarchy) {
res_counter_init(&memcg->res, &parent->res);
res_counter_init(&memcg->memsw, &parent->memsw);
/*
* We increment refcnt of the parent to ensure that we can
* safely access it on res_counter_charge/uncharge.
* This refcnt will be decremented when freeing this
* mem_cgroup(see mem_cgroup_put).
*/
mem_cgroup_get(parent);
} else {
res_counter_init(&memcg->res, NULL);
res_counter_init(&memcg->memsw, NULL);
}
memcg->last_scanned_node = MAX_NUMNODES;
INIT_LIST_HEAD(&memcg->oom_notify);
if (parent)
memcg->swappiness = mem_cgroup_swappiness(parent);
atomic_set(&memcg->refcnt, 1);
memcg->move_charge_at_immigrate = 0;
mutex_init(&memcg->thresholds_lock);
return &memcg->css;
free_out:
__mem_cgroup_free(memcg);
return ERR_PTR(error);
}
| 0
|
7,543
|
size_t jsuGetFreeStack() {
#ifdef ARM
void *frame = __builtin_frame_address(0);
size_t stackPos = (size_t)((char*)frame);
size_t stackEnd = (size_t)((char*)&LINKER_END_VAR);
if (stackPos < stackEnd) return 0; // should never happen, but just in case of overflow!
return stackPos - stackEnd;
#elif defined(LINUX)
// On linux, we set STACK_BASE from `main`.
char ptr; // this is on the stack
extern void *STACK_BASE;
uint32_t count = (uint32_t)((size_t)STACK_BASE - (size_t)&ptr);
return 1000000 - count; // give it 1 megabyte of stack
#else
// stack depth seems pretty platform-specific :( Default to a value that disables it
return 1000000; // no stack depth check on this platform
#endif
}
| 1
|
391,308
|
PHP_FUNCTION(xml_error_string)
{
zend_long code;
char *str;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &code) == FAILURE) {
return;
}
str = (char *)XML_ErrorString((int)code);
if (str) {
RETVAL_STRING(str);
}
}
| 0
|
9,139
|
void VRDisplay::OnPresentChange() {
if (is_presenting_ && !is_valid_device_for_presenting_) {
DVLOG(1) << __FUNCTION__ << ": device not valid, not sending event";
return;
}
navigator_vr_->EnqueueVREvent(VRDisplayEvent::Create(
EventTypeNames::vrdisplaypresentchange, true, false, this, ""));
}
| 1
|
461,424
|
static int qid_inode_prefix_hash_bits(V9fsPDU *pdu, dev_t dev)
{
QpdEntry lookup = {
.dev = dev
}, *val;
uint32_t hash = dev;
VariLenAffix affix;
val = qht_lookup(&pdu->s->qpd_table, &lookup, hash);
if (!val) {
val = g_malloc0(sizeof(QpdEntry));
*val = lookup;
affix = affixForIndex(pdu->s->qp_affix_next);
val->prefix_bits = affix.bits;
qht_insert(&pdu->s->qpd_table, val, hash, NULL);
pdu->s->qp_ndevices++;
}
return val->prefix_bits;
}
| 0
|
57,762
|
void imap_logout_all (void)
{
CONNECTION* conn;
CONNECTION* tmp;
conn = mutt_socket_head ();
while (conn)
{
tmp = conn->next;
if (conn->account.type == MUTT_ACCT_TYPE_IMAP && conn->fd >= 0)
{
mutt_message (_("Closing connection to %s..."), conn->account.host);
imap_logout ((IMAP_DATA**) (void*) &conn->data);
mutt_clear_error ();
mutt_socket_free (conn);
}
conn = tmp;
}
}
| 0
|
97,211
|
static void mntns_put(struct ns_common *ns)
{
put_mnt_ns(to_mnt_ns(ns));
}
| 0
|
228,130
|
void RuleFeatureSet::FeatureMetadata::add(const FeatureMetadata& other)
{
usesFirstLineRules = usesFirstLineRules || other.usesFirstLineRules;
usesWindowInactiveSelector = usesWindowInactiveSelector || other.usesWindowInactiveSelector;
maxDirectAdjacentSelectors = std::max(maxDirectAdjacentSelectors, other.maxDirectAdjacentSelectors);
}
| 0
|
354,586
|
void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs, int error_code)
{
struct siginfo info;
tsk->thread.trap_no = 1;
tsk->thread.error_code = error_code;
memset(&info, 0, sizeof(info));
info.si_signo = SIGTRAP;
info.si_code = TRAP_BRKPT;
/* User-mode eip? */
info.si_addr = user_mode_vm(regs) ? (void __user *) regs->eip : NULL;
/* Send us the fakey SIGTRAP */
force_sig_info(SIGTRAP, &info, tsk);
}
| 0
|
477,207
|
static int virtbt_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
{
struct virtio_bluetooth *vbt = hci_get_drvdata(hdev);
struct scatterlist sg[1];
int err;
memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
sg_init_one(sg, skb->data, skb->len);
err = virtqueue_add_outbuf(vbt->vqs[VIRTBT_VQ_TX], sg, 1, skb,
GFP_KERNEL);
if (err) {
kfree_skb(skb);
return err;
}
virtqueue_kick(vbt->vqs[VIRTBT_VQ_TX]);
return 0;
}
| 0
|
182,129
|
void DemangleSymbols(std::string* text) {
#if defined(__GLIBCXX__) && !defined(__UCLIBC__)
std::string::size_type search_from = 0;
while (search_from < text->size()) {
std::string::size_type mangled_start =
text->find(kMangledSymbolPrefix, search_from);
if (mangled_start == std::string::npos) {
break; // Mangled symbol not found.
}
std::string::size_type mangled_end =
text->find_first_not_of(kSymbolCharacters, mangled_start);
if (mangled_end == std::string::npos) {
mangled_end = text->size();
}
std::string mangled_symbol =
text->substr(mangled_start, mangled_end - mangled_start);
int status = 0;
scoped_ptr<char, base::FreeDeleter> demangled_symbol(
abi::__cxa_demangle(mangled_symbol.c_str(), NULL, 0, &status));
if (status == 0) { // Demangling is successful.
text->erase(mangled_start, mangled_end - mangled_start);
text->insert(mangled_start, demangled_symbol.get());
search_from = mangled_start + strlen(demangled_symbol.get());
} else {
search_from = mangled_start + 2;
}
}
#endif // defined(__GLIBCXX__) && !defined(__UCLIBC__)
}
| 0
|
522,507
|
void ha_checkpoint_state(bool disable)
{
plugin_foreach(NULL, checkpoint_state_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, &disable);
}
| 0
|
460,427
|
void hidinput_disconnect(struct hid_device *hid)
{
struct hid_input *hidinput, *next;
hidinput_cleanup_battery(hid);
list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
list_del(&hidinput->list);
if (hidinput->registered)
input_unregister_device(hidinput->input);
else
input_free_device(hidinput->input);
kfree(hidinput->name);
kfree(hidinput);
}
/* led_work is spawned by input_dev callbacks, but doesn't access the
* parent input_dev at all. Once all input devices are removed, we
* know that led_work will never get restarted, so we can cancel it
* synchronously and are safe. */
cancel_work_sync(&hid->led_work);
}
| 0
|
301,216
|
GF_Err hnti_on_child_box(GF_Box *s, GF_Box *a, Bool is_rem)
{
GF_HintTrackInfoBox *ptr = (GF_HintTrackInfoBox *)s;
if (!ptr || !a) return GF_BAD_PARAM;
switch (a->type) {
//this is the value for GF_RTPBox - same as HintSampleEntry for RTP !!!
case GF_ISOM_BOX_TYPE_RTP:
case GF_ISOM_BOX_TYPE_SDP:
BOX_FIELD_ASSIGN(SDP, GF_Box)
break;
default:
break;
}
return GF_OK;
}
| 0
|
336,828
|
static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx,
RowContext *row, int n)
{
return dnxhd_decode_dct_block(ctx, row, n, 4, 32, 6);
}
| 0
|
434,844
|
pdf_filter_gs_op(fz_context *ctx, pdf_processor *proc, int b)
{
pdf_filter_processor *p = (pdf_filter_processor*)proc;
filter_flush(ctx, p, 0);
if (p->chain->op_gs_op)
p->chain->op_gs_op(ctx, p->chain, b);
}
| 0
|
504,187
|
static int tipc_link_build_nack_msg(struct tipc_link *l,
struct sk_buff_head *xmitq)
{
u32 def_cnt = ++l->stats.deferred_recv;
struct sk_buff_head *dfq = &l->deferdq;
u32 defq_len = skb_queue_len(dfq);
int match1, match2;
if (link_is_bc_rcvlink(l)) {
match1 = def_cnt & 0xf;
match2 = tipc_own_addr(l->net) & 0xf;
if (match1 == match2)
return TIPC_LINK_SND_STATE;
return 0;
}
if (defq_len >= 3 && !((defq_len - 3) % 16)) {
u16 rcvgap = buf_seqno(skb_peek(dfq)) - l->rcv_nxt;
tipc_link_build_proto_msg(l, STATE_MSG, 0, 0,
rcvgap, 0, 0, xmitq);
}
return 0;
}
| 0
|
378,794
|
answer_from_qmem(int dns_fd, struct query *q, unsigned char *qmem_cmc,
unsigned short *qmem_type, int qmem_len,
unsigned char *cmc_to_check)
/* Checks query memory and sends an (illegal) answer if this is a duplicate.
Returns: 1 = answer sent, drop this query, 0 = no answer sent, this is
not a duplicate. */
{
int i;
for (i = 0; i < qmem_len ; i++) {
if (qmem_type[i] == T_UNSET)
continue;
if (qmem_type[i] != q->type)
continue;
if (memcmp(qmem_cmc + i * 4, cmc_to_check, 4))
continue;
/* okay, match */
if (debug >= 1)
fprintf(stderr, "OUT from qmem for %s == duplicate, sending illegal reply\n", q->name);
write_dns(dns_fd, q, "x", 1, 'T');
q->id = 0; /* this query was used */
return 1;
}
/* here only when no match found */
return 0;
}
| 0
|
123,962
|
static void trigger_start_discovery(struct btd_adapter *adapter, guint delay)
{
DBG("");
cancel_passive_scanning(adapter);
if (adapter->discovery_idle_timeout > 0) {
timeout_remove(adapter->discovery_idle_timeout);
adapter->discovery_idle_timeout = 0;
}
/*
* If the controller got powered down in between, then ensure
* that we do not keep trying to restart discovery.
*
* This is safe-guard and should actually never trigger.
*/
if (!btd_adapter_get_powered(adapter))
return;
adapter->discovery_idle_timeout = timeout_add_seconds(delay,
start_discovery_timeout, adapter, NULL);
}
| 0
|
379,217
|
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
zval *result = &EX_T(opline->result.u.var).tmp_var;
compare_function(result,
&opline->op1.u.constant,
&opline->op2.u.constant TSRMLS_CC);
ZVAL_BOOL(result, (Z_LVAL_P(result) != 0));
ZEND_VM_NEXT_OPCODE();
}
| 0
|
363,852
|
if(currRefCount == 0)
{
/* DEV Debugging Only! dbgprintf("msgDestruct\t0x%lx, RefCount now 0, doing DESTROY\n", (unsigned long)pThis); */
if(pThis->pszRawMsg != pThis->szRawMsg)
free(pThis->pszRawMsg);
freeTAG(pThis);
freeHOSTNAME(pThis);
if(pThis->pInputName != NULL)
prop.Destruct(&pThis->pInputName);
if((pThis->msgFlags & NEEDS_DNSRESOL) == 0) {
if(pThis->rcvFrom.pRcvFrom != NULL)
prop.Destruct(&pThis->rcvFrom.pRcvFrom);
} else {
free(pThis->rcvFrom.pfrominet);
}
if(pThis->pRcvFromIP != NULL)
prop.Destruct(&pThis->pRcvFromIP);
free(pThis->pszRcvdAt3164);
free(pThis->pszRcvdAt3339);
free(pThis->pszRcvdAt_MySQL);
free(pThis->pszRcvdAt_PgSQL);
free(pThis->pszTIMESTAMP_MySQL);
free(pThis->pszTIMESTAMP_PgSQL);
if(pThis->pCSProgName != NULL)
rsCStrDestruct(&pThis->pCSProgName);
if(pThis->pCSStrucData != NULL)
rsCStrDestruct(&pThis->pCSStrucData);
if(pThis->pCSAPPNAME != NULL)
rsCStrDestruct(&pThis->pCSAPPNAME);
if(pThis->pCSPROCID != NULL)
rsCStrDestruct(&pThis->pCSPROCID);
if(pThis->pCSMSGID != NULL)
rsCStrDestruct(&pThis->pCSMSGID);
# ifndef HAVE_ATOMIC_BUILTINS
MsgUnlock(pThis);
# endif
funcDeleteMutex(pThis);
/* now we need to do our own optimization. Testing has shown that at least the glibc
* malloc() subsystem returns memory to the OS far too late in our case. So we need
* to help it a bit, by calling malloc_trim(), which will tell the alloc subsystem
* to consolidate and return to the OS. We keep 128K for our use, as a safeguard
* to too-frequent reallocs. But more importantly, we call this hook only every
* 100,000 messages (which is an approximation, as we do not work with atomic
* operations on the counter. --- rgerhards, 2009-06-22.
*/
# if HAVE_MALLOC_TRIM
{ /* standard C requires a new block for a new variable definition!
* To simplify matters, we use modulo arithmetic and live with the fact
* that we trim too often when the counter wraps.
*/
static unsigned iTrimCtr = 1;
currCnt = ATOMIC_INC_AND_FETCH_unsigned(&iTrimCtr, &mutTrimCtr);
if(currCnt % 100000 == 0) {
malloc_trim(128*1024);
}
}
# endif
} else {
| 0
|
271,294
|
qboolean FS_CreatePath (char *OSPath) {
char *ofs;
char path[MAX_OSPATH];
// make absolutely sure that it can't back up the path
// FIXME: is c: allowed???
if ( strstr( OSPath, ".." ) || strstr( OSPath, "::" ) ) {
Com_Printf( "WARNING: refusing to create relative path \"%s\"\n", OSPath );
return qtrue;
}
Q_strncpyz( path, OSPath, sizeof( path ) );
FS_ReplaceSeparators( path );
// Skip creation of the root directory as it will always be there
ofs = strchr( path, PATH_SEP );
if ( ofs != NULL ) {
ofs++;
}
for (; ofs != NULL && *ofs ; ofs++) {
if (*ofs == PATH_SEP) {
// create the directory
*ofs = 0;
if (!Sys_Mkdir (path)) {
Com_Error( ERR_FATAL, "FS_CreatePath: failed to create path \"%s\"",
path );
}
*ofs = PATH_SEP;
}
}
return qfalse;
}
| 0
|
47,730
|
GF_Err gf_isom_freeze_order(GF_ISOFile *file)
{
u32 i=0;
GF_Box *box;
if (!file) return GF_BAD_PARAM;
while ((box=gf_list_enum(file->TopBoxes, &i))) {
gf_isom_box_freeze_order(box);
}
return GF_OK;
}
| 0
|
497,911
|
static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
int ret;
if (c->fc->nb_streams < 1)
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30))
return AVERROR_INVALIDDATA;
if (st->codecpar->codec_id == AV_CODEC_ID_QDM2 ||
st->codecpar->codec_id == AV_CODEC_ID_QDMC ||
st->codecpar->codec_id == AV_CODEC_ID_SPEEX) {
// pass all frma atom to codec, needed at least for QDMC and QDM2
ret = ff_get_extradata(c->fc, st->codecpar, pb, atom.size);
if (ret < 0)
return ret;
} else if (atom.size > 8) { /* to read frma, esds atoms */
if (st->codecpar->codec_id == AV_CODEC_ID_ALAC && atom.size >= 24) {
uint64_t buffer;
ret = ffio_ensure_seekback(pb, 8);
if (ret < 0)
return ret;
buffer = avio_rb64(pb);
atom.size -= 8;
if ( (buffer & 0xFFFFFFFF) == MKBETAG('f','r','m','a')
&& buffer >> 32 <= atom.size
&& buffer >> 32 >= 8) {
avio_skip(pb, -8);
atom.size += 8;
} else if (!st->codecpar->extradata_size) {
#define ALAC_EXTRADATA_SIZE 36
st->codecpar->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + AV_INPUT_BUFFER_PADDING_SIZE);
if (!st->codecpar->extradata)
return AVERROR(ENOMEM);
st->codecpar->extradata_size = ALAC_EXTRADATA_SIZE;
AV_WB32(st->codecpar->extradata , ALAC_EXTRADATA_SIZE);
AV_WB32(st->codecpar->extradata + 4, MKTAG('a','l','a','c'));
AV_WB64(st->codecpar->extradata + 12, buffer);
avio_read(pb, st->codecpar->extradata + 20, 16);
avio_skip(pb, atom.size - 24);
return 0;
}
}
if ((ret = mov_read_default(c, pb, atom)) < 0)
return ret;
} else
avio_skip(pb, atom.size);
return 0;
}
| 0
|
255,223
|
int MirrorJob::Do()
{
int res;
int m=STALL;
FileInfo *file;
Job *j;
switch(state)
{
case(INITIAL_STATE):
remove_this_source_dir=(remove_source_dirs && source_dir.last_char()!='/');
if(!strcmp(target_dir,".") || !strcmp(target_dir,"..") || (FlagSet(SCAN_ALL_FIRST) && parent_mirror))
create_target_dir=false;
source_session->Chdir(source_dir);
source_redirections=0;
source_session->Roll();
set_state(CHANGING_DIR_SOURCE);
m=MOVED;
/*fallthrough*/
case(CHANGING_DIR_SOURCE):
HandleChdir(source_session,source_redirections);
if(state!=CHANGING_DIR_SOURCE)
return MOVED;
if(source_session->IsOpen())
return m;
source_dir.set(source_session->GetCwd().GetDirectory());
pre_MAKE_TARGET_DIR:
{
if(!create_target_dir)
goto pre_CHANGING_DIR_TARGET;
if(target_is_local)
{
struct stat st;
if((FlagSet(RETR_SYMLINKS)?stat:lstat)(target_dir,&st)!=-1)
{
if(S_ISDIR(st.st_mode))
{
// try to enable write access
// only if not enabled as chmod can clear sgid flags on directories
if(!script_only && (st.st_mode!=(st.st_mode|0700)))
chmod(target_dir,st.st_mode|0700);
create_target_dir=false;
goto pre_CHANGING_DIR_TARGET;
}
else
{
Report(_("Removing old local file `%s'"),target_dir.get());
if(script)
{
ArgV args("rm");
args.Append(target_session->GetFileURL(target_dir));
xstring_ca cmd(args.CombineQuoted());
fprintf(script,"%s\n",cmd.get());
}
if(!script_only)
{
if(remove(target_dir)==-1)
eprintf("mirror: remove(%s): %s\n",target_dir.get(),strerror(errno));
}
}
}
}
if(FlagSet(DEPTH_FIRST))
goto pre_GETTING_LIST_INFO;
if(target_relative_dir)
Report(_("Making directory `%s'"),target_relative_dir.get());
bool mkdir_p=(parent_mirror==0 || parent_mirror->create_target_dir);
if(script)
{
ArgV args("mkdir");
if(mkdir_p)
args.Append("-p");
args.Append(target_session->GetFileURL(target_dir));
xstring_ca cmd(args.CombineQuoted());
fprintf(script,"%s\n",cmd.get());
if(script_only)
goto pre_CHANGING_DIR_TARGET;
}
target_session->Mkdir(target_dir,mkdir_p);
set_state(MAKE_TARGET_DIR);
m=MOVED;
}
/*fallthrough*/
case(MAKE_TARGET_DIR):
res=target_session->Done();
if(res==FA::IN_PROGRESS)
return m;
target_session->Close();
create_target_dir=false;
pre_CHANGING_DIR_TARGET:
target_session->Chdir(target_dir);
target_redirections=0;
target_session->Roll();
set_state(CHANGING_DIR_TARGET);
m=MOVED;
/*fallthrough*/
case(CHANGING_DIR_TARGET):
HandleChdir(target_session,target_redirections);
if(state!=CHANGING_DIR_TARGET)
return MOVED;
if(target_session->IsOpen())
return m;
create_target_dir=false;
target_dir.set(target_session->GetCwd().GetDirectory());
pre_GETTING_LIST_INFO:
set_state(GETTING_LIST_INFO);
m=MOVED;
if(!source_set)
HandleListInfoCreation(source_session,source_list_info,source_relative_dir);
if(!target_set && !create_target_dir
&& (!FlagSet(DEPTH_FIRST) || FlagSet(ONLY_EXISTING))
&& !(FlagSet(TARGET_FLAT) && parent_mirror))
HandleListInfoCreation(target_session,target_list_info,target_relative_dir);
if(state!=GETTING_LIST_INFO)
{
source_list_info=0;
target_list_info=0;
}
return m; // give time to other tasks
case(GETTING_LIST_INFO):
HandleListInfo(source_list_info,source_set);
HandleListInfo(target_list_info,target_set,&target_set_excluded);
if(state!=GETTING_LIST_INFO)
return MOVED;
if(source_list_info || target_list_info)
return m;
MirrorFinished(); // leave room for transfers.
if(FlagSet(DEPTH_FIRST) && source_set && !target_set)
{
// transfer directories first
InitSets();
to_transfer->Unsort();
to_transfer->SubtractNotDirs();
goto pre_WAITING_FOR_TRANSFER;
}
// now we have both target and source file sets.
if(parent_mirror)
stats.dirs++;
if(FlagSet(SCAN_ALL_FIRST) && parent_mirror)
{
source_set->PrependPath(source_relative_dir);
if(root_mirror->source_set_recursive)
root_mirror->source_set_recursive->Merge(source_set);
else
root_mirror->source_set_recursive=source_set.borrow();
if(target_set) {
target_set->PrependPath(target_relative_dir);
if(root_mirror->target_set_recursive)
root_mirror->target_set_recursive->Merge(target_set);
else
root_mirror->target_set_recursive=target_set.borrow();
}
if(target_set_excluded) {
target_set_excluded->PrependPath(target_relative_dir);
if(root_mirror->target_set_excluded)
root_mirror->target_set_excluded->Merge(target_set_excluded);
else
root_mirror->target_set_excluded=target_set_excluded.borrow();
}
root_mirror->stats.dirs++;
transfer_count++; // parent mirror will decrement it.
goto pre_DONE;
}
if(source_set_recursive) {
source_set->Merge(source_set_recursive);
source_set_recursive=0;
}
if(target_set_recursive) {
target_set->Merge(target_set_recursive);
target_set_recursive=0;
}
InitSets();
to_transfer->CountBytes(&bytes_to_transfer);
if(parent_mirror)
parent_mirror->AddBytesToTransfer(bytes_to_transfer);
to_rm->Count(&stats.del_dirs,&stats.del_files,&stats.del_symlinks,&stats.del_files);
to_rm->rewind();
to_rm_mismatched->Count(&stats.del_dirs,&stats.del_files,&stats.del_symlinks,&stats.del_files);
to_rm_mismatched->rewind();
target_set->Merge(target_set_excluded);
target_set_excluded=0;
set_state(TARGET_REMOVE_OLD_FIRST);
goto TARGET_REMOVE_OLD_FIRST_label;
pre_TARGET_MKDIR:
if(!to_mkdir)
goto pre_WAITING_FOR_TRANSFER;
to_mkdir->rewind();
set_state(TARGET_MKDIR);
m=MOVED;
/*fallthrough*/
case(TARGET_MKDIR):
while((j=FindDoneAwaitedJob())!=0)
{
JobFinished(j);
m=MOVED;
}
if(max_error_count>0 && stats.error_count>=max_error_count)
goto pre_FINISHING;
while(transfer_count<parallel && state==TARGET_MKDIR)
{
file=to_mkdir->curr();
if(!file)
goto pre_WAITING_FOR_TRANSFER;
to_mkdir->next();
if(!file->TypeIs(file->DIRECTORY))
continue;
if(script)
fprintf(script,"mkdir %s\n",target_session->GetFileURL(file->name).get());
if(!script_only)
{
ArgV *a=new ArgV("mkdir");
a->Append(file->name);
mkdirJob *mkj=new mkdirJob(target_session->Clone(),a);
a->CombineTo(mkj->cmdline);
JobStarted(mkj);
m=MOVED;
}
}
break;
pre_WAITING_FOR_TRANSFER:
to_transfer->rewind();
set_state(WAITING_FOR_TRANSFER);
m=MOVED;
/*fallthrough*/
case(WAITING_FOR_TRANSFER):
while((j=FindDoneAwaitedJob())!=0)
{
TransferFinished(j);
m=MOVED;
}
if(max_error_count>0 && stats.error_count>=max_error_count)
goto pre_FINISHING;
while(transfer_count<parallel && state==WAITING_FOR_TRANSFER)
{
file=to_transfer->curr();
if(!file)
{
// go to the next step only when all transfers have finished
if(waiting_num>0)
break;
if(FlagSet(DEPTH_FIRST))
{
// we have been in the depth, don't go there again
SetFlags(DEPTH_FIRST,false);
SetFlags(NO_RECURSION,true);
// if we have not created any subdirs and there are only subdirs,
// then the directory would be empty - skip it.
if(FlagSet(NO_EMPTY_DIRS) && stats.dirs==0 && only_dirs)
goto pre_FINISHING_FIX_LOCAL;
MirrorStarted();
goto pre_MAKE_TARGET_DIR;
}
goto pre_TARGET_REMOVE_OLD;
}
HandleFile(file);
to_transfer->next();
m=MOVED;
}
break;
pre_TARGET_REMOVE_OLD:
if(FlagSet(REMOVE_FIRST))
goto pre_TARGET_CHMOD;
set_state(TARGET_REMOVE_OLD);
m=MOVED;
/*fallthrough*/
case(TARGET_REMOVE_OLD):
case(TARGET_REMOVE_OLD_FIRST):
TARGET_REMOVE_OLD_FIRST_label:
while((j=FindDoneAwaitedJob())!=0)
{
JobFinished(j);
m=MOVED;
}
if(max_error_count>0 && stats.error_count>=max_error_count)
goto pre_FINISHING;
while(transfer_count<parallel && (state==TARGET_REMOVE_OLD || state==TARGET_REMOVE_OLD_FIRST))
{
file=0;
if(!file && state==TARGET_REMOVE_OLD_FIRST)
{
file=to_rm_mismatched->curr();
to_rm_mismatched->next();
}
if(!file && (state==TARGET_REMOVE_OLD || FlagSet(REMOVE_FIRST)))
{
file=to_rm->curr();
to_rm->next();
}
if(!file)
{
if(waiting_num>0)
break;
if(state==TARGET_REMOVE_OLD)
goto pre_TARGET_CHMOD;
goto pre_TARGET_MKDIR;
}
if(!FlagSet(DELETE))
{
if(FlagSet(REPORT_NOT_DELETED))
{
const char *target_name_rel=dir_file(target_relative_dir,file->name);
if(file->TypeIs(file->DIRECTORY))
Report(_("Old directory `%s' is not removed"),target_name_rel);
else
Report(_("Old file `%s' is not removed"),target_name_rel);
}
continue;
}
if(script)
{
ArgV args("rm");
if(file->TypeIs(file->DIRECTORY))
{
if(recursion_mode==RECURSION_NEVER)
args.setarg(0,"rmdir");
else
args.Append("-r");
}
args.Append(target_session->GetFileURL(file->name));
xstring_ca cmd(args.CombineQuoted());
fprintf(script,"%s\n",cmd.get());
}
if(!script_only)
{
ArgV *args=new ArgV("rm");
args->Append(file->name);
args->seek(1);
rmJob *j=new rmJob(target_session->Clone(),args);
args->CombineTo(j->cmdline);
JobStarted(j);
if(file->TypeIs(file->DIRECTORY))
{
if(recursion_mode==RECURSION_NEVER)
{
args->setarg(0,"rmdir");
j->Rmdir();
}
else
j->Recurse();
}
}
const char *target_name_rel=dir_file(target_relative_dir,file->name);
if(file->TypeIs(file->DIRECTORY))
Report(_("Removing old directory `%s'"),target_name_rel);
else
Report(_("Removing old file `%s'"),target_name_rel);
}
break;
pre_TARGET_CHMOD:
if(FlagSet(NO_PERMS))
goto pre_FINISHING_FIX_LOCAL;
to_transfer->rewind();
if(FlagSet(TARGET_FLAT))
to_transfer->Sort(FileSet::BYNAME_FLAT);
set_state(TARGET_CHMOD);
m=MOVED;
/*fallthrough*/
case(TARGET_CHMOD):
while((j=FindDoneAwaitedJob())!=0)
{
JobFinished(j);
m=MOVED;
}
if(max_error_count>0 && stats.error_count>=max_error_count)
goto pre_FINISHING;
while(transfer_count<parallel && state==TARGET_CHMOD)
{
file=to_transfer->curr();
if(!file)
goto pre_FINISHING_FIX_LOCAL;
to_transfer->next();
if(file->TypeIs(file->SYMLINK))
continue;
if(!file->Has(file->MODE))
continue;
mode_t mode_mask=get_mode_mask();
mode_t def_mode=(file->TypeIs(file->DIRECTORY)?0775:0664)&~mode_mask;
if(target_is_local && file->mode==def_mode)
{
struct stat st;
if(!target_is_local || lstat(dir_file(target_dir,file->name),&st)==-1)
continue;
if((st.st_mode&07777)==(file->mode&~mode_mask))
continue;
}
FileInfo *target=target_set->FindByName(file->name);
if(target && target->filetype==file->DIRECTORY && file->filetype==file->DIRECTORY
&& target->mode==(file->mode&~mode_mask) && (target->mode&0200))
continue;
if(script)
{
ArgV args("chmod");
args.Append(xstring::format("%03lo",(unsigned long)(file->mode&~mode_mask)));
args.Append(target_session->GetFileURL(file->name));
xstring_ca cmd(args.CombineQuoted());
fprintf(script,"%s\n",cmd.get());
}
if(!script_only)
{
ArgV *a=new ArgV("chmod");
a->Append(file->name);
a->seek(1);
ChmodJob *cj=new ChmodJob(target_session->Clone(),
file->mode&~mode_mask,a);
a->CombineTo(cj->cmdline);
if(!verbose_report)
cj->BeQuiet(); // chmod is not supported on all servers; be quiet.
JobStarted(cj);
m=MOVED;
}
}
break;
pre_FINISHING_FIX_LOCAL:
if(target_is_local && !script_only) // FIXME
{
const bool flat=FlagSet(TARGET_FLAT);
to_transfer->Sort(FileSet::BYNAME_FLAT);
to_transfer->LocalUtime(target_dir,/*only_dirs=*/true,flat);
if(FlagSet(ALLOW_CHOWN))
to_transfer->LocalChown(target_dir,flat);
if(!FlagSet(NO_PERMS) && same)
same->LocalChmod(target_dir,get_mode_mask(),flat);
if(FlagSet(ALLOW_CHOWN) && same)
same->LocalChown(target_dir,flat);
}
if(remove_source_files && (same || to_rm_src))
goto pre_SOURCE_REMOVING_SAME;
pre_FINISHING:
set_state(FINISHING);
m=MOVED;
/*fallthrough*/
case(FINISHING):
while((j=FindDoneAwaitedJob())!=0)
{
JobFinished(j);
m=MOVED;
}
if(waiting_num>0)
break;
// all jobs finished.
if(remove_this_source_dir) {
// remove source directory once.
remove_this_source_dir=false;
if(script)
{
ArgV args("rmdir");
args.Append(source_session->GetFileURL(source_dir));
xstring_ca cmd(args.CombineQuoted());
fprintf(script,"%s\n",cmd.get());
}
if(!script_only)
{
ArgV *args=new ArgV("rmdir");
args->Append(source_dir);
args->seek(1);
rmJob *j=new rmJob(source_session->Clone(),args);
args->CombineTo(j->cmdline);
j->Rmdir();
JobStarted(j);
}
if(source_relative_dir)
Report(_("Removing source directory `%s'"),source_relative_dir.get());
m=MOVED;
break;
}
// all jobs finished and src dir removed, if needed.
transfer_count++; // parent mirror will decrement it.
if(parent_mirror)
parent_mirror->stats.Add(stats);
else
{
if(stats.HaveSomethingDone(flags) && on_change)
{
CmdExec *exec=new CmdExec(source_session->Clone(),0);
AddWaiting(exec);
exec->FeedCmd(on_change);
exec->FeedCmd("\n");
set_state(LAST_EXEC);
break;
}
}
goto pre_DONE;
pre_SOURCE_REMOVING_SAME:
if(!same)
same=to_rm_src.borrow();
else if(to_rm_src)
same->Merge(to_rm_src);
same->rewind();
set_state(SOURCE_REMOVING_SAME);
m=MOVED;
/*fallthrough*/
case(SOURCE_REMOVING_SAME):
while((j=FindDoneAwaitedJob())!=0)
{
JobFinished(j);
m=MOVED;
}
if(max_error_count>0 && stats.error_count>=max_error_count)
goto pre_FINISHING;
while(transfer_count<parallel && state==SOURCE_REMOVING_SAME)
{
file=same->curr();
same->next();
if(!file)
goto pre_FINISHING;
if(file->TypeIs(file->DIRECTORY))
continue;
if(script)
{
ArgV args("rm");
args.Append(source_session->GetFileURL(file->name));
xstring_ca cmd(args.CombineQuoted());
fprintf(script,"%s\n",cmd.get());
}
if(!script_only)
{
ArgV *args=new ArgV("rm");
args->Append(file->name);
args->seek(1);
rmJob *j=new rmJob(source_session->Clone(),args);
args->CombineTo(j->cmdline);
JobStarted(j);
}
const char *source_name_rel=dir_file(source_relative_dir,file->name);
Report(_("Removing source file `%s'"),source_name_rel);
}
break;
case(LAST_EXEC):
while((j=FindDoneAwaitedJob())!=0)
{
RemoveWaiting(j);
Delete(j);
m=MOVED;
}
if(waiting_num>0)
break;
pre_DONE:
set_state(DONE);
m=MOVED;
bytes_transferred=0;
if(!parent_mirror && FlagSet(LOOP) && stats.HaveSomethingDone(flags) && !stats.error_count)
{
PrintStatus(0,"");
printf(_("Retrying mirror...\n"));
stats.Reset();
source_set=0;
target_set=0;
goto pre_GETTING_LIST_INFO;
}
/*fallthrough*/
case(DONE):
break;
}
// give direct parent priority over grand-parents.
if(transfer_count<parallel && parent_mirror)
m|=parent_mirror->Roll();
return m;
}
| 1
|
339,514
|
static int udp_close(URLContext *h)
{
UDPContext *s = h->priv_data;
int ret;
if (s->is_multicast && (h->flags & AVIO_FLAG_READ))
udp_leave_multicast_group(s->udp_fd, (struct sockaddr *)&s->dest_addr);
closesocket(s->udp_fd);
av_fifo_free(s->fifo);
#if HAVE_PTHREADS
if (s->thread_started) {
pthread_cancel(s->circular_buffer_thread);
ret = pthread_join(s->circular_buffer_thread, NULL);
if (ret != 0)
av_log(h, AV_LOG_ERROR, "pthread_join(): %s\n", strerror(ret));
}
pthread_mutex_destroy(&s->mutex);
pthread_cond_destroy(&s->cond);
#endif
return 0;
}
| 0
|
323,856
|
static int ram_save_iterate(QEMUFile *f, void *opaque)
{
int ret;
int i;
int64_t t0;
int total_sent = 0;
qemu_mutex_lock_ramlist();
if (ram_list.version != last_version) {
reset_ram_globals();
}
ram_control_before_iterate(f, RAM_CONTROL_ROUND);
t0 = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
i = 0;
while ((ret = qemu_file_rate_limit(f)) == 0) {
int bytes_sent;
bytes_sent = ram_save_block(f, false);
/* no more blocks to sent */
if (bytes_sent == 0) {
break;
}
total_sent += bytes_sent;
acct_info.iterations++;
check_guest_throttling();
/* we want to check in the 1st loop, just in case it was the 1st time
and we had to sync the dirty bitmap.
qemu_get_clock_ns() is a bit expensive, so we only check each some
iterations
*/
if ((i & 63) == 0) {
uint64_t t1 = (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - t0) / 1000000;
if (t1 > MAX_WAIT) {
DPRINTF("big wait: %" PRIu64 " milliseconds, %d iterations\n",
t1, i);
break;
}
}
i++;
}
qemu_mutex_unlock_ramlist();
/*
* Must occur before EOS (or any QEMUFile operation)
* because of RDMA protocol.
*/
ram_control_after_iterate(f, RAM_CONTROL_ROUND);
if (ret < 0) {
bytes_transferred += total_sent;
return ret;
}
qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
total_sent += 8;
bytes_transferred += total_sent;
return total_sent;
}
| 0
|
354,875
|
static int dccp_close_state(struct sock *sk)
{
const int next = dccp_new_state[sk->sk_state];
const int ns = next & DCCP_STATE_MASK;
if (ns != sk->sk_state)
dccp_set_state(sk, ns);
return next & DCCP_ACTION_FIN;
}
| 0
|
394,849
|
static int php_zip_ops_flush(php_stream *stream TSRMLS_DC)
{
if (!stream) {
return 0;
}
return 0;
}
| 0
|
290,839
|
bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr)
{
return false;
}
| 0
|
17,438
|
gpg_error_t keydb_search ( KEYDB_HANDLE hd , KEYDB_SEARCH_DESC * desc , size_t ndesc , size_t * descindex ) {
gpg_error_t rc ;
if ( descindex ) * descindex = 0 ;
if ( ! hd ) return gpg_error ( GPG_ERR_INV_ARG ) ;
if ( DBG_CLOCK ) log_clock ( "keydb_search enter" ) ;
if ( DBG_CACHE ) dump_search_desc ( hd , "keydb_search" , desc , ndesc ) ;
if ( ! hd -> no_caching && ndesc == 1 && ( desc [ 0 ] . mode == KEYDB_SEARCH_MODE_FPR20 || desc [ 0 ] . mode == KEYDB_SEARCH_MODE_FPR ) && keyblock_cache . state == KEYBLOCK_CACHE_FILLED && ! memcmp ( keyblock_cache . fpr , desc [ 0 ] . u . fpr , 20 ) ) {
if ( DBG_CLOCK ) log_clock ( "keydb_search leave (cached)" ) ;
return 0 ;
}
rc = - 1 ;
while ( ( rc == - 1 || gpg_err_code ( rc ) == GPG_ERR_EOF ) && hd -> current >= 0 && hd -> current < hd -> used ) {
switch ( hd -> active [ hd -> current ] . type ) {
case KEYDB_RESOURCE_TYPE_NONE : BUG ( ) ;
break ;
case KEYDB_RESOURCE_TYPE_KEYRING : rc = keyring_search ( hd -> active [ hd -> current ] . u . kr , desc , ndesc , descindex ) ;
break ;
case KEYDB_RESOURCE_TYPE_KEYBOX : rc = keybox_search ( hd -> active [ hd -> current ] . u . kb , desc , ndesc , KEYBOX_BLOBTYPE_PGP , descindex , & hd -> skipped_long_blobs ) ;
break ;
}
if ( rc == - 1 || gpg_err_code ( rc ) == GPG_ERR_EOF ) {
hd -> current ++ ;
}
else if ( ! rc ) hd -> found = hd -> current ;
}
rc = ( ( rc == - 1 || gpg_err_code ( rc ) == GPG_ERR_EOF ) ? gpg_error ( GPG_ERR_NOT_FOUND ) : rc ) ;
keyblock_cache_clear ( ) ;
if ( ! hd -> no_caching && ! rc && ndesc == 1 && ( desc [ 0 ] . mode == KEYDB_SEARCH_MODE_FPR20 || desc [ 0 ] . mode == KEYDB_SEARCH_MODE_FPR ) ) {
keyblock_cache . state = KEYBLOCK_CACHE_PREPARED ;
memcpy ( keyblock_cache . fpr , desc [ 0 ] . u . fpr , 20 ) ;
}
if ( DBG_CLOCK ) log_clock ( rc ? "keydb_search leave (not found)" : "keydb_search leave (found)" ) ;
return rc ;
}
| 0
|
66,867
|
int sfgets(void)
{
struct pollfd pfd;
int pollret;
ssize_t readnb;
signed char seen_r = 0;
if (scanned > (size_t) 0U) { /* support pipelining */
readnbd -= scanned;
memmove(cmd, cmd + scanned, readnbd); /* safe */
scanned = (size_t) 0U;
}
pfd.fd = clientfd;
#ifdef __APPLE_CC__
pfd.events = POLLIN | POLLERR | POLLHUP;
#else
pfd.events = POLLIN | POLLPRI | POLLERR | POLLHUP;
#endif
while (scanned < cmdsize) {
if (scanned >= readnbd) { /* nothing left in the buffer */
pfd.revents = 0;
while ((pollret = poll(&pfd, 1U, idletime * 1000UL)) < 0 &&
errno == EINTR);
if (pollret == 0) {
return -1;
}
if (pollret <= 0 ||
(pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) != 0) {
return -2;
}
if ((pfd.revents & (POLLIN | POLLPRI)) == 0) {
continue;
}
if (readnbd >= cmdsize) {
break;
}
#ifdef WITH_TLS
if (tls_cnx != NULL) {
while ((readnb = SSL_read
(tls_cnx, cmd + readnbd, cmdsize - readnbd))
< (ssize_t) 0 && errno == EINTR);
} else
#endif
{
while ((readnb = read(clientfd, cmd + readnbd,
cmdsize - readnbd)) < (ssize_t) 0 &&
errno == EINTR);
}
if (readnb <= (ssize_t) 0) {
return -2;
}
readnbd += readnb;
if (readnbd > cmdsize) {
return -2;
}
}
#ifdef RFC_CONFORMANT_LINES
if (seen_r != 0) {
#endif
if (cmd[scanned] == '\n') {
#ifndef RFC_CONFORMANT_LINES
if (seen_r != 0) {
#endif
cmd[scanned - 1U] = 0;
#ifndef RFC_CONFORMANT_LINES
} else {
cmd[scanned] = 0;
}
#endif
if (++scanned >= readnbd) { /* non-pipelined command */
scanned = readnbd = (size_t) 0U;
}
return 0;
}
seen_r = 0;
#ifdef RFC_CONFORMANT_LINES
}
#endif
if (ISCTRLCODE(cmd[scanned])) {
if (cmd[scanned] == '\r') {
seen_r = 1;
}
#ifdef RFC_CONFORMANT_PARSER /* disabled by default, intentionnaly */
else if (cmd[scanned] == 0) {
cmd[scanned] = '\n';
}
#else
/* replace control chars with _ */
cmd[scanned] = '_';
#endif
}
scanned++;
}
die(421, LOG_WARNING, MSG_LINE_TOO_LONG); /* don't remove this */
return 0; /* to please GCC */
}
| 0
|
520,464
|
my_decimal *val_decimal(my_decimal *to)
{
return has_value() ? Date(this).to_decimal(to) : NULL;
}
| 0
|
379,033
|
*/
PHPAPI char *php_get_uname(char mode)
{
char *php_uname;
char tmp_uname[256];
#ifdef PHP_WIN32
DWORD dwBuild=0;
DWORD dwVersion = GetVersion();
DWORD dwWindowsMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
DWORD dwWindowsMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
char ComputerName[MAX_COMPUTERNAME_LENGTH + 1];
GetComputerName(ComputerName, &dwSize);
if (mode == 's') {
php_uname = "Windows NT";
} else if (mode == 'r') {
snprintf(tmp_uname, sizeof(tmp_uname), "%d.%d", dwWindowsMajorVersion, dwWindowsMinorVersion);
php_uname = tmp_uname;
} else if (mode == 'n') {
php_uname = ComputerName;
} else if (mode == 'v') {
char *winver = php_get_windows_name();
dwBuild = (DWORD)(HIWORD(dwVersion));
if(winver == NULL) {
snprintf(tmp_uname, sizeof(tmp_uname), "build %d", dwBuild);
} else {
snprintf(tmp_uname, sizeof(tmp_uname), "build %d (%s)", dwBuild, winver);
}
php_uname = tmp_uname;
if(winver) {
efree(winver);
}
} else if (mode == 'm') {
php_get_windows_cpu(tmp_uname, sizeof(tmp_uname));
php_uname = tmp_uname;
} else { /* assume mode == 'a' */
char *winver = php_get_windows_name();
char wincpu[20];
php_get_windows_cpu(wincpu, sizeof(wincpu));
dwBuild = (DWORD)(HIWORD(dwVersion));
snprintf(tmp_uname, sizeof(tmp_uname), "%s %s %d.%d build %d (%s) %s",
"Windows NT", ComputerName,
dwWindowsMajorVersion, dwWindowsMinorVersion, dwBuild, winver?winver:"unknown", wincpu);
if(winver) {
efree(winver);
}
php_uname = tmp_uname;
}
#else
#ifdef HAVE_SYS_UTSNAME_H
struct utsname buf;
if (uname((struct utsname *)&buf) == -1) {
php_uname = PHP_UNAME;
} else {
#ifdef NETWARE
if (mode == 's') {
php_uname = buf.sysname;
} else if (mode == 'r') {
snprintf(tmp_uname, sizeof(tmp_uname), "%d.%d.%d",
buf.netware_major, buf.netware_minor, buf.netware_revision);
php_uname = tmp_uname;
} else if (mode == 'n') {
php_uname = buf.servername;
} else if (mode == 'v') {
snprintf(tmp_uname, sizeof(tmp_uname), "libc-%d.%d.%d #%d",
buf.libmajor, buf.libminor, buf.librevision, buf.libthreshold);
php_uname = tmp_uname;
} else if (mode == 'm') {
php_uname = buf.machine;
} else { /* assume mode == 'a' */
snprintf(tmp_uname, sizeof(tmp_uname), "%s %s %d.%d.%d libc-%d.%d.%d #%d %s",
buf.sysname, buf.servername,
buf.netware_major, buf.netware_minor, buf.netware_revision,
buf.libmajor, buf.libminor, buf.librevision, buf.libthreshold,
buf.machine);
php_uname = tmp_uname;
}
#else
if (mode == 's') {
php_uname = buf.sysname;
} else if (mode == 'r') {
php_uname = buf.release;
} else if (mode == 'n') {
php_uname = buf.nodename;
} else if (mode == 'v') {
php_uname = buf.version;
} else if (mode == 'm') {
php_uname = buf.machine;
} else { /* assume mode == 'a' */
snprintf(tmp_uname, sizeof(tmp_uname), "%s %s %s %s %s",
buf.sysname, buf.nodename, buf.release, buf.version,
buf.machine);
php_uname = tmp_uname;
}
#endif /* NETWARE */
}
#else
php_uname = PHP_UNAME;
#endif
#endif
return estrdup(php_uname);
| 0
|
253,803
|
PHP_FUNCTION(pg_result_seek)
{
zval *result;
long row;
pgsql_result_handle *pg_result;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &result, &row) == FAILURE) {
return;
}
ZEND_FETCH_RESOURCE(pg_result, pgsql_result_handle *, &result, -1, "PostgreSQL result", le_result);
if (row < 0 || row >= PQntuples(pg_result->result)) {
RETURN_FALSE;
}
/* seek to offset */
pg_result->row = row;
RETURN_TRUE;
}
| 0
|
320,127
|
static av_cold int yop_decode_init(AVCodecContext *avctx)
{
YopDecContext *s = avctx->priv_data;
s->avctx = avctx;
if (avctx->width & 1 || avctx->height & 1 ||
av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0) {
av_log(avctx, AV_LOG_ERROR, "YOP has invalid dimensions\n");
return -1;
avctx->pix_fmt = PIX_FMT_PAL8;
avcodec_get_frame_defaults(&s->frame);
s->num_pal_colors = avctx->extradata[0];
s->first_color[0] = avctx->extradata[1];
s->first_color[1] = avctx->extradata[2];
if (s->num_pal_colors + s->first_color[0] > 256 ||
s->num_pal_colors + s->first_color[1] > 256) {
av_log(avctx, AV_LOG_ERROR,
"YOP: palette parameters invalid, header probably corrupt\n");
return 0;
| 1
|
363,029
|
int sel_fontn(DviContext *dvi, int opcode)
{
Int32 arg;
DviFontRef *ref;
arg = dugetn(dvi, opcode - DVI_FNT1 + 1);
if(dvi->depth)
ref = font_find_flat(dvi, arg);
else
ref = dvi->findref(dvi, arg);
if(ref == NULL) {
dvierr(dvi, _("font %d is not defined\n"), arg);
return -1;
}
SHOWCMD((dvi, "fnt", opcode - DVI_FNT1 + 1,
"current font is %s (id %d)\n",
ref->ref->fontname, arg));
dvi->currfont = ref;
return 0;
}
| 0
|
366,258
|
static int smaps_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
struct mm_walk *walk)
{
struct mem_size_stats *mss = walk->private;
struct vm_area_struct *vma = mss->vma;
pte_t *pte;
spinlock_t *ptl;
spin_lock(&walk->mm->page_table_lock);
if (pmd_trans_huge(*pmd)) {
if (pmd_trans_splitting(*pmd)) {
spin_unlock(&walk->mm->page_table_lock);
wait_split_huge_page(vma->anon_vma, pmd);
} else {
smaps_pte_entry(*(pte_t *)pmd, addr,
HPAGE_PMD_SIZE, walk);
spin_unlock(&walk->mm->page_table_lock);
mss->anonymous_thp += HPAGE_PMD_SIZE;
return 0;
}
} else {
spin_unlock(&walk->mm->page_table_lock);
}
if (pmd_trans_unstable(pmd))
return 0;
/*
* The mmap_sem held all the way back in m_start() is what
* keeps khugepaged out of here and from collapsing things
* in here.
*/
pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
for (; addr != end; pte++, addr += PAGE_SIZE)
smaps_pte_entry(*pte, addr, PAGE_SIZE, walk);
pte_unmap_unlock(pte - 1, ptl);
cond_resched();
return 0;
}
| 0
|
144,526
|
void mips_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
int flags)
{
MIPSCPU *cpu = MIPS_CPU(cs);
CPUMIPSState *env = &cpu->env;
int i;
cpu_fprintf(f, "pc=0x" TARGET_FMT_lx " HI=0x" TARGET_FMT_lx
" LO=0x" TARGET_FMT_lx " ds %04x "
TARGET_FMT_lx " " TARGET_FMT_ld "\n",
env->active_tc.PC, env->active_tc.HI[0], env->active_tc.LO[0],
env->hflags, env->btarget, env->bcond);
for (i = 0; i < 32; i++) {
if ((i & 3) == 0)
cpu_fprintf(f, "GPR%02d:", i);
cpu_fprintf(f, " %s " TARGET_FMT_lx, regnames[i], env->active_tc.gpr[i]);
if ((i & 3) == 3)
cpu_fprintf(f, "\n");
}
cpu_fprintf(f, "CP0 Status 0x%08x Cause 0x%08x EPC 0x" TARGET_FMT_lx "\n",
env->CP0_Status, env->CP0_Cause, env->CP0_EPC);
cpu_fprintf(f, " Config0 0x%08x Config1 0x%08x LLAddr 0x%016"
PRIx64 "\n",
env->CP0_Config0, env->CP0_Config1, env->lladdr);
cpu_fprintf(f, " Config2 0x%08x Config3 0x%08x\n",
env->CP0_Config2, env->CP0_Config3);
cpu_fprintf(f, " Config4 0x%08x Config5 0x%08x\n",
env->CP0_Config4, env->CP0_Config5);
if (env->hflags & MIPS_HFLAG_FPU)
fpu_dump_state(env, f, cpu_fprintf, flags);
#if defined(TARGET_MIPS64) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)
cpu_mips_check_sign_extensions(env, f, cpu_fprintf, flags);
#endif
}
| 1
|
124,631
|
static void tg3_hwmon_close(struct tg3 *tp)
{
if (tp->hwmon_dev) {
hwmon_device_unregister(tp->hwmon_dev);
tp->hwmon_dev = NULL;
sysfs_remove_group(&tp->pdev->dev.kobj, &tg3_group);
}
}
| 0
|
95,145
|
static Jsi_Interp* jsi_InterpNew(Jsi_Interp *parent, Jsi_Value *opts, Jsi_InterpOpts *iopts)
{
Jsi_Interp* interp;
if (parent && parent->noSubInterps) {
interp = parent;
Jsi_LogError("subinterps disallowed");
return NULL;
}
if (opts && parent && (Jsi_ValueIsObjType(parent, opts, JSI_OT_OBJECT)==0 ||
Jsi_TreeSize(opts->d.obj->tree)<=0))
opts = NULL;
interp = (Jsi_Interp *)Jsi_Calloc(1,sizeof(*interp) + sizeof(jsi_Frame));
interp->framePtr = (jsi_Frame*)(((uchar*)interp)+sizeof(*interp));
if (!parent)
interp->maxInterpDepth = JSI_MAX_SUBINTERP_DEPTH;
else {
interp->maxInterpDepth = parent->maxInterpDepth;
interp->interpDepth = parent->interpDepth+1;
if (interp->interpDepth > interp->maxInterpDepth) {
Jsi_Free(interp);
interp = parent;
Jsi_LogError("exceeded max subinterp depth");
return NULL;
}
}
interp->maxDepth = JSI_MAX_EVAL_DEPTH;
interp->maxIncDepth = JSI_MAX_INCLUDE_DEPTH;
interp->maxArrayList = MAX_ARRAY_LIST;
interp->typeWarnMax = 50;
interp->subOpts.dblPrec = __DBL_DECIMAL_DIG__-1;
interp->subOpts.prompt = "$ ";
interp->subOpts.prompt2 = "> ";
int iocnt;
if (iopts) {
iopts->interp = interp;
interp->opts = *iopts;
}
interp->logOpts.file = 1;
interp->logOpts.func = 1;
interp->logOpts.Info = 1;
interp->logOpts.Warn = 1;
interp->logOpts.Error = 1;
int argc = interp->opts.argc;
char **argv = interp->opts.argv;
char *argv0 = (argv?argv[0]:NULL);
interp->parent = parent;
interp->topInterp = (parent == NULL ? interp: parent->topInterp);
if (jsiIntData.mainInterp == NULL)
jsiIntData.mainInterp = interp->topInterp;
interp->mainInterp = jsiIntData.mainInterp; // The first interps handles exit.
interp->memDebug = interp->opts.mem_debug;
if (parent) {
interp->dbPtr = parent->dbPtr;
} else {
interp->dbPtr = &interp->dbStatic;
}
#ifdef JSI_MEM_DEBUG
if (!interp->dbPtr->valueDebugTbl) {
interp->dbPtr->valueDebugTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, NULL);
interp->dbPtr->objDebugTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, NULL);
}
#endif
if (parent) {
if (parent->pkgDirs)
interp->pkgDirs = Jsi_ValueDupJSON(interp, parent->pkgDirs);
} else {
#ifdef JSI_PKG_DIRS
interp->pkgDirs = Jsi_StringSplit(interp, JSI_PKG_DIRS, ",");
Jsi_IncrRefCount(interp, interp->pkgDirs);
#endif
}
#ifdef JSI_USE_COMPAT
interp->compat = JSI_USE_COMPAT;
#endif
#ifndef JSI_CONF_ARGS
#define JSI_CONF_ARGS ""
#endif
interp->confArgs = JSI_CONF_ARGS;
for (iocnt = 1; (iocnt+1)<argc; iocnt+=2)
{
const char *aio = argv[iocnt];
if (Jsi_Strcmp(aio, "--T") == 0 || Jsi_Strcmp(aio, "--C") == 0 || Jsi_Strcmp(aio, "--L") == 0) {
continue;
}
if (Jsi_Strcmp(aio, "--F") == 0 || Jsi_Strcmp(aio, "--U") == 0 || Jsi_Strcmp(aio, "--V") == 0) {
iocnt--;
continue;
}
if (!Jsi_Strcmp(aio, "--I")) {
const char *aio2 = argv[iocnt+1];
if (!Jsi_Strncmp("memDebug:", aio2, sizeof("memDebug")))
interp->memDebug=strtol(aio2+sizeof("memDebug"), NULL, 0);
else if (!Jsi_Strncmp("compat", aio2, sizeof("compat")))
interp->subOpts.compat=strtol(aio2+sizeof("compat"), NULL, 0);
continue;
}
break;
}
SIGINIT(interp,INTERP);
interp->NullValue = Jsi_ValueNewNull(interp);
Jsi_IncrRefCount(interp, interp->NullValue);
#ifdef __WIN32
Jsi_DString cwdStr;
Jsi_DSInit(&cwdStr);
interp->curDir = Jsi_Strdup(Jsi_GetCwd(interp, &cwdStr));
Jsi_DSFree(&cwdStr);
#else
char buf[JSI_BUFSIZ];
interp->curDir = getcwd(buf, sizeof(buf));
interp->curDir = Jsi_Strdup(interp->curDir?interp->curDir:".");
#endif
interp->onDeleteTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, freeOnDeleteTbl);
interp->assocTbl = Jsi_HashNew(interp, JSI_KEYS_STRING, freeAssocTbl);
interp->cmdSpecTbl = Jsi_MapNew(interp, JSI_MAP_TREE, JSI_KEYS_STRING, freeCmdSpecTbl);
interp->eventTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, freeEventTbl);
interp->fileTbl = Jsi_HashNew(interp, JSI_KEYS_STRING, jsi_HashFree);
interp->funcObjTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, freeFuncObjTbl);
interp->funcsTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, freeFuncsTbl);
interp->bindTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, freeBindObjTbl);
interp->protoTbl = Jsi_HashNew(interp, JSI_KEYS_STRING, NULL/*freeValueTbl*/);
interp->regexpTbl = Jsi_HashNew(interp, JSI_KEYS_STRING, regExpFree);
interp->preserveTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, jsi_HashFree);
interp->loadTbl = (parent?parent->loadTbl:Jsi_HashNew(interp, JSI_KEYS_STRING, jsi_FreeOneLoadHandle));
interp->packageHash = Jsi_HashNew(interp, JSI_KEYS_STRING, packageHashFree);
interp->aliasHash = Jsi_HashNew(interp, JSI_KEYS_STRING, jsi_AliasFree);
interp->lockTimeout = -1;
#ifdef JSI_LOCK_TIMEOUT
interp->lockTimeout JSI_LOCK_TIMEOUT;
#endif
#ifndef JSI_DO_UNLOCK
#define JSI_DO_UNLOCK 1
#endif
interp->subOpts.mutexUnlock = JSI_DO_UNLOCK;
Jsi_Map_Type mapType = JSI_MAP_HASH;
#ifdef JSI_USE_MANY_STRKEY
mapType = JSI_MAP_TREE;
#endif
if (interp == jsiIntData.mainInterp || interp->threadId != jsiIntData.mainInterp->threadId) {
interp->strKeyTbl = Jsi_MapNew(interp, mapType, JSI_KEYS_STRING, NULL);
interp->subOpts.privKeys = 1;
}
// Handle interp options: -T value and -Ixxx value
for (iocnt = 1; (iocnt+1)<argc && !interp->parent; iocnt+=2)
{
const char *aio = argv[iocnt];
if (Jsi_Strcmp(aio, "--F") == 0) {
interp->traceCall |= (jsi_callTraceFuncs |jsi_callTraceArgs |jsi_callTraceReturn | jsi_callTraceBefore | jsi_callTraceFullPath);
iocnt--;
interp->iskips++;
continue;
}
if (Jsi_Strcmp(aio, "--U") == 0) {
interp->asserts = 1;
interp->unitTest = 1;
iocnt--;
interp->iskips++;
continue;
}
if (Jsi_Strcmp(aio, "--V") == 0) {
interp->asserts = 1;
interp->unitTest = 5;
interp->tracePuts = 1;
iocnt--;
interp->iskips++;
continue;
}
if (Jsi_Strcmp(aio, "--C") == 0) {
if (interp->confFile)
Jsi_LogWarn("overriding confFile: %s", interp->confFile);
interp->confFile = argv[iocnt+1];
interp->iskips+=2;
continue;
}
if (Jsi_Strcmp(aio, "--L") == 0) {
struct stat sb;
const char* path = argv[iocnt+1]; //TODO: convert to Jsi_Value first?
if (!path || stat(path, &sb)
|| !((S_ISREG(sb.st_mode) && !access(path, W_OK)) || (S_ISDIR(sb.st_mode) && !access(path, X_OK)))) {
Jsi_LogError("Lockdown path must exist and be a writable file or executable dir: %s", path);
Jsi_InterpDelete(interp);
return NULL;
}
interp->isSafe = true;
interp->safeMode = jsi_safe_Lockdown;
if (interp->safeWriteDirs) {
Jsi_LogWarn("Overriding safeWriteDirs");
Jsi_DecrRefCount(interp, interp->safeWriteDirs);
}
const char *vda[2] = {};
char npath[PATH_MAX];
vda[0] = Jsi_FileRealpathStr(interp, path, npath);
interp->safeWriteDirs = Jsi_ValueNewArray(interp, vda, 1);
Jsi_IncrRefCount(interp, interp->safeWriteDirs);
if (!interp->safeReadDirs) {
interp->safeReadDirs = interp->safeWriteDirs;
Jsi_IncrRefCount(interp, interp->safeReadDirs);
}
interp->iskips+=2;
continue;
}
if (Jsi_Strcmp(aio, "--T") == 0) {
if (jsi_ParseTypeCheckStr(interp, argv[iocnt+1]) != JSI_OK) {
Jsi_InterpDelete(interp);
return NULL;
}
interp->iskips+=2;
continue;
}
if (!Jsi_Strcmp(aio, "--I")) {
bool bv = 1;
char *aio2 = argv[iocnt+1], *aioc = Jsi_Strchr(aio2, ':'),
argNamS[50], *argNam = aio2;
const char *argVal;
if (!Jsi_Strcmp("traceCall", aio2))
interp->traceCall |= (jsi_callTraceFuncs |jsi_callTraceArgs |jsi_callTraceReturn | jsi_callTraceBefore | jsi_callTraceFullPath);
else {
if (aioc) {
argNam = argNamS;
argVal = aioc+1;
snprintf(argNamS, sizeof(argNamS), "%.*s", (int)(aioc-aio2), aio2);
}
DECL_VALINIT(argV);
Jsi_Value *argValue = &argV;
Jsi_Number dv;
if (!aioc || Jsi_GetBool(interp, argVal, &bv) == JSI_OK) {
Jsi_ValueMakeBool(interp, &argValue, bv);
} else if (!Jsi_Strcmp("null", argVal)) {
Jsi_ValueMakeNull(interp, &argValue);
} else if (Jsi_GetDouble(interp, argVal, &dv) == JSI_OK) {
Jsi_ValueMakeNumber(interp, &argValue, dv);
} else {
Jsi_ValueMakeStringKey(interp, &argValue, argVal);
}
if (JSI_OK != Jsi_OptionsSet(interp, InterpOptions, interp, argNam, argValue, 0)) {
Jsi_InterpDelete(interp);
return NULL;
}
}
interp->iskips+=2;
continue;
}
break;
}
if (!interp->strKeyTbl)
interp->strKeyTbl = jsiIntData.mainInterp->strKeyTbl;
if (opts) {
interp->inopts = opts = Jsi_ValueDupJSON(interp, opts);
if (Jsi_OptionsProcess(interp, InterpOptions, interp, opts, 0) < 0) {
Jsi_DecrRefCount(interp, opts);
interp->inopts = NULL;
Jsi_InterpDelete(interp);
return NULL;
}
}
if (interp == jsiIntData.mainInterp) {
interp->subthread = 0;
} else {
if (opts) {
if (interp->subOpts.privKeys && interp->strKeyTbl == jsiIntData.mainInterp->strKeyTbl) {
//Jsi_HashDelete(interp->strKeyTbl);
Jsi_OptionsFree(interp, InterpOptions, interp, 0); /* Reparse options to populate new key table. */
interp->strKeyTbl = Jsi_MapNew(interp, mapType, JSI_KEYS_STRING, NULL);
if (opts->vt != JSI_VT_NULL) Jsi_OptionsProcess(interp, InterpOptions, interp, opts, 0);
} else if (interp->subOpts.privKeys == 0 && interp->strKeyTbl != jsiIntData.mainInterp->strKeyTbl) {
Jsi_OptionsFree(interp, InterpOptions, interp, 0); /* Reparse options to populate new key table. */
Jsi_MapDelete(interp->strKeyTbl);
interp->strKeyTbl = jsiIntData.mainInterp->strKeyTbl;
if (opts->vt != JSI_VT_NULL) Jsi_OptionsProcess(interp, InterpOptions, interp, opts, 0);
}
}
if (parent && parent->isSafe) {
interp->isSafe = 1;
interp->safeMode = parent->safeMode;
}
if (interp->subthread && interp->isSafe) {
interp->subthread = 0;
Jsi_LogError("threading disallowed in safe mode");
Jsi_InterpDelete(interp);
return NULL;
}
if (interp->subthread)
jsiIntData.mainInterp->threadCnt++;
if (interp->subthread && interp->strKeyTbl == jsiIntData.mainInterp->strKeyTbl)
jsiIntData.mainInterp->threadShrCnt++;
if (jsiIntData.mainInterp->threadShrCnt)
#ifdef JSI_USE_MANY_STRKEY
jsiIntData.mainInterp->strKeyTbl->v.tree->opts.lockTreeProc = KeyLockerTree;
#else
jsiIntData.mainInterp->strKeyTbl->v.hash->opts.lockHashProc = KeyLocker;
#endif
}
if (parent && parent->isSafe) {
interp->isSafe = 1;
interp->safeMode = parent->safeMode;
interp->maxOpCnt = parent->maxOpCnt;
if (interp->safeWriteDirs || interp->safeReadDirs || interp->safeExecPattern) {
Jsi_LogWarn("ignoring safe* options in safe sub-sub-interp");
if (interp->safeWriteDirs) Jsi_DecrRefCount(interp, interp->safeWriteDirs);
if (interp->safeReadDirs) Jsi_DecrRefCount(interp, interp->safeReadDirs);
interp->safeWriteDirs = interp->safeReadDirs = NULL;
interp->safeExecPattern = NULL;
}
}
jsi_InterpConfFiles(interp);
if (!interp->udata) {
interp->udata = Jsi_ValueNewObj(interp, NULL);
Jsi_IncrRefCount(interp, interp->udata);
}
if (interp->subthread && !interp->scriptStr && !interp->scriptFile) {
Jsi_LogError("subthread interp must be specify either scriptFile or scriptStr");
Jsi_InterpDelete(interp);
return NULL;
}
#ifndef JSI_MEM_DEBUG
static int warnNoDebug = 0;
if (interp->memDebug && warnNoDebug == 0) {
Jsi_LogWarn("ignoring memDebug as jsi was compiled without memory debugging");
warnNoDebug = 1;
}
#endif
interp->threadId = Jsi_CurrentThread();
if (interp->parent && interp->subthread==0 && interp->threadId != interp->parent->threadId) {
interp->threadId = interp->parent->threadId;
#ifndef JSI_MEM_DEBUG
Jsi_LogWarn("non-threaded sub-interp created by different thread than parent");
#endif
}
if (interp->safeMode != jsi_safe_None)
interp->isSafe = interp->startSafe = 1;
if (!interp->parent) {
if (interp->isSafe)
interp->startSafe = 1;
if (interp->debugOpts.msgCallback)
Jsi_LogWarn("ignoring msgCallback");
if (interp->debugOpts.putsCallback)
Jsi_LogWarn("ignoring putsCallback");
if (interp->busyCallback)
Jsi_LogWarn("ignoring busyCallback");
if (interp->debugOpts.traceCallback)
Jsi_LogWarn("ignoring traceCallback");
} else if (interp->busyCallback && interp->threadId != interp->parent->threadId) {
Jsi_LogWarn("disabling busyCallback due to threads");
interp->busyCallback = NULL;
}
if (interp == jsiIntData.mainInterp)
interp->lexkeyTbl = Jsi_HashNew(interp, JSI_KEYS_STRING, NULL);
else
interp->lexkeyTbl = jsiIntData.mainInterp->lexkeyTbl;
interp->thisTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, freeValueTbl);
interp->userdataTbl = Jsi_HashNew(interp, JSI_KEYS_STRING, freeUserdataTbl);
interp->varTbl = Jsi_HashNew(interp, JSI_KEYS_STRING, NULL);
interp->codeTbl = Jsi_HashNew(interp, JSI_KEYS_STRING, freeCodeTbl);
interp->genValueTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD,freeValueTbl);
interp->genObjTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, freeGenObjTbl);
#ifdef JSI_MEM_DEBUG
interp->codesTbl = (interp == jsiIntData.mainInterp ? Jsi_HashNew(interp, JSI_KEYS_ONEWORD, NULL) : jsiIntData.mainInterp->codesTbl);
#endif
if (interp->typeCheck.all|interp->typeCheck.parse|interp->typeCheck.funcsig)
interp->staticFuncsTbl = Jsi_HashNew(interp, JSI_KEYS_STRING, NULL);
if (!jsiIntData.isInit) {
jsiIntData.isInit = 1;
jsi_InitValue(interp, 0);
jsiIntData.interpsTbl = Jsi_HashNew(interp, JSI_KEYS_ONEWORD, 0);
}
/* current scope, also global */
interp->csc = Jsi_ValueNew1(interp);
Jsi_ValueMakeObject(interp, &interp->csc, Jsi_ObjNew(interp));
interp->framePtr->incsc = interp->csc;
#define JSIDOINIT(nam) if (!jsi_ModBlacklisted(interp,#nam)) { if (jsi_Init##nam(interp, 0) != JSI_OK) { Jsi_LogBug("Init failure in %s", #nam); } }
#define JSIDOINIT2(nam) if (!jsi_ModBlacklisted(interp,#nam)) { if (Jsi_Init##nam(interp, 0) != JSI_OK) { Jsi_LogBug("Init failure in %s", #nam); } }
JSIDOINIT(Proto);
if (interp->pkgDirs) // Fix-up because above, array was not yet initialized.
interp->pkgDirs->d.obj->__proto__ = interp->Array_prototype;
Jsi_Value *modObj = Jsi_ValueNewObj(interp, Jsi_ObjNewType(interp, JSI_OT_OBJECT));
Jsi_ValueInsert(interp, interp->csc, "Jsi_Auto", modObj, JSI_OM_DONTDEL);
/* initial scope chain, nothing */
interp->framePtr->ingsc = interp->gsc = jsi_ScopeChainNew(interp, 0);
interp->ps = jsi_PstateNew(interp); /* Default parser. */
if (interp->unitTest&2) {
interp->logOpts.before = 1;
interp->logOpts.full = 1;
interp->tracePuts = 1;
interp->noStderr = 1;
}
if (interp->args && argc) {
Jsi_LogBug("args may not be specified both as options and parameter");
Jsi_InterpDelete(interp);
return NULL;
}
if (interp->maxDepth>JSI_MAX_EVAL_DEPTH)
interp->maxDepth = JSI_MAX_EVAL_DEPTH;
// Create the args array.
if (argc >= 0 && !interp->args) {
Jsi_Value *iargs = Jsi_ValueNew1(interp);
iargs->f.bits.dontdel = 1;
iargs->f.bits.readonly = 1;
Jsi_Obj *iobj = Jsi_ObjNew(interp);
Jsi_ValueMakeArrayObject(interp, &iargs, iobj);
int i = 1, ii = (iocnt>1 ? iocnt : 1);
int msiz = (argc?argc-iocnt:0);
Jsi_ObjArraySizer(interp, iobj, msiz);
iobj->arrMaxSize = msiz;
iocnt--;
iobj->arrCnt = argc-iocnt;
for (i = 1; ii < argc; ++ii, i++) {
iobj->arr[i-1] = Jsi_ValueNewStringKey(interp, argv[ii]);
Jsi_IncrRefCount(interp, iobj->arr[i-1]);
jsi_ValueDebugLabel(iobj->arr[i-1], "InterpCreate", "args");
}
Jsi_ObjSetLength(interp, iobj, msiz);
interp->args = iargs;
} else if (interp->parent && interp->args) {
// Avoid strings from sneeking in with options from parent...
Jsi_Value *nar = Jsi_ValueDupJSON(interp, interp->args);
Jsi_DecrRefCount(interp, interp->args);
interp->args = nar;
}
JSIDOINIT(Options);
JSIDOINIT(Cmds);
JSIDOINIT(Interp);
JSIDOINIT(JSON);
interp->retValue = Jsi_ValueNew1(interp);
interp->Mutex = Jsi_MutexNew(interp, -1, JSI_MUTEX_RECURSIVE);
if (1 || interp->subthread) {
interp->QMutex = Jsi_MutexNew(interp, -1, JSI_MUTEX_RECURSIVE);
//Jsi_DSInit(&interp->interpEvalQ);
}
JSIDOINIT(Lexer);
if (interp != jsiIntData.mainInterp && !parent)
Jsi_HashSet(jsiIntData.interpsTbl, interp, NULL);
if (!interp->isSafe) {
JSIDOINIT(Load);
#if JSI__SIGNAL==1
JSIDOINIT(Signal);
#endif
}
if (interp->isSafe == 0 || interp->startSafe || interp->safeWriteDirs!=NULL || interp->safeReadDirs!=NULL) {
#if JSI__FILESYS==1
JSIDOINIT(FileCmds);
JSIDOINIT(Filesys);
#endif
}
#if JSI__SQLITE==1
JSIDOINIT2(Sqlite);
#else
Jsi_initSqlite(interp, 0);
#endif
#if JSI__MYSQL==1
if (!interp->noNetwork) {
JSIDOINIT2(MySql);
}
#endif
#if JSI__SOCKET==1
JSIDOINIT2(Socket);
#endif
#if JSI__WEBSOCKET==1
JSIDOINIT2(WebSocket);
#endif
#if JSI__CDATA==1
JSIDOINIT(CData);
#endif
#ifdef JSI_USER_EXTENSION
extern int JSI_USER_EXTENSION(Jsi_Interp *interp, int release);
if (JSI_USER_EXTENSION (interp, 0) != JSI_OK) {
fprintf(stderr, "extension load failed");
return jsi_DoExit(interp, 1);
}
#endif
Jsi_PkgProvide(interp, "Jsi", JSI_VERSION, NULL);
if (argc > 0) {
char *ss = argv0;
char epath[PATH_MAX] = ""; // Path of executable
#ifdef __WIN32
if (GetModuleFileName(NULL, epath, sizeof(epath))>0)
ss = epath;
#else
#ifndef PROC_SELF_DIR
#define PROC_SELF_DIR "/proc/self/exe"
#endif
if (ss && *ss != '/' && readlink(PROC_SELF_DIR, epath, sizeof(epath)) && epath[0])
ss = epath;
#endif
Jsi_Value *src = Jsi_ValueNewStringDup(interp, ss);
Jsi_IncrRefCount(interp, src);
jsiIntData.execName = Jsi_Realpath(interp, src, NULL);
Jsi_DecrRefCount(interp, src);
if (!jsiIntData.execName) jsiIntData.execName = Jsi_Strdup("");
jsiIntData.execValue = Jsi_ValueNewString(interp, jsiIntData.execName, -1);
Jsi_IncrRefCount(interp, jsiIntData.execValue);
Jsi_HashSet(interp->genValueTbl, jsiIntData.execValue, jsiIntData.execValue);
}
//interp->nocacheOpCodes = 1;
if (interp->debugOpts.debugCallback && !interp->debugOpts.hook) {
interp->debugOpts.hook = jsi_InterpDebugHook;
}
interp->startTime = jsi_GetTimestamp();
#ifdef JSI_INTERP_EXTENSION_CODE // For extending interp from jsi.c
JSI_INTERP_EXTENSION_CODE
#endif
if (interp->opts.initProc && (*interp->opts.initProc)(interp, 0) != JSI_OK)
Jsi_LogBug("Init failure in initProc");
return interp;
}
| 0
|
218,121
|
std::unique_ptr<net::test_server::HttpResponse> DrpBlockOnceHandler(
const std::string& server_name,
EventLog* event_log,
const net::test_server::HttpRequest& request) {
if (request.relative_url == "/favicon.ico")
return nullptr;
event_log->Add(server_name + " responded 502 for " + request.relative_url);
auto response = std::make_unique<net::test_server::BasicHttpResponse>();
response->set_content_type("text/plain");
response->set_code(net::HTTP_BAD_GATEWAY);
response->AddCustomHeader(chrome_proxy_header(), "block-once");
return response;
}
| 0
|
310,221
|
bool OmniboxViewViews::HandleAccessibleAction(
const ui::AXActionData& action_data) {
if (read_only())
return Textfield::HandleAccessibleAction(action_data);
if (action_data.action == ui::AX_ACTION_SET_VALUE) {
SetUserText(action_data.value, true);
return true;
} else if (action_data.action == ui::AX_ACTION_REPLACE_SELECTED_TEXT) {
model()->SetInputInProgress(true);
if (saved_selection_for_focus_change_.IsValid()) {
SelectRange(saved_selection_for_focus_change_);
saved_selection_for_focus_change_ = gfx::Range::InvalidRange();
}
InsertOrReplaceText(action_data.value);
TextChanged();
return true;
}
return Textfield::HandleAccessibleAction(action_data);
}
| 0
|
444,448
|
TEST_P(Http2UpstreamIntegrationTest, BidirectionalStreaming) { bidirectionalStreaming(1024); }
| 0
|
323,348
|
int32_t scsi_send_command(SCSIDevice *s, uint32_t tag, uint8_t *buf, int lun)
{
int64_t nb_sectors;
uint32_t lba;
uint32_t len;
int cmdlen;
int is_write;
s->command = buf[0];
s->tag = tag;
s->sector_count = 0;
s->buf_pos = 0;
s->buf_len = 0;
is_write = 0;
DPRINTF("Command: 0x%02x", buf[0]);
switch (s->command >> 5) {
case 0:
lba = buf[3] | (buf[2] << 8) | ((buf[1] & 0x1f) << 16);
len = buf[4];
cmdlen = 6;
break;
case 1:
case 2:
lba = buf[5] | (buf[4] << 8) | (buf[3] << 16) | (buf[2] << 24);
len = buf[8] | (buf[7] << 8);
cmdlen = 10;
break;
case 4:
lba = buf[5] | (buf[4] << 8) | (buf[3] << 16) | (buf[2] << 24);
len = buf[13] | (buf[12] << 8) | (buf[11] << 16) | (buf[10] << 24);
cmdlen = 16;
break;
case 5:
lba = buf[5] | (buf[4] << 8) | (buf[3] << 16) | (buf[2] << 24);
len = buf[9] | (buf[8] << 8) | (buf[7] << 16) | (buf[6] << 24);
cmdlen = 12;
break;
default:
BADF("Unsupported command length, command %x\n", s->command);
goto fail;
}
#ifdef DEBUG_SCSI
{
int i;
for (i = 1; i < cmdlen; i++) {
printf(" 0x%02x", buf[i]);
}
printf("\n");
}
#endif
if (lun || buf[1] >> 5) {
/* Only LUN 0 supported. */
DPRINTF("Unimplemented LUN %d\n", lun ? lun : buf[1] >> 5);
goto fail;
}
switch (s->command) {
case 0x0:
DPRINTF("Test Unit Ready\n");
break;
case 0x03:
DPRINTF("Request Sense (len %d)\n", len);
if (len < 4)
goto fail;
memset(buf, 0, 4);
s->buf[0] = 0xf0;
s->buf[1] = 0;
s->buf[2] = s->sense;
s->buf_len = 4;
break;
case 0x12:
DPRINTF("Inquiry (len %d)\n", len);
if (len < 36) {
BADF("Inquiry buffer too small (%d)\n", len);
}
memset(s->buf, 0, 36);
if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
s->buf[0] = 5;
s->buf[1] = 0x80;
memcpy(&s->buf[16], "QEMU CD-ROM ", 16);
} else {
s->buf[0] = 0;
memcpy(&s->buf[16], "QEMU HARDDISK ", 16);
}
memcpy(&s->buf[8], "QEMU ", 8);
memcpy(&s->buf[32], QEMU_VERSION, 4);
/* Identify device as SCSI-3 rev 1.
Some later commands are also implemented. */
s->buf[2] = 3;
s->buf[3] = 2; /* Format 2 */
s->buf[4] = 32;
s->buf_len = 36;
break;
case 0x16:
DPRINTF("Reserve(6)\n");
if (buf[1] & 1)
goto fail;
break;
case 0x17:
DPRINTF("Release(6)\n");
if (buf[1] & 1)
goto fail;
break;
case 0x1a:
case 0x5a:
{
char *p;
int page;
page = buf[2] & 0x3f;
DPRINTF("Mode Sense (page %d, len %d)\n", page, len);
p = s->buf;
memset(p, 0, 4);
s->buf[1] = 0; /* Default media type. */
s->buf[3] = 0; /* Block descriptor length. */
if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
s->buf[2] = 0x80; /* Readonly. */
}
p += 4;
if ((page == 8 || page == 0x3f)) {
/* Caching page. */
p[0] = 8;
p[1] = 0x12;
p[2] = 4; /* WCE */
p += 19;
}
if ((page == 0x3f || page == 0x2a)
&& (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM)) {
/* CD Capabilities and Mechanical Status page. */
p[0] = 0x2a;
p[1] = 0x14;
p[2] = 3; // CD-R & CD-RW read
p[3] = 0; // Writing not supported
p[4] = 0x7f; /* Audio, composite, digital out,
mode 2 form 1&2, multi session */
p[5] = 0xff; /* CD DA, DA accurate, RW supported,
RW corrected, C2 errors, ISRC,
UPC, Bar code */
p[6] = 0x2d | (bdrv_is_locked(s->bdrv)? 2 : 0);
/* Locking supported, jumper present, eject, tray */
p[7] = 0; /* no volume & mute control, no
changer */
p[8] = (50 * 176) >> 8; // 50x read speed
p[9] = (50 * 176) & 0xff;
p[10] = 0 >> 8; // No volume
p[11] = 0 & 0xff;
p[12] = 2048 >> 8; // 2M buffer
p[13] = 2048 & 0xff;
p[14] = (16 * 176) >> 8; // 16x read speed current
p[15] = (16 * 176) & 0xff;
p[18] = (16 * 176) >> 8; // 16x write speed
p[19] = (16 * 176) & 0xff;
p[20] = (16 * 176) >> 8; // 16x write speed current
p[21] = (16 * 176) & 0xff;
p += 21;
}
s->buf_len = p - s->buf;
s->buf[0] = s->buf_len - 4;
if (s->buf_len > len)
s->buf_len = len;
}
break;
case 0x1b:
DPRINTF("Start Stop Unit\n");
break;
case 0x1e:
DPRINTF("Prevent Allow Medium Removal (prevent = %d)\n", buf[4] & 3);
bdrv_set_locked(s->bdrv, buf[4] & 1);
break;
case 0x25:
DPRINTF("Read Capacity\n");
/* The normal LEN field for this command is zero. */
memset(s->buf, 0, 8);
bdrv_get_geometry(s->bdrv, &nb_sectors);
s->buf[0] = (nb_sectors >> 24) & 0xff;
s->buf[1] = (nb_sectors >> 16) & 0xff;
s->buf[2] = (nb_sectors >> 8) & 0xff;
s->buf[3] = nb_sectors & 0xff;
s->buf[4] = 0;
s->buf[5] = 0;
s->buf[6] = s->cluster_size * 2;
s->buf[7] = 0;
s->buf_len = 8;
break;
case 0x08:
case 0x28:
DPRINTF("Read (sector %d, count %d)\n", lba, len);
s->sector = lba * s->cluster_size;
s->sector_count = len * s->cluster_size;
break;
case 0x0a:
case 0x2a:
DPRINTF("Write (sector %d, count %d)\n", lba, len);
s->sector = lba * s->cluster_size;
s->sector_count = len * s->cluster_size;
is_write = 1;
break;
case 0x35:
DPRINTF("Syncronise cache (sector %d, count %d)\n", lba, len);
bdrv_flush(s->bdrv);
break;
case 0x43:
{
int start_track, format, msf, toclen;
msf = buf[1] & 2;
format = buf[2] & 0xf;
start_track = buf[6];
bdrv_get_geometry(s->bdrv, &nb_sectors);
DPRINTF("Read TOC (track %d format %d msf %d)\n", start_track, format, msf >> 1);
switch(format) {
case 0:
toclen = cdrom_read_toc(nb_sectors, s->buf, msf, start_track);
break;
case 1:
/* multi session : only a single session defined */
toclen = 12;
memset(s->buf, 0, 12);
s->buf[1] = 0x0a;
s->buf[2] = 0x01;
s->buf[3] = 0x01;
break;
case 2:
toclen = cdrom_read_toc_raw(nb_sectors, s->buf, msf, start_track);
break;
default:
goto error_cmd;
}
if (toclen > 0) {
if (len > toclen)
len = toclen;
s->buf_len = len;
break;
}
error_cmd:
DPRINTF("Read TOC error\n");
goto fail;
}
case 0x46:
DPRINTF("Get Configuration (rt %d, maxlen %d)\n", buf[1] & 3, len);
memset(s->buf, 0, 8);
/* ??? This shoud probably return much more information. For now
just return the basic header indicating the CD-ROM profile. */
s->buf[7] = 8; // CD-ROM
s->buf_len = 8;
break;
case 0x56:
DPRINTF("Reserve(10)\n");
if (buf[1] & 3)
goto fail;
break;
case 0x57:
DPRINTF("Release(10)\n");
if (buf[1] & 3)
goto fail;
break;
case 0xa0:
DPRINTF("Report LUNs (len %d)\n", len);
if (len < 16)
goto fail;
memset(s->buf, 0, 16);
s->buf[3] = 8;
s->buf_len = 16;
break;
default:
DPRINTF("Unknown SCSI command (%2.2x)\n", buf[0]);
fail:
scsi_command_complete(s, SENSE_ILLEGAL_REQUEST);
return 0;
}
if (s->sector_count == 0 && s->buf_len == 0) {
scsi_command_complete(s, SENSE_NO_SENSE);
}
len = s->sector_count * 512 + s->buf_len;
return is_write ? -len : len;
}
| 1
|
197,558
|
PHP_METHOD(Phar, convertToExecutable)
{
char *ext = NULL;
int is_data, ext_len = 0;
php_uint32 flags;
zval *ret;
/* a number that is not 0, 1 or 2 (Which is also Greg's birthday, so there) */
long format = 9021976, method = 9021976;
PHAR_ARCHIVE_OBJECT();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lls", &format, &method, &ext, &ext_len) == FAILURE) {
return;
}
if (PHAR_G(readonly)) {
zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC,
"Cannot write out executable phar archive, phar is read-only");
return;
}
switch (format) {
case 9021976:
case PHAR_FORMAT_SAME: /* null is converted to 0 */
/* by default, use the existing format */
if (phar_obj->arc.archive->is_tar) {
format = PHAR_FORMAT_TAR;
} else if (phar_obj->arc.archive->is_zip) {
format = PHAR_FORMAT_ZIP;
} else {
format = PHAR_FORMAT_PHAR;
}
break;
case PHAR_FORMAT_PHAR:
case PHAR_FORMAT_TAR:
case PHAR_FORMAT_ZIP:
break;
default:
zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
"Unknown file format specified, please pass one of Phar::PHAR, Phar::TAR or Phar::ZIP");
return;
}
switch (method) {
case 9021976:
flags = phar_obj->arc.archive->flags & PHAR_FILE_COMPRESSION_MASK;
break;
case 0:
flags = PHAR_FILE_COMPRESSED_NONE;
break;
case PHAR_ENT_COMPRESSED_GZ:
if (format == PHAR_FORMAT_ZIP) {
zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
"Cannot compress entire archive with gzip, zip archives do not support whole-archive compression");
return;
}
if (!PHAR_G(has_zlib)) {
zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
"Cannot compress entire archive with gzip, enable ext/zlib in php.ini");
return;
}
flags = PHAR_FILE_COMPRESSED_GZ;
break;
case PHAR_ENT_COMPRESSED_BZ2:
if (format == PHAR_FORMAT_ZIP) {
zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
"Cannot compress entire archive with bz2, zip archives do not support whole-archive compression");
return;
}
if (!PHAR_G(has_bz2)) {
zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
"Cannot compress entire archive with bz2, enable ext/bz2 in php.ini");
return;
}
flags = PHAR_FILE_COMPRESSED_BZ2;
break;
default:
zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC,
"Unknown compression specified, please pass one of Phar::GZ or Phar::BZ2");
return;
}
is_data = phar_obj->arc.archive->is_data;
phar_obj->arc.archive->is_data = 0;
ret = phar_convert_to_other(phar_obj->arc.archive, format, ext, flags TSRMLS_CC);
phar_obj->arc.archive->is_data = is_data;
if (ret) {
RETURN_ZVAL(ret, 1, 1);
} else {
RETURN_NULL();
}
}
| 0
|
148,665
|
static void sync_child_event(struct perf_event *child_event,
struct task_struct *child)
{
struct perf_event *parent_event = child_event->parent;
u64 child_val;
if (child_event->attr.inherit_stat)
perf_event_read_event(child_event, child);
child_val = perf_event_count(child_event);
/*
* Add back the child's count to the parent's count:
*/
atomic64_add(child_val, &parent_event->child_count);
atomic64_add(child_event->total_time_enabled,
&parent_event->child_total_time_enabled);
atomic64_add(child_event->total_time_running,
&parent_event->child_total_time_running);
/*
* Remove this event from the parent's list
*/
WARN_ON_ONCE(parent_event->ctx->parent_ctx);
mutex_lock(&parent_event->child_mutex);
list_del_init(&child_event->child_list);
mutex_unlock(&parent_event->child_mutex);
/*
* Release the parent event, if this was the last
* reference to it.
*/
put_event(parent_event);
}
| 0
|
276,207
|
static void Ins_IF( INS_ARG )
{
Int nIfs;
Bool Out;
if ( args[0] != 0 )
return;
nIfs = 1;
Out = 0;
do
{
if ( SKIP_Code() == FAILURE )
return;
switch ( CUR.opcode )
{
case 0x58: /* IF */
nIfs++;
break;
case 0x1b: /* ELSE */
Out = (nIfs == 1);
break;
case 0x59: /* EIF */
nIfs--;
Out = (nIfs == 0);
break;
}
} while ( Out == 0 );
}
| 0
|
374,358
|
hv_store_string(HV *hv, const char *key, SV *val)
{
int32 hlen;
char *hkey;
SV **ret;
hkey = (char *)
pg_do_encoding_conversion((unsigned char *) key, strlen(key),
GetDatabaseEncoding(), PG_UTF8);
/*
* This seems nowhere documented, but under Perl 5.8.0 and up, hv_store()
* recognizes a negative klen parameter as meaning a UTF-8 encoded key. It
* does not appear that hashes track UTF-8-ness of keys at all in Perl
* 5.6.
*/
hlen = -(int) strlen(hkey);
ret = hv_store(hv, hkey, hlen, val, 0);
if (hkey != key)
pfree(hkey);
return ret;
}
| 0
|
488,549
|
~edge_clone_summary ()
{
if (prev_clone)
edge_clone_summaries->get (prev_clone)->next_clone = next_clone;
if (next_clone)
edge_clone_summaries->get (next_clone)->prev_clone = prev_clone;
}
| 0
|
447,390
|
int sldns_str2wire_ipseckey_buf(const char* str, uint8_t* rd, size_t* len)
{
size_t gwlen = 0, keylen = 0;
int s;
uint8_t gwtype;
char token[512];
sldns_buffer strbuf;
sldns_buffer_init_frm_data(&strbuf, (uint8_t*)str, strlen(str));
if(*len < 3)
return LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL;
/* precedence */
if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
sldns_buffer_position(&strbuf));
rd[0] = (uint8_t)atoi(token);
/* gateway_type */
if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
sldns_buffer_position(&strbuf));
rd[1] = (uint8_t)atoi(token);
gwtype = rd[1];
/* algorithm */
if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
sldns_buffer_position(&strbuf));
rd[2] = (uint8_t)atoi(token);
/* gateway */
if(sldns_bget_token(&strbuf, token, "\t\n ", sizeof(token)) <= 0)
return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
sldns_buffer_position(&strbuf));
if(gwtype == 0) {
/* NOGATEWAY */
if(strcmp(token, ".") != 0)
return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
sldns_buffer_position(&strbuf));
gwlen = 0;
} else if(gwtype == 1) {
/* IP4 */
gwlen = *len - 3;
s = sldns_str2wire_a_buf(token, rd+3, &gwlen);
if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
} else if(gwtype == 2) {
/* IP6 */
gwlen = *len - 3;
s = sldns_str2wire_aaaa_buf(token, rd+3, &gwlen);
if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
} else if(gwtype == 3) {
/* DNAME */
gwlen = *len - 3;
s = sldns_str2wire_dname_buf(token, rd+3, &gwlen);
if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
} else {
/* unknown gateway type */
return RET_ERR(LDNS_WIREPARSE_ERR_INVALID_STR,
sldns_buffer_position(&strbuf));
}
/* double check for size */
if(*len < 3 + gwlen)
return RET_ERR(LDNS_WIREPARSE_ERR_BUFFER_TOO_SMALL,
sldns_buffer_position(&strbuf));
/* publickey in remainder of strbuf */
keylen = *len - 3 - gwlen;
s = sldns_str2wire_b64_buf((const char*)sldns_buffer_current(&strbuf),
rd+3+gwlen, &keylen);
if(s) return RET_ERR_SHIFT(s, sldns_buffer_position(&strbuf));
*len = 3 + gwlen + keylen;
return LDNS_WIREPARSE_ERR_OK;
}
| 0
|
364,694
|
static int parserange(char *str, uint32_t *uid, uint32_t *last,
char **msgid, struct backend **ret)
{
const char *p = NULL;
char *mboxname;
int r = 0;
*uid = 0;
if (last) *last = 0;
if (msgid) *msgid = NULL;
if (ret) *ret = NULL;
if (!str || !*str) {
/* no argument, use current article */
if (backend_current) {
if (ret) *ret = backend_current;
}
else if (!group_state) goto noopengroup;
else if (!nntp_current) goto nocurrent;
else {
*uid = index_getuid(group_state, nntp_current);
if (last) *last = *uid;
}
}
else if (*str == '<') {
/* message-id, find server and/or mailbox */
if (!msgid) goto badrange;
if (!find_msgid(str, &mboxname, uid)) goto nomsgid;
*msgid = str;
/* open group if its different from our current one */
if (!group_state || strcmp(mboxname, group_state->mailbox->name)) {
if ((r = open_group(mboxname, 1, ret, NULL))) goto nomsgid;
}
}
else if (backend_current)
*ret = backend_current;
else if (!group_state) goto noopengroup;
else if (parseuint32(str, &p, uid) || uid == 0) goto badrange;
else if (p && *p) {
/* extra stuff, check for range */
if (!last || (*p != '-')) goto badrange;
if (*++p) {
if (parseuint32(p, NULL, last))
*last = 0;
}
else
*last = UINT32_MAX; /* open range -> use highest possible UID */
}
if (last && !*last) *last = *uid;
return 0;
noopengroup:
prot_printf(nntp_out, "412 No newsgroup selected\r\n");
return -1;
nocurrent:
prot_printf(nntp_out, "420 Current article number is invalid\r\n");
return -1;
nomsgid:
prot_printf(nntp_out, "430 No article found with that message-id");
if (r) prot_printf(nntp_out, " (%s)", error_message(r));
prot_printf(nntp_out, "\r\n");
return -1;
badrange:
prot_printf(nntp_out, "501 Bad message-id, message number, or range\r\n");
return -1;
}
| 0
|
286,208
|
static uint64_t xhci_oper_read(void *ptr, hwaddr reg, unsigned size)
{
XHCIState *xhci = ptr;
uint32_t ret;
switch (reg) {
case 0x00: /* USBCMD */
ret = xhci->usbcmd;
break;
case 0x04: /* USBSTS */
ret = xhci->usbsts;
break;
case 0x08: /* PAGESIZE */
ret = 1; /* 4KiB */
break;
case 0x14: /* DNCTRL */
ret = xhci->dnctrl;
break;
case 0x18: /* CRCR low */
ret = xhci->crcr_low & ~0xe;
break;
case 0x1c: /* CRCR high */
ret = xhci->crcr_high;
break;
case 0x30: /* DCBAAP low */
ret = xhci->dcbaap_low;
break;
case 0x34: /* DCBAAP high */
ret = xhci->dcbaap_high;
break;
case 0x38: /* CONFIG */
ret = xhci->config;
break;
default:
trace_usb_xhci_unimplemented("oper read", reg);
ret = 0;
}
trace_usb_xhci_oper_read(reg, ret);
return ret;
}
| 0
|
255,114
|
static void kgdb_hw_overflow_handler(struct perf_event *event, int nmi,
struct perf_sample_data *data, struct pt_regs *regs)
{
struct task_struct *tsk = current;
int i;
for (i = 0; i < 4; i++)
if (breakinfo[i].enabled)
tsk->thread.debugreg6 |= (DR_TRAP0 << i);
}
| 1
|
94,909
|
inline void LogSoftmax(const uint8* input_data, const RuntimeShape& input_shape,
int32 input_multiplier, int32 input_left_shift,
int32 reverse_scaling_divisor,
int32 reverse_scaling_right_shift, int diff_min,
uint8* output_data, const RuntimeShape& output_shape) {
SoftmaxParams params;
params.input_multiplier = input_multiplier;
params.input_left_shift = input_left_shift;
params.reverse_scaling_divisor = reverse_scaling_divisor;
params.reverse_scaling_right_shift = reverse_scaling_right_shift;
params.diff_min = diff_min;
reference_ops::LogSoftmax(params, input_shape, input_data, output_shape,
output_data);
}
| 0
|
25,476
|
void armv7m_nvic_complete_irq ( void * opaque , int irq ) {
nvic_state * s = ( nvic_state * ) opaque ;
if ( irq >= 16 ) irq += 16 ;
gic_complete_irq ( & s -> gic , 0 , irq ) ;
}
| 0
|
334,726
|
static void handle_notify(EventNotifier *e)
{
VirtIOBlockDataPlane *s = container_of(e, VirtIOBlockDataPlane,
host_notifier);
VirtQueueElement *elem;
VirtIOBlockReq *req;
int ret;
MultiReqBuffer mrb = {
.num_writes = 0,
};
event_notifier_test_and_clear(&s->host_notifier);
bdrv_io_plug(s->blk->conf.bs);
for (;;) {
/* Disable guest->host notifies to avoid unnecessary vmexits */
vring_disable_notification(s->vdev, &s->vring);
for (;;) {
ret = vring_pop(s->vdev, &s->vring, &elem);
if (ret < 0) {
assert(elem == NULL);
break; /* no more requests */
}
trace_virtio_blk_data_plane_process_request(s, elem->out_num,
elem->in_num, elem->index);
req = g_slice_new(VirtIOBlockReq);
req->dev = VIRTIO_BLK(s->vdev);
req->elem = elem;
virtio_blk_handle_request(req, &mrb);
}
virtio_submit_multiwrite(s->blk->conf.bs, &mrb);
if (likely(ret == -EAGAIN)) { /* vring emptied */
/* Re-enable guest->host notifies and stop processing the vring.
* But if the guest has snuck in more descriptors, keep processing.
*/
if (vring_enable_notification(s->vdev, &s->vring)) {
break;
}
} else { /* fatal error */
break;
}
}
bdrv_io_unplug(s->blk->conf.bs);
}
| 1
|
492,245
|
currval_oid(PG_FUNCTION_ARGS)
{
Oid relid = PG_GETARG_OID(0);
int64 result;
SeqTable elm;
Relation seqrel;
/* open and lock sequence */
init_sequence(relid, &elm, &seqrel);
if (pg_class_aclcheck(elm->relid, GetUserId(),
ACL_SELECT | ACL_USAGE) != ACLCHECK_OK)
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("permission denied for sequence %s",
RelationGetRelationName(seqrel))));
if (!elm->last_valid)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
errmsg("currval of sequence \"%s\" is not yet defined in this session",
RelationGetRelationName(seqrel))));
result = elm->last;
relation_close(seqrel, NoLock);
PG_RETURN_INT64(result);
}
| 0
|
160,165
|
lyd_merge(struct lyd_node *target, const struct lyd_node *source, int options)
{
if (!target || !source) {
LOGARG;
return -1;
}
return lyd_merge_to_ctx(&target, source, options, target->schema->module->ctx);
}
| 0
|
500,149
|
ArgParser::argEncrypt()
{
++cur_arg;
if (cur_arg + 3 > argc)
{
if (this->bash_completion)
{
if (cur_arg == argc)
{
this->completions.insert("user-password");
}
else if (cur_arg + 1 == argc)
{
this->completions.insert("owner-password");
}
else if (cur_arg + 2 == argc)
{
this->completions.insert("40");
this->completions.insert("128");
this->completions.insert("256");
}
return;
}
else
{
usage("insufficient arguments to --encrypt");
}
}
o.user_password = argv[cur_arg++];
o.owner_password = argv[cur_arg++];
std::string len_str = argv[cur_arg];
if (len_str == "40")
{
o.keylen = 40;
this->option_table = &(this->encrypt40_option_table);
}
else if (len_str == "128")
{
o.keylen = 128;
this->option_table = &(this->encrypt128_option_table);
}
else if (len_str == "256")
{
o.keylen = 256;
o.use_aes = true;
this->option_table = &(this->encrypt256_option_table);
}
else
{
usage("encryption key length must be 40, 128, or 256");
}
}
| 0
|
460,425
|
static bool mt_need_to_apply_feature(struct hid_device *hdev,
struct hid_field *field,
struct hid_usage *usage,
enum latency_mode latency,
bool surface_switch,
bool button_switch,
bool *inputmode_found)
{
struct mt_device *td = hid_get_drvdata(hdev);
struct mt_class *cls = &td->mtclass;
struct hid_report *report = field->report;
unsigned int index = usage->usage_index;
char *buf;
u32 report_len;
int max;
switch (usage->hid) {
case HID_DG_INPUTMODE:
/*
* Some elan panels wrongly declare 2 input mode features,
* and silently ignore when we set the value in the second
* field. Skip the second feature and hope for the best.
*/
if (*inputmode_found)
return false;
if (cls->quirks & MT_QUIRK_FORCE_GET_FEATURE) {
report_len = hid_report_len(report);
buf = hid_alloc_report_buf(report, GFP_KERNEL);
if (!buf) {
hid_err(hdev,
"failed to allocate buffer for report\n");
return false;
}
hid_hw_raw_request(hdev, report->id, buf, report_len,
HID_FEATURE_REPORT,
HID_REQ_GET_REPORT);
kfree(buf);
}
field->value[index] = td->inputmode_value;
*inputmode_found = true;
return true;
case HID_DG_CONTACTMAX:
if (cls->maxcontacts) {
max = min_t(int, field->logical_maximum,
cls->maxcontacts);
if (field->value[index] != max) {
field->value[index] = max;
return true;
}
}
break;
case HID_DG_LATENCYMODE:
field->value[index] = latency;
return true;
case HID_DG_SURFACESWITCH:
field->value[index] = surface_switch;
return true;
case HID_DG_BUTTONSWITCH:
field->value[index] = button_switch;
return true;
}
return false; /* no need to update the report */
}
| 0
|
240,125
|
CMS_ContentInfo *CMS_sign(X509 *signcert, EVP_PKEY *pkey,
STACK_OF(X509) *certs, BIO *data,
unsigned int flags)
{
CMS_ContentInfo *cms;
int i;
cms = CMS_ContentInfo_new();
if (cms == NULL || !CMS_SignedData_init(cms))
goto merr;
if (flags & CMS_ASCIICRLF
&& !CMS_set1_eContentType(cms,
OBJ_nid2obj(NID_id_ct_asciiTextWithCRLF)))
goto err;
if (pkey && !CMS_add1_signer(cms, signcert, pkey, NULL, flags)) {
CMSerr(CMS_F_CMS_SIGN, CMS_R_ADD_SIGNER_ERROR);
goto err;
}
for (i = 0; i < sk_X509_num(certs); i++) {
X509 *x = sk_X509_value(certs, i);
if (!CMS_add1_cert(cms, x))
goto merr;
}
if (!(flags & CMS_DETACHED))
CMS_set_detached(cms, 0);
if ((flags & (CMS_STREAM | CMS_PARTIAL))
|| CMS_final(cms, data, NULL, flags))
return cms;
else
goto err;
merr:
CMSerr(CMS_F_CMS_SIGN, ERR_R_MALLOC_FAILURE);
err:
CMS_ContentInfo_free(cms);
return NULL;
}
| 0
|
296,776
|
sendAssociationRQTCP(PRIVATE_NETWORKKEY ** /*network*/,
DUL_ASSOCIATESERVICEPARAMETERS * params,
PRIVATE_ASSOCIATIONKEY ** association)
{
PRV_ASSOCIATEPDU
associateRequest;
unsigned char
buffer[4096],
*b;
unsigned long
length;
int
nbytes;
OFBitmanipTemplate<char>::zeroMem((char *)&associateRequest, sizeof(PRV_ASSOCIATEPDU)); // initialize PDU
// associateRequest.presentationContextList = NULL;
OFCondition cond = constructAssociatePDU(params, DUL_TYPEASSOCIATERQ,
&associateRequest);
if (cond.bad())
{
DCMNET_ERROR(cond.text());
return cond;
}
if (associateRequest.length + 6 <= sizeof(buffer))
b = buffer;
else {
b = (unsigned char*)malloc(size_t(associateRequest.length + 6));
if (b == NULL) return EC_MemoryExhausted;
}
cond = streamAssociatePDU(&associateRequest, b,
associateRequest.length + 6, &length);
if ((*association)->associatePDUFlag)
{
// copy A-ASSOCIATE-RQ PDU
(*association)->associatePDU = new char[length];
if ((*association)->associatePDU)
{
memcpy((*association)->associatePDU, b, (size_t) length);
(*association)->associatePDULength = length;
}
}
destroyPresentationContextList(&associateRequest.presentationContextList);
destroyUserInformationLists(&associateRequest.userInfo);
if (cond.bad())
return cond;
do {
nbytes = (*association)->connection ? (*association)->connection->write((char*)b, size_t(associateRequest.length + 6)) : 0;
} while (nbytes == -1 && OFStandard::getLastNetworkErrorCode().value() == DCMNET_EINTR);
if ((unsigned long) nbytes != associateRequest.length + 6)
{
OFString msg = "TCP I/O Error (";
msg += OFStandard::getLastNetworkErrorCode().message();
msg += ") occurred in routine: sendAssociationRQTCP";
return makeDcmnetCondition(DULC_TCPIOERROR, OF_error, msg.c_str());
}
if (b != buffer) free(b);
return EC_Normal;
}
| 0
|
3,822
|
ast2obj_excepthandler(void* _o)
{
excepthandler_ty o = (excepthandler_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_INCREF(Py_None);
return Py_None;
}
switch (o->kind) {
case ExceptHandler_kind:
result = PyType_GenericNew(ExceptHandler_type, NULL, NULL);
if (!result) goto failed;
value = ast2obj_expr(o->v.ExceptHandler.type);
if (!value) goto failed;
if (_PyObject_SetAttrId(result, &PyId_type, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_identifier(o->v.ExceptHandler.name);
if (!value) goto failed;
if (_PyObject_SetAttrId(result, &PyId_name, value) == -1)
goto failed;
Py_DECREF(value);
value = ast2obj_list(o->v.ExceptHandler.body, ast2obj_stmt);
if (!value) goto failed;
if (_PyObject_SetAttrId(result, &PyId_body, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
value = ast2obj_int(o->lineno);
if (!value) goto failed;
if (_PyObject_SetAttrId(result, &PyId_lineno, value) < 0)
goto failed;
Py_DECREF(value);
value = ast2obj_int(o->col_offset);
if (!value) goto failed;
if (_PyObject_SetAttrId(result, &PyId_col_offset, value) < 0)
goto failed;
Py_DECREF(value);
return result;
failed:
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
| 1
|
186,344
|
void SyncManager::SyncInternal::EncryptDataTypes(
const syncable::ModelTypeSet& encrypted_types) {
DCHECK(initialized_);
VLOG(1) << "Attempting to encrypt datatypes "
<< syncable::ModelTypeSetToString(encrypted_types);
WriteTransaction trans(FROM_HERE, GetUserShare());
WriteNode node(&trans);
if (!node.InitByTagLookup(kNigoriTag)) {
NOTREACHED() << "Unable to set encrypted datatypes because Nigori node not "
<< "found.";
return;
}
Cryptographer* cryptographer = trans.GetCryptographer();
if (!cryptographer->is_ready()) {
VLOG(1) << "Attempting to encrypt datatypes when cryptographer not "
<< "initialized, prompting for passphrase.";
ObserverList<SyncManager::Observer> temp_obs_list;
CopyObservers(&temp_obs_list);
FOR_EACH_OBSERVER(SyncManager::Observer, temp_obs_list,
OnPassphraseRequired(sync_api::REASON_DECRYPTION));
return;
}
cryptographer->SetEncryptedTypes(encrypted_types);
sync_pb::NigoriSpecifics nigori;
nigori.CopyFrom(node.GetNigoriSpecifics());
cryptographer->UpdateNigoriFromEncryptedTypes(&nigori);
node.SetNigoriSpecifics(nigori);
allstatus_.SetEncryptedTypes(cryptographer->GetEncryptedTypes());
ReEncryptEverything(&trans);
return;
}
| 0
|
482,537
|
static LogEst whereRangeAdjust(WhereTerm *pTerm, LogEst nNew){
LogEst nRet = nNew;
if( pTerm ){
if( pTerm->truthProb<=0 ){
nRet += pTerm->truthProb;
}else if( (pTerm->wtFlags & TERM_VNULL)==0 ){
nRet -= 20; assert( 20==sqlite3LogEst(4) );
}
}
return nRet;
}
| 0
|
359,395
|
static void print_cifs_mount_version(void)
{
printf("mount.cifs version: %s.%s%s\n",
MOUNT_CIFS_VERSION_MAJOR,
MOUNT_CIFS_VERSION_MINOR,
MOUNT_CIFS_VENDOR_SUFFIX);
}
| 0
|
463,842
|
int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key,
struct btrfs_path *p, u64 time_seq)
{
struct btrfs_fs_info *fs_info = root->fs_info;
struct extent_buffer *b;
int slot;
int ret;
int err;
int level;
int lowest_unlock = 1;
u8 lowest_level = 0;
lowest_level = p->lowest_level;
WARN_ON(p->nodes[0] != NULL);
if (p->search_commit_root) {
BUG_ON(time_seq);
return btrfs_search_slot(NULL, root, key, p, 0, 0);
}
again:
b = get_old_root(root, time_seq);
if (!b) {
ret = -EIO;
goto done;
}
level = btrfs_header_level(b);
p->locks[level] = BTRFS_READ_LOCK;
while (b) {
int dec = 0;
level = btrfs_header_level(b);
p->nodes[level] = b;
/*
* we have a lock on b and as long as we aren't changing
* the tree, there is no way to for the items in b to change.
* It is safe to drop the lock on our parent before we
* go through the expensive btree search on b.
*/
btrfs_unlock_up_safe(p, level + 1);
ret = btrfs_bin_search(b, key, &slot);
if (ret < 0)
goto done;
if (level == 0) {
p->slots[level] = slot;
unlock_up(p, level, lowest_unlock, 0, NULL);
goto done;
}
if (ret && slot > 0) {
dec = 1;
slot--;
}
p->slots[level] = slot;
unlock_up(p, level, lowest_unlock, 0, NULL);
if (level == lowest_level) {
if (dec)
p->slots[level]++;
goto done;
}
err = read_block_for_search(root, p, &b, level, slot, key);
if (err == -EAGAIN)
goto again;
if (err) {
ret = err;
goto done;
}
level = btrfs_header_level(b);
btrfs_tree_read_lock(b);
b = tree_mod_log_rewind(fs_info, p, b, time_seq);
if (!b) {
ret = -ENOMEM;
goto done;
}
p->locks[level] = BTRFS_READ_LOCK;
p->nodes[level] = b;
}
ret = 1;
done:
if (ret < 0)
btrfs_release_path(p);
return ret;
}
| 0
|
442,315
|
size_t size () const
{
// string length + \0
size_t sizeBytes = _suffix.length() + 1;
// 1 byte for scheme / cscIdx / caseInsensitive, and 1 byte for type
sizeBytes += 2 * Xdr::size<char>();
return sizeBytes;
}
| 0
|
77,211
|
kdc_make_s4u2self_rep(krb5_context context,
krb5_keyblock *tgs_subkey,
krb5_keyblock *tgs_session,
krb5_pa_s4u_x509_user *req_s4u_user,
krb5_kdc_rep *reply,
krb5_enc_kdc_rep_part *reply_encpart)
{
krb5_error_code code;
krb5_data *der_user_id = NULL, *der_s4u_x509_user = NULL;
krb5_pa_s4u_x509_user rep_s4u_user;
krb5_pa_data *pa;
krb5_enctype enctype;
krb5_keyusage usage;
memset(&rep_s4u_user, 0, sizeof(rep_s4u_user));
rep_s4u_user.user_id.nonce = req_s4u_user->user_id.nonce;
rep_s4u_user.user_id.user = req_s4u_user->user_id.user;
rep_s4u_user.user_id.options =
req_s4u_user->user_id.options & KRB5_S4U_OPTS_USE_REPLY_KEY_USAGE;
code = encode_krb5_s4u_userid(&rep_s4u_user.user_id, &der_user_id);
if (code != 0)
goto cleanup;
if (req_s4u_user->user_id.options & KRB5_S4U_OPTS_USE_REPLY_KEY_USAGE)
usage = KRB5_KEYUSAGE_PA_S4U_X509_USER_REPLY;
else
usage = KRB5_KEYUSAGE_PA_S4U_X509_USER_REQUEST;
code = krb5_c_make_checksum(context, req_s4u_user->cksum.checksum_type,
tgs_subkey != NULL ? tgs_subkey : tgs_session,
usage, der_user_id, &rep_s4u_user.cksum);
if (code != 0)
goto cleanup;
code = encode_krb5_pa_s4u_x509_user(&rep_s4u_user, &der_s4u_x509_user);
if (code != 0)
goto cleanup;
/* Add a padata element, stealing memory from der_s4u_x509_user. */
code = alloc_pa_data(KRB5_PADATA_S4U_X509_USER, 0, &pa);
if (code != 0)
goto cleanup;
pa->length = der_s4u_x509_user->length;
pa->contents = (uint8_t *)der_s4u_x509_user->data;
der_s4u_x509_user->data = NULL;
/* add_pa_data_element() claims pa on success or failure. */
code = add_pa_data_element(&reply->padata, pa);
if (code != 0)
goto cleanup;
if (tgs_subkey != NULL)
enctype = tgs_subkey->enctype;
else
enctype = tgs_session->enctype;
/*
* Owing to a bug in Windows, unkeyed checksums were used for older
* enctypes, including rc4-hmac. A forthcoming workaround for this
* includes the checksum bytes in the encrypted padata.
*/
if ((req_s4u_user->user_id.options & KRB5_S4U_OPTS_USE_REPLY_KEY_USAGE) &&
enctype_requires_etype_info_2(enctype) == FALSE) {
code = alloc_pa_data(KRB5_PADATA_S4U_X509_USER,
req_s4u_user->cksum.length +
rep_s4u_user.cksum.length, &pa);
if (code != 0)
goto cleanup;
memcpy(pa->contents,
req_s4u_user->cksum.contents, req_s4u_user->cksum.length);
memcpy(&pa->contents[req_s4u_user->cksum.length],
rep_s4u_user.cksum.contents, rep_s4u_user.cksum.length);
/* add_pa_data_element() claims pa on success or failure. */
code = add_pa_data_element(&reply_encpart->enc_padata, pa);
if (code != 0)
goto cleanup;
}
cleanup:
if (rep_s4u_user.cksum.contents != NULL)
krb5_free_checksum_contents(context, &rep_s4u_user.cksum);
krb5_free_data(context, der_user_id);
krb5_free_data(context, der_s4u_x509_user);
return code;
}
| 0
|
299,311
|
static bool can_checksum_protocol(unsigned long features, __be16 protocol)
{
return ((features & NETIF_F_GEN_CSUM) ||
((features & NETIF_F_V4_CSUM) &&
protocol == htons(ETH_P_IP)) ||
((features & NETIF_F_V6_CSUM) &&
protocol == htons(ETH_P_IPV6)) ||
((features & NETIF_F_FCOE_CRC) &&
protocol == htons(ETH_P_FCOE)));
}
| 0
|
409,061
|
static void automount_shutdown(Manager *m) {
assert(m);
m->dev_autofs_fd = safe_close(m->dev_autofs_fd);
}
| 0
|
486,399
|
checkRequestAgainstDataset(
T_DIMSE_C_StoreRQ *req, /* original store request */
const char* fname, /* filename of dataset */
DcmDataset *dataSet, /* dataset to check */
T_DIMSE_C_StoreRSP *rsp, /* final store response */
OFBool opt_correctUIDPadding)
{
DcmFileFormat ff;
if (dataSet == NULL)
{
/* load the data from file */
if (ff.loadFile(fname).bad())
{
OFLOG_ERROR(dcmpsrcvLogger, "Cannot open file: " << fname);
rsp->DimseStatus = STATUS_STORE_Refused_OutOfResources;
return;
}
dataSet = ff.getDataset();
}
/* which SOP class and SOP instance ? */
DIC_UI sopClass;
DIC_UI sopInstance;
if (!DU_findSOPClassAndInstanceInDataSet(dataSet, sopClass, sopInstance, opt_correctUIDPadding))
{
OFLOG_ERROR(dcmpsrcvLogger, "Bad image file: " << fname);
rsp->DimseStatus = STATUS_STORE_Error_CannotUnderstand;
}
else if (strcmp(sopClass, req->AffectedSOPClassUID) != 0)
{
rsp->DimseStatus = STATUS_STORE_Error_DataSetDoesNotMatchSOPClass;
}
else if (strcmp(sopInstance, req->AffectedSOPInstanceUID) != 0)
{
rsp->DimseStatus = STATUS_STORE_Error_DataSetDoesNotMatchSOPClass;
}
else if (strcmp(sopClass, UID_GrayscaleSoftcopyPresentationStateStorage) == 0)
{
/* we have received a presentation state. Check if we can parse it! */
DcmPresentationState pstate;
if (EC_Normal != pstate.read(*dataSet))
{
OFLOG_ERROR(dcmpsrcvLogger, "Grayscale softcopy presentation state object cannot be displayed - rejected");
rsp->DimseStatus = STATUS_STORE_Error_CannotUnderstand;
}
}
return;
}
| 0
|
198,255
|
WebContents* BrowserView::GetActiveWebContents() const {
return browser_->tab_strip_model()->GetActiveWebContents();
}
| 0
|
327,611
|
static void mcf5208evb_init(MachineState *machine)
{
ram_addr_t ram_size = machine->ram_size;
const char *cpu_model = machine->cpu_model;
const char *kernel_filename = machine->kernel_filename;
M68kCPU *cpu;
CPUM68KState *env;
int kernel_size;
uint64_t elf_entry;
hwaddr entry;
qemu_irq *pic;
MemoryRegion *address_space_mem = get_system_memory();
MemoryRegion *ram = g_new(MemoryRegion, 1);
MemoryRegion *sram = g_new(MemoryRegion, 1);
if (!cpu_model) {
cpu_model = "m5208";
}
cpu = M68K_CPU(cpu_generic_init(TYPE_M68K_CPU, cpu_model));
env = &cpu->env;
/* Initialize CPU registers. */
env->vbr = 0;
/* TODO: Configure BARs. */
/* DRAM at 0x40000000 */
memory_region_allocate_system_memory(ram, NULL, "mcf5208.ram", ram_size);
memory_region_add_subregion(address_space_mem, 0x40000000, ram);
/* Internal SRAM. */
memory_region_init_ram(sram, NULL, "mcf5208.sram", 16384, &error_fatal);
memory_region_add_subregion(address_space_mem, 0x80000000, sram);
/* Internal peripherals. */
pic = mcf_intc_init(address_space_mem, 0xfc048000, cpu);
mcf_uart_mm_init(0xfc060000, pic[26], serial_hds[0]);
mcf_uart_mm_init(0xfc064000, pic[27], serial_hds[1]);
mcf_uart_mm_init(0xfc068000, pic[28], serial_hds[2]);
mcf5208_sys_init(address_space_mem, pic);
if (nb_nics > 1) {
fprintf(stderr, "Too many NICs\n");
exit(1);
}
if (nd_table[0].used) {
mcf_fec_init(address_space_mem, &nd_table[0],
0xfc030000, pic + 36);
}
/* 0xfc000000 SCM. */
/* 0xfc004000 XBS. */
/* 0xfc008000 FlexBus CS. */
/* 0xfc030000 FEC. */
/* 0xfc040000 SCM + Power management. */
/* 0xfc044000 eDMA. */
/* 0xfc048000 INTC. */
/* 0xfc058000 I2C. */
/* 0xfc05c000 QSPI. */
/* 0xfc060000 UART0. */
/* 0xfc064000 UART0. */
/* 0xfc068000 UART0. */
/* 0xfc070000 DMA timers. */
/* 0xfc080000 PIT0. */
/* 0xfc084000 PIT1. */
/* 0xfc088000 EPORT. */
/* 0xfc08c000 Watchdog. */
/* 0xfc090000 clock module. */
/* 0xfc0a0000 CCM + reset. */
/* 0xfc0a4000 GPIO. */
/* 0xfc0a8000 SDRAM controller. */
/* Load kernel. */
if (!kernel_filename) {
if (qtest_enabled()) {
return;
}
fprintf(stderr, "Kernel image must be specified\n");
exit(1);
}
kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
NULL, NULL, 1, EM_68K, 0, 0);
entry = elf_entry;
if (kernel_size < 0) {
kernel_size = load_uimage(kernel_filename, &entry, NULL, NULL,
NULL, NULL);
}
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename, 0x40000000,
ram_size);
entry = 0x40000000;
}
if (kernel_size < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n", kernel_filename);
exit(1);
}
env->pc = entry;
}
| 0
|
13,287
|
find_insert(png_const_charp what, png_charp param)
{
png_uint_32 chunk = 0;
png_charp parameter_list[1024];
int i, nparams;
/* Assemble the chunk name */
for (i=0; i<4; ++i)
{
char ch = what[i];
if ((ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122))
chunk = (chunk << 8) + what[i];
else
break;
}
if (i < 4 || what[4] != 0)
{
fprintf(stderr, "makepng --insert \"%s\": invalid chunk name\n", what);
exit(1);
}
/* Assemble the parameter list. */
nparams = find_parameters(what, param, parameter_list, 1024);
# define CHUNK(a,b,c,d) (((a)<<24)+((b)<<16)+((c)<<8)+(d))
switch (chunk)
{
case CHUNK(105,67,67,80): /* iCCP */
if (nparams == 2)
return make_insert(what, insert_iCCP, nparams, parameter_list);
break;
case CHUNK(116,69,88,116): /* tEXt */
if (nparams == 2)
return make_insert(what, insert_tEXt, nparams, parameter_list);
break;
case CHUNK(122,84,88,116): /* zTXt */
if (nparams == 2)
return make_insert(what, insert_zTXt, nparams, parameter_list);
break;
case CHUNK(105,84,88,116): /* iTXt */
if (nparams == 4)
return make_insert(what, insert_iTXt, nparams, parameter_list);
break;
case CHUNK(104,73,83,84): /* hIST */
if (nparams <= 256)
return make_insert(what, insert_hIST, nparams, parameter_list);
break;
#if 0
case CHUNK(115,80,76,84): /* sPLT */
return make_insert(what, insert_sPLT, nparams, parameter_list);
#endif
default:
fprintf(stderr, "makepng --insert \"%s\": unrecognized chunk name\n",
what);
exit(1);
}
bad_parameter_count(what, nparams);
return NULL;
}
| 1
|
386,220
|
xsltVariableComp(xsltStylesheetPtr style, xmlNodePtr inst) {
#ifdef XSLT_REFACTORED
xsltStyleItemVariablePtr comp;
#else
xsltStylePreCompPtr comp;
#endif
if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
return;
#ifdef XSLT_REFACTORED
comp = (xsltStyleItemVariablePtr)
xsltNewStylePreComp(style, XSLT_FUNC_VARIABLE);
#else
comp = xsltNewStylePreComp(style, XSLT_FUNC_VARIABLE);
#endif
if (comp == NULL)
return;
inst->psvi = comp;
comp->inst = inst;
/*
* The full template resolution can be done statically
*/
/*
* Attribute "name".
*/
xsltGetQNameProperty(style, inst, BAD_CAST "name",
1, &(comp->has_name), &(comp->ns), &(comp->name));
if (comp->ns)
comp->has_ns = 1;
/*
* Attribute "select".
*/
comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
XSLT_NAMESPACE);
if (comp->select != NULL) {
#ifndef XSLT_REFACTORED
xmlNodePtr cur;
#endif
comp->comp = xsltXPathCompile(style, comp->select);
if (comp->comp == NULL) {
xsltTransformError(NULL, style, inst,
"XSLT-variable: Failed to compile the XPath expression '%s'.\n",
comp->select);
style->errors++;
}
#ifdef XSLT_REFACTORED
if (inst->children != NULL) {
xsltTransformError(NULL, style, inst,
"XSLT-variable: There must be no child nodes, since the "
"attribute 'select' was specified.\n");
style->errors++;
}
#else
for (cur = inst->children; cur != NULL; cur = cur->next) {
if (cur->type != XML_COMMENT_NODE &&
(cur->type != XML_TEXT_NODE || !xsltIsBlank(cur->content)))
{
xsltTransformError(NULL, style, inst,
"XSLT-variable: There must be no child nodes, since the "
"attribute 'select' was specified.\n");
style->errors++;
}
}
#endif
}
}
| 0
|
407,079
|
static CURLcode imap_state_fetch_resp(struct connectdata *conn, int imapcode,
imapstate instate)
{
CURLcode result = CURLE_OK;
struct Curl_easy *data = conn->data;
struct imap_conn *imapc = &conn->proto.imapc;
struct pingpong *pp = &imapc->pp;
const char *ptr = data->state.buffer;
bool parsed = FALSE;
curl_off_t size = 0;
(void)instate; /* no use for this yet */
if(imapcode != '*') {
Curl_pgrsSetDownloadSize(data, -1);
state(conn, IMAP_STOP);
return CURLE_REMOTE_FILE_NOT_FOUND; /* TODO: Fix error code */
}
/* Something like this is received "* 1 FETCH (BODY[TEXT] {2021}\r" so parse
the continuation data contained within the curly brackets */
while(*ptr && (*ptr != '{'))
ptr++;
if(*ptr == '{') {
char *endptr;
if(!curlx_strtoofft(ptr + 1, &endptr, 10, &size)) {
if(endptr - ptr > 1 && endptr[0] == '}' &&
endptr[1] == '\r' && endptr[2] == '\0')
parsed = TRUE;
}
}
if(parsed) {
infof(data, "Found %" CURL_FORMAT_CURL_OFF_TU " bytes to download\n",
size);
Curl_pgrsSetDownloadSize(data, size);
if(pp->cache) {
/* At this point there is a bunch of data in the header "cache" that is
actually body content, send it as body and then skip it. Do note
that there may even be additional "headers" after the body. */
size_t chunk = pp->cache_size;
if(chunk > (size_t)size)
/* The conversion from curl_off_t to size_t is always fine here */
chunk = (size_t)size;
if(!chunk) {
/* no size, we're done with the data */
state(conn, IMAP_STOP);
return CURLE_OK;
}
result = Curl_client_write(conn, CLIENTWRITE_BODY, pp->cache, chunk);
if(result)
return result;
data->req.bytecount += chunk;
infof(data, "Written %" CURL_FORMAT_CURL_OFF_TU
" bytes, %" CURL_FORMAT_CURL_OFF_TU
" bytes are left for transfer\n", (curl_off_t)chunk,
size - chunk);
/* Have we used the entire cache or just part of it?*/
if(pp->cache_size > chunk) {
/* Only part of it so shrink the cache to fit the trailing data */
memmove(pp->cache, pp->cache + chunk, pp->cache_size - chunk);
pp->cache_size -= chunk;
}
else {
/* Free the cache */
Curl_safefree(pp->cache);
/* Reset the cache size */
pp->cache_size = 0;
}
}
if(data->req.bytecount == size)
/* The entire data is already transferred! */
Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
else {
/* IMAP download */
data->req.maxdownload = size;
Curl_setup_transfer(conn, FIRSTSOCKET, size, FALSE, NULL, -1, NULL);
}
}
else {
/* We don't know how to parse this line */
failf(pp->conn->data, "Failed to parse FETCH response.");
result = CURLE_WEIRD_SERVER_REPLY;
}
/* End of DO phase */
state(conn, IMAP_STOP);
return result;
}
| 0
|
49,718
|
static void analPathFollow(RCoreAnalPaths *p, ut64 addr, PJ *pj) {
if (addr == UT64_MAX) {
return;
}
if (!dict_get (&p->visited, addr)) {
p->cur = r_anal_bb_from_offset (p->core->anal, addr);
analPaths (p, pj);
}
}
| 0
|
227,394
|
Ins_CLEAR( TT_ExecContext exc )
{
exc->new_top = 0;
}
| 0
|
196,396
|
void LauncherView::UpdateFirstButtonPadding() {
if (view_model_->view_size() > 0) {
view_model_->view_at(0)->set_border(views::Border::CreateEmptyBorder(
primary_axis_coordinate(0, leading_inset()),
primary_axis_coordinate(leading_inset(), 0),
0,
0));
}
}
| 0
|
190,181
|
void RootWindowHostLinux::ReleaseCapture() {
}
| 0
|
298,020
|
template<typename t>
CImg<T>& _LU(CImg<t>& indx, bool& d) {
const int N = width();
int imax = 0;
CImg<Tfloat> vv(N);
indx.assign(N);
d = true;
bool return0 = false;
cimg_pragma_openmp(parallel for cimg_openmp_if(_width*_height>=512))
cimg_forX(*this,i) {
Tfloat vmax = 0;
cimg_forX(*this,j) {
const Tfloat tmp = cimg::abs((*this)(j,i));
if (tmp>vmax) vmax = tmp;
}
if (vmax==0) return0 = true; else vv[i] = 1/vmax;
}
if (return0) { indx.fill(0); return fill(0); }
cimg_forX(*this,j) {
for (int i = 0; i<j; ++i) {
Tfloat sum = (*this)(j,i);
for (int k = 0; k<i; ++k) sum-=(*this)(k,i)*(*this)(j,k);
(*this)(j,i) = (T)sum;
}
Tfloat vmax = 0;
for (int i = j; i<width(); ++i) {
Tfloat sum = (*this)(j,i);
for (int k = 0; k<j; ++k) sum-=(*this)(k,i)*(*this)(j,k);
(*this)(j,i) = (T)sum;
const Tfloat tmp = vv[i]*cimg::abs(sum);
if (tmp>=vmax) { vmax = tmp; imax = i; }
}
if (j!=imax) {
cimg_forX(*this,k) cimg::swap((*this)(k,imax),(*this)(k,j));
d = !d;
vv[imax] = vv[j];
}
indx[j] = (t)imax;
if ((*this)(j,j)==0) (*this)(j,j) = (T)1e-20;
if (j<N) {
const Tfloat tmp = 1/(Tfloat)(*this)(j,j);
for (int i = j + 1; i<N; ++i) (*this)(j,i) = (T)((*this)(j,i)*tmp);
}
}
return *this;
| 0
|
406,557
|
Item_static_float_func(const char *str, double val_arg, uint decimal_par,
uint length)
:Item_float(NullS, val_arg, decimal_par, length), func_name(str)
{}
| 0
|
69,801
|
packet_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
{
struct sock *sk = sock->sk;
struct packet_sock *po = pkt_sk(sk);
int ret;
if (level != SOL_PACKET)
return -ENOPROTOOPT;
switch (optname) {
case PACKET_ADD_MEMBERSHIP:
case PACKET_DROP_MEMBERSHIP:
{
struct packet_mreq_max mreq;
int len = optlen;
memset(&mreq, 0, sizeof(mreq));
if (len < sizeof(struct packet_mreq))
return -EINVAL;
if (len > sizeof(mreq))
len = sizeof(mreq);
if (copy_from_user(&mreq, optval, len))
return -EFAULT;
if (len < (mreq.mr_alen + offsetof(struct packet_mreq, mr_address)))
return -EINVAL;
if (optname == PACKET_ADD_MEMBERSHIP)
ret = packet_mc_add(sk, &mreq);
else
ret = packet_mc_drop(sk, &mreq);
return ret;
}
case PACKET_RX_RING:
case PACKET_TX_RING:
{
struct tpacket_req req;
if (optlen < sizeof(req))
return -EINVAL;
if (pkt_sk(sk)->has_vnet_hdr)
return -EINVAL;
if (copy_from_user(&req, optval, sizeof(req)))
return -EFAULT;
return packet_set_ring(sk, &req, 0, optname == PACKET_TX_RING);
}
case PACKET_COPY_THRESH:
{
int val;
if (optlen != sizeof(val))
return -EINVAL;
if (copy_from_user(&val, optval, sizeof(val)))
return -EFAULT;
pkt_sk(sk)->copy_thresh = val;
return 0;
}
case PACKET_VERSION:
{
int val;
if (optlen != sizeof(val))
return -EINVAL;
if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
return -EBUSY;
if (copy_from_user(&val, optval, sizeof(val)))
return -EFAULT;
switch (val) {
case TPACKET_V1:
case TPACKET_V2:
po->tp_version = val;
return 0;
default:
return -EINVAL;
}
}
case PACKET_RESERVE:
{
unsigned int val;
if (optlen != sizeof(val))
return -EINVAL;
if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
return -EBUSY;
if (copy_from_user(&val, optval, sizeof(val)))
return -EFAULT;
po->tp_reserve = val;
return 0;
}
case PACKET_LOSS:
{
unsigned int val;
if (optlen != sizeof(val))
return -EINVAL;
if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
return -EBUSY;
if (copy_from_user(&val, optval, sizeof(val)))
return -EFAULT;
po->tp_loss = !!val;
return 0;
}
case PACKET_AUXDATA:
{
int val;
if (optlen < sizeof(val))
return -EINVAL;
if (copy_from_user(&val, optval, sizeof(val)))
return -EFAULT;
po->auxdata = !!val;
return 0;
}
case PACKET_ORIGDEV:
{
int val;
if (optlen < sizeof(val))
return -EINVAL;
if (copy_from_user(&val, optval, sizeof(val)))
return -EFAULT;
po->origdev = !!val;
return 0;
}
case PACKET_VNET_HDR:
{
int val;
if (sock->type != SOCK_RAW)
return -EINVAL;
if (po->rx_ring.pg_vec || po->tx_ring.pg_vec)
return -EBUSY;
if (optlen < sizeof(val))
return -EINVAL;
if (copy_from_user(&val, optval, sizeof(val)))
return -EFAULT;
po->has_vnet_hdr = !!val;
return 0;
}
case PACKET_TIMESTAMP:
{
int val;
if (optlen != sizeof(val))
return -EINVAL;
if (copy_from_user(&val, optval, sizeof(val)))
return -EFAULT;
po->tp_tstamp = val;
return 0;
}
default:
return -ENOPROTOOPT;
}
}
| 0
|
321,685
|
static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
{
CharDriverState *chr;
PtyCharDriver *s;
struct termios tty;
const char *label;
int master_fd, slave_fd, len;
#if defined(__OpenBSD__) || defined(__DragonFly__)
char pty_name[PATH_MAX];
#define q_ptsname(x) pty_name
#else
char *pty_name = NULL;
#define q_ptsname(x) ptsname(x)
#endif
if (openpty(&master_fd, &slave_fd, pty_name, NULL, NULL) < 0) {
return NULL;
}
/* Set raw attributes on the pty. */
tcgetattr(slave_fd, &tty);
cfmakeraw(&tty);
tcsetattr(slave_fd, TCSAFLUSH, &tty);
close(slave_fd);
chr = g_malloc0(sizeof(CharDriverState));
len = strlen(q_ptsname(master_fd)) + 5;
chr->filename = g_malloc(len);
snprintf(chr->filename, len, "pty:%s", q_ptsname(master_fd));
qemu_opt_set(opts, "path", q_ptsname(master_fd));
label = qemu_opts_id(opts);
fprintf(stderr, "char device redirected to %s%s%s%s\n",
q_ptsname(master_fd),
label ? " (label " : "",
label ? label : "",
label ? ")" : "");
s = g_malloc0(sizeof(PtyCharDriver));
chr->opaque = s;
chr->chr_write = pty_chr_write;
chr->chr_update_read_handler = pty_chr_update_read_handler;
chr->chr_close = pty_chr_close;
chr->chr_add_watch = pty_chr_add_watch;
s->fd = io_channel_from_fd(master_fd);
s->timer_tag = 0;
return chr;
}
| 0
|
69,236
|
static int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
{
DECLARE_WAITQUEUE(wait, current);
struct sock *sk = sock->sk, *nsk;
long timeo;
int err = 0;
lock_sock(sk);
if (sk->sk_type != SOCK_STREAM) {
err = -EINVAL;
goto done;
}
timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
BT_DBG("sk %p timeo %ld", sk, timeo);
/* Wait for an incoming connection. (wake-one). */
add_wait_queue_exclusive(sk_sleep(sk), &wait);
while (1) {
set_current_state(TASK_INTERRUPTIBLE);
if (sk->sk_state != BT_LISTEN) {
err = -EBADFD;
break;
}
nsk = bt_accept_dequeue(sk, newsock);
if (nsk)
break;
if (!timeo) {
err = -EAGAIN;
break;
}
if (signal_pending(current)) {
err = sock_intr_errno(timeo);
break;
}
release_sock(sk);
timeo = schedule_timeout(timeo);
lock_sock(sk);
}
__set_current_state(TASK_RUNNING);
remove_wait_queue(sk_sleep(sk), &wait);
if (err)
goto done;
newsock->state = SS_CONNECTED;
BT_DBG("new socket %p", nsk);
done:
release_sock(sk);
return err;
}
| 0
|
210,758
|
void mwifiex_uap_set_channel(struct mwifiex_private *priv,
struct mwifiex_uap_bss_param *bss_cfg,
struct cfg80211_chan_def chandef)
{
u8 config_bands = 0, old_bands = priv->adapter->config_bands;
priv->bss_chandef = chandef;
bss_cfg->channel = ieee80211_frequency_to_channel(
chandef.chan->center_freq);
/* Set appropriate bands */
if (chandef.chan->band == NL80211_BAND_2GHZ) {
bss_cfg->band_cfg = BAND_CONFIG_BG;
config_bands = BAND_B | BAND_G;
if (chandef.width > NL80211_CHAN_WIDTH_20_NOHT)
config_bands |= BAND_GN;
} else {
bss_cfg->band_cfg = BAND_CONFIG_A;
config_bands = BAND_A;
if (chandef.width > NL80211_CHAN_WIDTH_20_NOHT)
config_bands |= BAND_AN;
if (chandef.width > NL80211_CHAN_WIDTH_40)
config_bands |= BAND_AAC;
}
switch (chandef.width) {
case NL80211_CHAN_WIDTH_5:
case NL80211_CHAN_WIDTH_10:
case NL80211_CHAN_WIDTH_20_NOHT:
case NL80211_CHAN_WIDTH_20:
break;
case NL80211_CHAN_WIDTH_40:
if (chandef.center_freq1 < chandef.chan->center_freq)
bss_cfg->band_cfg |= MWIFIEX_SEC_CHAN_BELOW;
else
bss_cfg->band_cfg |= MWIFIEX_SEC_CHAN_ABOVE;
break;
case NL80211_CHAN_WIDTH_80:
case NL80211_CHAN_WIDTH_80P80:
case NL80211_CHAN_WIDTH_160:
bss_cfg->band_cfg |=
mwifiex_get_sec_chan_offset(bss_cfg->channel) << 4;
break;
default:
mwifiex_dbg(priv->adapter,
WARN, "Unknown channel width: %d\n",
chandef.width);
break;
}
priv->adapter->config_bands = config_bands;
if (old_bands != config_bands) {
mwifiex_send_domain_info_cmd_fw(priv->adapter->wiphy);
mwifiex_dnld_txpwr_table(priv);
}
}
| 0
|
141,007
|
static bool regsafe(struct bpf_reg_state *rold, struct bpf_reg_state *rcur,
struct idpair *idmap)
{
bool equal;
if (!(rold->live & REG_LIVE_READ))
/* explored state didn't use this */
return true;
equal = memcmp(rold, rcur, offsetof(struct bpf_reg_state, frameno)) == 0;
if (rold->type == PTR_TO_STACK)
/* two stack pointers are equal only if they're pointing to
* the same stack frame, since fp-8 in foo != fp-8 in bar
*/
return equal && rold->frameno == rcur->frameno;
if (equal)
return true;
if (rold->type == NOT_INIT)
/* explored state can't have used this */
return true;
if (rcur->type == NOT_INIT)
return false;
switch (rold->type) {
case SCALAR_VALUE:
if (rcur->type == SCALAR_VALUE) {
/* new val must satisfy old val knowledge */
return range_within(rold, rcur) &&
tnum_in(rold->var_off, rcur->var_off);
} else {
/* We're trying to use a pointer in place of a scalar.
* Even if the scalar was unbounded, this could lead to
* pointer leaks because scalars are allowed to leak
* while pointers are not. We could make this safe in
* special cases if root is calling us, but it's
* probably not worth the hassle.
*/
return false;
}
case PTR_TO_MAP_VALUE:
/* If the new min/max/var_off satisfy the old ones and
* everything else matches, we are OK.
* We don't care about the 'id' value, because nothing
* uses it for PTR_TO_MAP_VALUE (only for ..._OR_NULL)
*/
return memcmp(rold, rcur, offsetof(struct bpf_reg_state, id)) == 0 &&
range_within(rold, rcur) &&
tnum_in(rold->var_off, rcur->var_off);
case PTR_TO_MAP_VALUE_OR_NULL:
/* a PTR_TO_MAP_VALUE could be safe to use as a
* PTR_TO_MAP_VALUE_OR_NULL into the same map.
* However, if the old PTR_TO_MAP_VALUE_OR_NULL then got NULL-
* checked, doing so could have affected others with the same
* id, and we can't check for that because we lost the id when
* we converted to a PTR_TO_MAP_VALUE.
*/
if (rcur->type != PTR_TO_MAP_VALUE_OR_NULL)
return false;
if (memcmp(rold, rcur, offsetof(struct bpf_reg_state, id)))
return false;
/* Check our ids match any regs they're supposed to */
return check_ids(rold->id, rcur->id, idmap);
case PTR_TO_PACKET_META:
case PTR_TO_PACKET:
if (rcur->type != rold->type)
return false;
/* We must have at least as much range as the old ptr
* did, so that any accesses which were safe before are
* still safe. This is true even if old range < old off,
* since someone could have accessed through (ptr - k), or
* even done ptr -= k in a register, to get a safe access.
*/
if (rold->range > rcur->range)
return false;
/* If the offsets don't match, we can't trust our alignment;
* nor can we be sure that we won't fall out of range.
*/
if (rold->off != rcur->off)
return false;
/* id relations must be preserved */
if (rold->id && !check_ids(rold->id, rcur->id, idmap))
return false;
/* new val must satisfy old val knowledge */
return range_within(rold, rcur) &&
tnum_in(rold->var_off, rcur->var_off);
case PTR_TO_CTX:
case CONST_PTR_TO_MAP:
case PTR_TO_PACKET_END:
/* Only valid matches are exact, which memcmp() above
* would have accepted
*/
default:
/* Don't know what's going on, just say it's not safe */
return false;
}
/* Shouldn't get here; if we do, say it's not safe */
WARN_ON_ONCE(1);
return false;
}
| 0
|
357,115
|
void sctp_assoc_sync_pmtu(struct sctp_association *asoc)
{
struct sctp_transport *t;
__u32 pmtu = 0;
if (!asoc)
return;
/* Get the lowest pmtu of all the transports. */
list_for_each_entry(t, &asoc->peer.transport_addr_list,
transports) {
if (t->pmtu_pending && t->dst) {
sctp_transport_update_pmtu(t, dst_mtu(t->dst));
t->pmtu_pending = 0;
}
if (!pmtu || (t->pathmtu < pmtu))
pmtu = t->pathmtu;
}
if (pmtu) {
struct sctp_sock *sp = sctp_sk(asoc->base.sk);
asoc->pathmtu = pmtu;
asoc->frag_point = sctp_frag_point(sp, pmtu);
}
SCTP_DEBUG_PRINTK("%s: asoc:%p, pmtu:%d, frag_point:%d\n",
__func__, asoc, asoc->pathmtu, asoc->frag_point);
}
| 0
|
185,929
|
static void coroutine_fn v9fs_readdir(void *opaque)
{
int32_t fid;
V9fsFidState *fidp;
ssize_t retval = 0;
size_t offset = 7;
uint64_t initial_offset;
int32_t count;
uint32_t max_count;
V9fsPDU *pdu = opaque;
retval = pdu_unmarshal(pdu, offset, "dqd", &fid,
&initial_offset, &max_count);
if (retval < 0) {
goto out_nofid;
}
trace_v9fs_readdir(pdu->tag, pdu->id, fid, initial_offset, max_count);
fidp = get_fid(pdu, fid);
if (fidp == NULL) {
retval = -EINVAL;
goto out_nofid;
}
if (!fidp->fs.dir.stream) {
retval = -EINVAL;
goto out;
}
if (initial_offset == 0) {
v9fs_co_rewinddir(pdu, fidp);
} else {
v9fs_co_seekdir(pdu, fidp, initial_offset);
}
count = v9fs_do_readdir(pdu, fidp, max_count);
if (count < 0) {
retval = count;
goto out;
}
retval = pdu_marshal(pdu, offset, "d", count);
if (retval < 0) {
goto out;
}
retval += count + offset;
trace_v9fs_readdir_return(pdu->tag, pdu->id, count, retval);
out:
put_fid(pdu, fidp);
out_nofid:
pdu_complete(pdu, retval);
}
| 0
|
433,815
|
point_resize (mpi_point_t p, mpi_ec_t ctx)
{
size_t nlimbs = ctx->p->nlimbs;
mpi_resize (p->x, nlimbs);
p->x->nlimbs = nlimbs;
mpi_resize (p->z, nlimbs);
p->z->nlimbs = nlimbs;
if (ctx->model != MPI_EC_MONTGOMERY)
{
mpi_resize (p->y, nlimbs);
p->y->nlimbs = nlimbs;
}
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.