idx
int64 | func
string | target
int64 |
|---|---|---|
178,585
|
nfs3svc_encode_readdirres(struct svc_rqst *rqstp, __be32 *p,
struct nfsd3_readdirres *resp)
{
p = encode_post_op_attr(rqstp, p, &resp->fh);
if (resp->status == 0) {
/* stupid readdir cookie */
memcpy(p, resp->verf, 8); p += 2;
xdr_ressize_check(rqstp, p);
if (rqstp->rq_res.head[0].iov_len + (2<<2) > PAGE_SIZE)
return 1; /*No room for trailer */
rqstp->rq_res.page_len = (resp->count) << 2;
/* add the 'tail' to the end of the 'head' page - page 0. */
rqstp->rq_res.tail[0].iov_base = p;
*p++ = 0; /* no more entries */
*p++ = htonl(resp->common.err == nfserr_eof);
rqstp->rq_res.tail[0].iov_len = 2<<2;
return 1;
} else
return xdr_ressize_check(rqstp, p);
}
| 0
|
474,683
|
void addClusterMonitorPrivileges(PrivilegeVector* privileges) {
Privilege::addPrivilegeToPrivilegeVector(
privileges,
Privilege(ResourcePattern::forClusterResource(), clusterMonitorRoleClusterActions));
Privilege::addPrivilegeToPrivilegeVector(
privileges,
Privilege(ResourcePattern::forAnyNormalResource(), clusterMonitorRoleDatabaseActions));
Privilege::addPrivilegeToPrivilegeVector(
privileges,
Privilege(ResourcePattern::forDatabaseName("config"), clusterMonitorRoleDatabaseActions));
Privilege::addPrivilegeToPrivilegeVector(
privileges,
Privilege(ResourcePattern::forDatabaseName("local"), clusterMonitorRoleDatabaseActions));
addReadOnlyDbPrivileges(privileges, "config");
addReadOnlyDbPrivileges(privileges, "local");
Privilege::addPrivilegeToPrivilegeVector(
privileges,
Privilege(ResourcePattern::forExactNamespace(NamespaceString("local", "system.replset")),
ActionType::find));
Privilege::addPrivilegeToPrivilegeVector(
privileges,
Privilege(ResourcePattern::forExactNamespace(NamespaceString("local", "replset.election")),
ActionType::find));
Privilege::addPrivilegeToPrivilegeVector(
privileges,
Privilege(ResourcePattern::forExactNamespace(NamespaceString("local", "replset.minvalid")),
ActionType::find));
Privilege::addPrivilegeToPrivilegeVector(
privileges,
Privilege(ResourcePattern::forCollectionName("system.profile"), ActionType::find));
}
| 0
|
296,201
|
RandomCancelKey(int32 *cancel_key)
{
return pg_strong_random(cancel_key, sizeof(int32));
}
| 0
|
417,843
|
static curl_off_t vms_realfilesize(const char * name,
const struct_stat * stat_buf)
{
char buffer[8192];
curl_off_t count;
int ret_stat;
FILE * file;
file = fopen(name, "r"); /* VMS */
if(file == NULL) {
return 0;
}
count = 0;
ret_stat = 1;
while(ret_stat > 0) {
ret_stat = fread(buffer, 1, sizeof(buffer), file);
if(ret_stat != 0)
count += ret_stat;
}
fclose(file);
return count;
}
| 0
|
496,583
|
void DataWriterImpl::disable()
{
set_listener(nullptr);
if (writer_ != nullptr)
{
writer_->set_listener(nullptr);
}
}
| 0
|
510,758
|
auth_server_input_mech(struct auth_server_connection *conn,
const char *const *args)
{
struct auth_mech_desc mech_desc;
if (conn->handshake_received) {
i_error("BUG: Authentication server already sent handshake");
return -1;
}
if (args[0] == NULL) {
i_error("BUG: Authentication server sent broken MECH line");
return -1;
}
i_zero(&mech_desc);
mech_desc.name = p_strdup(conn->pool, args[0]);
if (strcmp(mech_desc.name, "PLAIN") == 0)
conn->has_plain_mech = TRUE;
for (args++; *args != NULL; args++) {
if (strcmp(*args, "private") == 0)
mech_desc.flags |= MECH_SEC_PRIVATE;
else if (strcmp(*args, "anonymous") == 0)
mech_desc.flags |= MECH_SEC_ANONYMOUS;
else if (strcmp(*args, "plaintext") == 0)
mech_desc.flags |= MECH_SEC_PLAINTEXT;
else if (strcmp(*args, "dictionary") == 0)
mech_desc.flags |= MECH_SEC_DICTIONARY;
else if (strcmp(*args, "active") == 0)
mech_desc.flags |= MECH_SEC_ACTIVE;
else if (strcmp(*args, "forward-secrecy") == 0)
mech_desc.flags |= MECH_SEC_FORWARD_SECRECY;
else if (strcmp(*args, "mutual-auth") == 0)
mech_desc.flags |= MECH_SEC_MUTUAL_AUTH;
}
array_append(&conn->available_auth_mechs, &mech_desc, 1);
return 0;
}
| 0
|
68,820
|
archive_read_support_format_mtree(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct mtree *mtree;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_mtree");
mtree = (struct mtree *)malloc(sizeof(*mtree));
if (mtree == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate mtree data");
return (ARCHIVE_FATAL);
}
memset(mtree, 0, sizeof(*mtree));
mtree->fd = -1;
r = __archive_read_register_format(a, mtree, "mtree",
mtree_bid, archive_read_format_mtree_options, read_header, read_data, skip, NULL, cleanup, NULL, NULL);
if (r != ARCHIVE_OK)
free(mtree);
return (ARCHIVE_OK);
}
| 0
|
33,208
|
void install_exec_creds(struct linux_binprm *bprm)
{
security_bprm_committing_creds(bprm);
commit_creds(bprm->cred);
bprm->cred = NULL;
/*
* cred_guard_mutex must be held at least to this point to prevent
* ptrace_attach() from altering our determination of the task's
* credentials; any time after this it may be unlocked.
*/
security_bprm_committed_creds(bprm);
mutex_unlock(¤t->signal->cred_guard_mutex);
}
| 0
|
113,679
|
GF_Err mvhd_Read(GF_Box *s, GF_BitStream *bs)
{
GF_MovieHeaderBox *ptr = (GF_MovieHeaderBox *)s;
if (ptr == NULL) return GF_BAD_PARAM;
if (ptr->version == 1) {
ptr->creationTime = gf_bs_read_u64(bs);
ptr->modificationTime = gf_bs_read_u64(bs);
ptr->timeScale = gf_bs_read_u32(bs);
ptr->duration = gf_bs_read_u64(bs);
} else {
ptr->creationTime = gf_bs_read_u32(bs);
ptr->modificationTime = gf_bs_read_u32(bs);
ptr->timeScale = gf_bs_read_u32(bs);
ptr->duration = gf_bs_read_u32(bs);
}
if (!ptr->timeScale) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] Movie header timescale is invalid (0) - defaulting to 600\n" ));
ptr->timeScale = 600;
}
ptr->preferredRate = gf_bs_read_u32(bs);
ptr->preferredVolume = gf_bs_read_u16(bs);
gf_bs_read_data(bs, ptr->reserved, 10);
ptr->matrixA = gf_bs_read_u32(bs);
ptr->matrixB = gf_bs_read_u32(bs);
ptr->matrixU = gf_bs_read_u32(bs);
ptr->matrixC = gf_bs_read_u32(bs);
ptr->matrixD = gf_bs_read_u32(bs);
ptr->matrixV = gf_bs_read_u32(bs);
ptr->matrixX = gf_bs_read_u32(bs);
ptr->matrixY = gf_bs_read_u32(bs);
ptr->matrixW = gf_bs_read_u32(bs);
ptr->previewTime = gf_bs_read_u32(bs);
ptr->previewDuration = gf_bs_read_u32(bs);
ptr->posterTime = gf_bs_read_u32(bs);
ptr->selectionTime = gf_bs_read_u32(bs);
ptr->selectionDuration = gf_bs_read_u32(bs);
ptr->currentTime = gf_bs_read_u32(bs);
ptr->nextTrackID = gf_bs_read_u32(bs);
ptr->original_duration = ptr->duration;
return GF_OK;
}
| 0
|
496,441
|
getAutoExtensionsOfObject(Oid classId, Oid objectId)
{
List *result = NIL;
Relation depRel;
ScanKeyData key[2];
SysScanDesc scan;
HeapTuple tup;
depRel = table_open(DependRelationId, AccessShareLock);
ScanKeyInit(&key[0],
Anum_pg_depend_classid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(classId));
ScanKeyInit(&key[1],
Anum_pg_depend_objid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(objectId));
scan = systable_beginscan(depRel, DependDependerIndexId, true,
NULL, 2, key);
while (HeapTupleIsValid((tup = systable_getnext(scan))))
{
Form_pg_depend depform = (Form_pg_depend) GETSTRUCT(tup);
if (depform->refclassid == ExtensionRelationId &&
depform->deptype == DEPENDENCY_AUTO_EXTENSION)
result = lappend_oid(result, depform->refobjid);
}
systable_endscan(scan);
table_close(depRel, AccessShareLock);
return result;
}
| 0
|
192,804
|
void ObjectBackedNativeHandler::RouteFunction(
const std::string& name,
const std::string& feature_name,
const HandlerFunction& handler_function) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handle_scope(isolate);
v8::Context::Scope context_scope(context_->v8_context());
v8::Local<v8::Object> data = v8::Object::New(isolate);
SetPrivate(data, kHandlerFunction,
v8::External::New(isolate, new HandlerFunction(handler_function)));
DCHECK(feature_name.empty() ||
ExtensionAPI::GetSharedInstance()->GetFeatureDependency(feature_name))
<< feature_name;
SetPrivate(data, kFeatureName,
v8_helpers::ToV8StringUnsafe(isolate, feature_name));
v8::Local<v8::FunctionTemplate> function_template =
v8::FunctionTemplate::New(isolate, Router, data);
v8::Local<v8::ObjectTemplate>::New(isolate, object_template_)
->Set(isolate, name.c_str(), function_template);
router_data_.Append(data);
}
| 0
|
70,092
|
void CMSEXPORT cmsMLUfree(cmsMLU* mlu)
{
if (mlu) {
if (mlu -> Entries) _cmsFree(mlu ->ContextID, mlu->Entries);
if (mlu -> MemPool) _cmsFree(mlu ->ContextID, mlu->MemPool);
_cmsFree(mlu ->ContextID, mlu);
}
}
| 0
|
141,507
|
static void charstring_end(void)
{
byte *bp;
sprintf(line, "%d ", (int) (charstring_bp - charstring_buf));
eexec_string(line);
sprintf(line, "%s ", cs_start);
eexec_string(line);
for (bp = charstring_buf; bp < charstring_bp; bp++)
eexec_byte(*bp);
}
| 0
|
229,925
|
void AutomationProvider::SelectAll(int tab_handle) {
RenderViewHost* view = GetViewForTab(tab_handle);
if (!view) {
NOTREACHED();
return;
}
view->SelectAll();
}
| 0
|
301,717
|
void t2p_compose_pdf_page_orient(T2P_BOX* boxp, uint16 orientation){
float m1[9];
float f=0.0;
if( boxp->x1 > boxp->x2){
f=boxp->x1;
boxp->x1=boxp->x2;
boxp->x2 = f;
}
if( boxp->y1 > boxp->y2){
f=boxp->y1;
boxp->y1=boxp->y2;
boxp->y2 = f;
}
boxp->mat[0]=m1[0]=boxp->x2-boxp->x1;
boxp->mat[1]=m1[1]=0.0;
boxp->mat[2]=m1[2]=0.0;
boxp->mat[3]=m1[3]=0.0;
boxp->mat[4]=m1[4]=boxp->y2-boxp->y1;
boxp->mat[5]=m1[5]=0.0;
boxp->mat[6]=m1[6]=boxp->x1;
boxp->mat[7]=m1[7]=boxp->y1;
boxp->mat[8]=m1[8]=1.0;
switch(orientation){
case 0:
case 1:
break;
case 2:
boxp->mat[0]=0.0F-m1[0];
boxp->mat[6]+=m1[0];
break;
case 3:
boxp->mat[0]=0.0F-m1[0];
boxp->mat[4]=0.0F-m1[4];
boxp->mat[6]+=m1[0];
boxp->mat[7]+=m1[4];
break;
case 4:
boxp->mat[4]=0.0F-m1[4];
boxp->mat[7]+=m1[4];
break;
case 5:
boxp->mat[0]=0.0F;
boxp->mat[1]=0.0F-m1[0];
boxp->mat[3]=0.0F-m1[4];
boxp->mat[4]=0.0F;
boxp->mat[6]+=m1[4];
boxp->mat[7]+=m1[0];
break;
case 6:
boxp->mat[0]=0.0F;
boxp->mat[1]=0.0F-m1[0];
boxp->mat[3]=m1[4];
boxp->mat[4]=0.0F;
boxp->mat[7]+=m1[0];
break;
case 7:
boxp->mat[0]=0.0F;
boxp->mat[1]=m1[0];
boxp->mat[3]=m1[4];
boxp->mat[4]=0.0F;
break;
case 8:
boxp->mat[0]=0.0F;
boxp->mat[1]=m1[0];
boxp->mat[3]=0.0F-m1[4];
boxp->mat[4]=0.0F;
boxp->mat[6]+=m1[4];
break;
}
return;
}
| 0
|
304,898
|
static unsigned int crypto_blkcipher_ctxsize(struct crypto_alg *alg, u32 type,
u32 mask)
{
struct blkcipher_alg *cipher = &alg->cra_blkcipher;
unsigned int len = alg->cra_ctxsize;
if ((mask & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_MASK &&
cipher->ivsize) {
len = ALIGN(len, (unsigned long)alg->cra_alignmask + 1);
len += cipher->ivsize;
}
return len;
}
| 0
|
298,655
|
int install_process_keyring_to_cred(struct cred *new)
{
struct key *keyring;
if (new->process_keyring)
return -EEXIST;
keyring = keyring_alloc("_pid", new->uid, new->gid, new,
KEY_POS_ALL | KEY_USR_VIEW,
KEY_ALLOC_QUOTA_OVERRUN, NULL);
if (IS_ERR(keyring))
return PTR_ERR(keyring);
new->process_keyring = keyring;
return 0;
}
| 0
|
263,948
|
static int parseOperand(RAsm *a, const char *str, Operand *op, bool isrepop) {
size_t pos, nextpos = 0;
x86newTokenType last_type;
int size_token = 1;
bool explicit_size = false;
int reg_index = 0;
// Reset type
op->type = 0;
// Consume tokens denoting the operand size
while (size_token) {
pos = nextpos;
last_type = getToken (str, &pos, &nextpos);
// Token may indicate size: then skip
if (!r_str_ncasecmp (str + pos, "ptr", 3)) {
continue;
} else if (!r_str_ncasecmp (str + pos, "byte", 4)) {
op->type |= OT_MEMORY | OT_BYTE;
op->dest_size = OT_BYTE;
explicit_size = true;
} else if (!r_str_ncasecmp (str + pos, "word", 4)) {
op->type |= OT_MEMORY | OT_WORD;
op->dest_size = OT_WORD;
explicit_size = true;
} else if (!r_str_ncasecmp (str + pos, "dword", 5)) {
op->type |= OT_MEMORY | OT_DWORD;
op->dest_size = OT_DWORD;
explicit_size = true;
} else if (!r_str_ncasecmp (str + pos, "qword", 5)) {
op->type |= OT_MEMORY | OT_QWORD;
op->dest_size = OT_QWORD;
explicit_size = true;
} else if (!r_str_ncasecmp (str + pos, "oword", 5)) {
op->type |= OT_MEMORY | OT_OWORD;
op->dest_size = OT_OWORD;
explicit_size = true;
} else if (!r_str_ncasecmp (str + pos, "tbyte", 5)) {
op->type |= OT_MEMORY | OT_TBYTE;
op->dest_size = OT_TBYTE;
explicit_size = true;
} else { // the current token doesn't denote a size
size_token = 0;
}
}
// Next token: register, immediate, or '['
if (str[pos] == '[') {
// Don't care about size, if none is given.
if (!op->type) {
op->type = OT_MEMORY;
}
// At the moment, we only accept plain linear combinations:
// part := address | [factor *] register
// address := part {+ part}*
op->offset = op->scale[0] = op->scale[1] = 0;
ut64 temp = 1;
Register reg = X86R_UNDEFINED;
bool first_reg = true;
while (str[pos] != ']') {
if (pos > nextpos) {
// eprintf ("Error parsing instruction\n");
break;
}
pos = nextpos;
if (!str[pos]) {
break;
}
last_type = getToken (str, &pos, &nextpos);
if (last_type == TT_SPECIAL) {
if (str[pos] == '+' || str[pos] == '-' || str[pos] == ']') {
if (reg != X86R_UNDEFINED) {
if (reg_index < 2) {
op->regs[reg_index] = reg;
op->scale[reg_index] = temp;
}
++reg_index;
} else {
op->offset += temp;
if (reg_index < 2) {
op->regs[reg_index] = X86R_UNDEFINED;
}
}
temp = 1;
reg = X86R_UNDEFINED;
} else if (str[pos] == '*') {
// go to ], + or - to get scale
// Something to do here?
// Seems we are just ignoring '*' or assuming it implicitly.
}
}
else if (last_type == TT_WORD) {
ut32 reg_type = 0;
// We can't multiply registers
if (reg != X86R_UNDEFINED) {
op->type = 0; // Make the result invalid
}
// Reset nextpos: parseReg wants to parse from the beginning
nextpos = pos;
reg = parseReg (a, str, &nextpos, ®_type);
if (first_reg) {
op->extended = false;
if (reg > 8) {
op->extended = true;
op->reg = reg - 9;
}
first_reg = false;
} else if (reg > 8) {
op->reg = reg - 9;
}
if (reg_type & OT_REGTYPE & OT_SEGMENTREG) {
op->reg = reg;
op->type = reg_type;
parse_segment_offset (a, str, &nextpos, op, reg_index);
return nextpos;
}
// Still going to need to know the size if not specified
if (!explicit_size) {
op->type |= reg_type;
}
op->reg_size = reg_type;
op->explicit_size = explicit_size;
// Addressing only via general purpose registers
if (!(reg_type & OT_GPREG)) {
op->type = 0; // Make the result invalid
}
}
else {
char *p = strchr (str, '+');
op->offset_sign = 1;
if (!p) {
p = strchr (str, '-');
if (p) {
op->offset_sign = -1;
}
}
//with SIB notation, we need to consider the right sign
char * plus = strchr (str, '+');
char * minus = strchr (str, '-');
char * closeB = strchr (str, ']');
if (plus && minus && plus < closeB && minus < closeB) {
op->offset_sign = -1;
}
// If there's a scale, we don't want to parse out the
// scale with the offset (scale + offset) otherwise the scale
// will be the sum of the two. This splits the numbers
char *tmp;
tmp = malloc (strlen (str + pos) + 1);
strcpy (tmp, str + pos);
strtok (tmp, "+-");
st64 read = getnum (a, tmp);
free (tmp);
temp *= read;
}
}
} else if (last_type == TT_WORD) { // register
nextpos = pos;
RFlagItem *flag;
if (isrepop) {
op->is_good_flag = false;
strncpy (op->rep_op, str, MAX_REPOP_LENGTH - 1);
op->rep_op[MAX_REPOP_LENGTH - 1] = '\0';
return nextpos;
}
op->reg = parseReg (a, str, &nextpos, &op->type);
op->extended = false;
if (op->reg > 8) {
op->extended = true;
op->reg -= 9;
}
if (op->type & OT_REGTYPE & OT_SEGMENTREG) {
parse_segment_offset (a, str, &nextpos, op, reg_index);
return nextpos;
}
if (op->reg == X86R_UNDEFINED) {
op->is_good_flag = false;
if (a->num && a->num->value == 0) {
return nextpos;
}
op->type = OT_CONSTANT;
RCore *core = a->num? (RCore *)(a->num->userptr): NULL;
if (core && (flag = r_flag_get (core->flags, str))) {
op->is_good_flag = true;
}
char *p = strchr (str, '-');
if (p) {
op->sign = -1;
str = ++p;
}
op->immediate = getnum (a, str);
} else if (op->reg < X86R_UNDEFINED) {
strncpy (op->rep_op, str, MAX_REPOP_LENGTH - 1);
op->rep_op[MAX_REPOP_LENGTH - 1] = '\0';
}
} else { // immediate
// We don't know the size, so let's just set no size flag.
op->type = OT_CONSTANT;
op->sign = 1;
char *p = strchr (str, '-');
if (p) {
op->sign = -1;
str = ++p;
}
op->immediate = getnum (a, str);
}
return nextpos;
}
| 0
|
32,944
|
int cil_gen_default(struct cil_tree_node *parse_current, struct cil_tree_node *ast_node, enum cil_flavor flavor)
{
int rc = SEPOL_ERR;
struct cil_default *def = NULL;
char *object;
enum cil_syntax syntax[] = {
CIL_SYN_STRING,
CIL_SYN_STRING | CIL_SYN_LIST,
CIL_SYN_STRING,
CIL_SYN_END
};
int syntax_len = sizeof(syntax)/sizeof(*syntax);
rc = __cil_verify_syntax(parse_current, syntax, syntax_len);
if (rc != SEPOL_OK) {
goto exit;
}
cil_default_init(&def);
def->flavor = flavor;
if (parse_current->next->cl_head == NULL) {
cil_list_init(&def->class_strs, CIL_CLASS);
cil_list_append(def->class_strs, CIL_STRING, parse_current->next->data);
} else {
rc = cil_fill_list(parse_current->next->cl_head, CIL_CLASS, &def->class_strs);
if (rc != SEPOL_OK) {
goto exit;
}
}
object = parse_current->next->next->data;
if (object == CIL_KEY_SOURCE) {
def->object = CIL_DEFAULT_SOURCE;
} else if (object == CIL_KEY_TARGET) {
def->object = CIL_DEFAULT_TARGET;
} else {
cil_log(CIL_ERR,"Expected either 'source' or 'target'\n");
rc = SEPOL_ERR;
goto exit;
}
ast_node->data = def;
ast_node->flavor = flavor;
return SEPOL_OK;
exit:
cil_tree_log(parse_current, CIL_ERR, "Bad %s declaration", cil_node_to_string(parse_current));
cil_destroy_default(def);
return rc;
}
| 0
|
17,822
|
static void event_text ( const char * data , SERVER_REC * server , WI_ITEM_REC * item ) {
char * line , * str , * target ;
g_return_if_fail ( data != NULL ) ;
if ( item == NULL ) return ;
if ( * data == '\0' ) {
signal_stop ( ) ;
return ;
}
line = settings_get_bool ( "expand_escapes" ) ? expand_escapes ( data , server , item ) : g_strdup ( data ) ;
if ( completion_auto && IS_CHANNEL ( item ) ) {
str = auto_complete ( CHANNEL ( item ) , line ) ;
if ( str != NULL ) {
g_free ( line ) ;
line = str ;
}
}
target = escape_string ( window_item_get_target ( item ) ) ;
str = g_strdup_printf ( IS_CHANNEL ( item ) ? "-channel \"%s\" %s" : IS_QUERY ( item ) ? "-nick \"%s\" %s" : "%s %s" , target , line ) ;
g_free ( target ) ;
signal_emit ( "command msg" , 3 , str , server , item ) ;
g_free ( str ) ;
g_free ( line ) ;
signal_stop ( ) ;
}
| 0
|
342,602
|
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt)
{
AVFrame *frame = data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MJpegDecodeContext *s = avctx->priv_data;
const uint8_t *buf_end, *buf_ptr;
const uint8_t *unescaped_buf_ptr;
int hshift, vshift;
int unescaped_buf_size;
int start_code;
int i, index;
int ret = 0;
int is16bit;
av_dict_free(&s->exif_metadata);
av_freep(&s->stereo3d);
s->adobe_transform = -1;
buf_ptr = buf;
buf_end = buf + buf_size;
while (buf_ptr < buf_end) {
/* find start next marker */
start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
&unescaped_buf_ptr,
&unescaped_buf_size);
/* EOF */
if (start_code < 0) {
break;
} else if (unescaped_buf_size > INT_MAX / 8) {
av_log(avctx, AV_LOG_ERROR,
"MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
start_code, unescaped_buf_size, buf_size);
return AVERROR_INVALIDDATA;
}
av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
start_code, buf_end - buf_ptr);
ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
goto fail;
}
s->start_code = start_code;
if (s->avctx->debug & FF_DEBUG_STARTCODE)
av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
/* process markers */
if (start_code >= 0xd0 && start_code <= 0xd7)
av_log(avctx, AV_LOG_DEBUG,
"restart marker: %d\n", start_code & 0x0f);
/* APP fields */
else if (start_code >= APP0 && start_code <= APP15)
mjpeg_decode_app(s);
/* Comment */
else if (start_code == COM)
mjpeg_decode_com(s);
ret = -1;
if (!CONFIG_JPEGLS_DECODER &&
(start_code == SOF48 || start_code == LSE)) {
av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
return AVERROR(ENOSYS);
}
if (avctx->skip_frame == AVDISCARD_ALL) {
switch(start_code) {
case SOF0:
case SOF1:
case SOF2:
case SOF3:
case SOF48:
case SOI:
case SOS:
case EOI:
break;
default:
goto skip;
}
}
switch (start_code) {
case SOI:
s->restart_interval = 0;
s->restart_count = 0;
/* nothing to do on SOI */
break;
case DQT:
ff_mjpeg_decode_dqt(s);
break;
case DHT:
if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
goto fail;
}
break;
case SOF0:
case SOF1:
s->lossless = 0;
s->ls = 0;
s->progressive = 0;
if ((ret = ff_mjpeg_decode_sof(s)) < 0)
goto fail;
break;
case SOF2:
s->lossless = 0;
s->ls = 0;
s->progressive = 1;
if ((ret = ff_mjpeg_decode_sof(s)) < 0)
goto fail;
break;
case SOF3:
s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
s->lossless = 1;
s->ls = 0;
s->progressive = 0;
if ((ret = ff_mjpeg_decode_sof(s)) < 0)
goto fail;
break;
case SOF48:
s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
s->lossless = 1;
s->ls = 1;
s->progressive = 0;
if ((ret = ff_mjpeg_decode_sof(s)) < 0)
goto fail;
break;
case LSE:
if (!CONFIG_JPEGLS_DECODER ||
(ret = ff_jpegls_decode_lse(s)) < 0)
goto fail;
break;
case EOI:
eoi_parser:
s->cur_scan = 0;
if (!s->got_picture) {
av_log(avctx, AV_LOG_WARNING,
"Found EOI before any SOF, ignoring\n");
break;
}
if (s->interlaced) {
s->bottom_field ^= 1;
/* if not bottom field, do not output image yet */
if (s->bottom_field == !s->interlace_polarity)
break;
}
if (avctx->skip_frame == AVDISCARD_ALL) {
s->got_picture = 0;
goto the_end_no_picture;
}
if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
return ret;
*got_frame = 1;
s->got_picture = 0;
if (!s->lossless) {
int qp = FFMAX3(s->qscale[0],
s->qscale[1],
s->qscale[2]);
int qpw = (s->width + 15) / 16;
AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
if (qp_table_buf) {
memset(qp_table_buf->data, qp, qpw);
av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
}
if(avctx->debug & FF_DEBUG_QP)
av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
}
goto the_end;
case SOS:
s->cur_scan++;
if (avctx->skip_frame == AVDISCARD_ALL)
break;
if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
(avctx->err_recognition & AV_EF_EXPLODE))
goto fail;
break;
case DRI:
mjpeg_decode_dri(s);
break;
case SOF5:
case SOF6:
case SOF7:
case SOF9:
case SOF10:
case SOF11:
case SOF13:
case SOF14:
case SOF15:
case JPG:
av_log(avctx, AV_LOG_ERROR,
"mjpeg: unsupported coding type (%x)\n", start_code);
break;
}
skip:
/* eof process start code */
buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
av_log(avctx, AV_LOG_DEBUG,
"marker parser used %d bytes (%d bits)\n",
(get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
}
if (s->got_picture && s->cur_scan) {
av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
goto eoi_parser;
}
av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
return AVERROR_INVALIDDATA;
fail:
s->got_picture = 0;
return ret;
the_end:
is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
if (AV_RB32(s->upscale_h)) {
int p;
av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
avctx->pix_fmt == AV_PIX_FMT_GBRP ||
avctx->pix_fmt == AV_PIX_FMT_GBRAP
);
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
for (p = 0; p<4; p++) {
uint8_t *line = s->picture_ptr->data[p];
int w = s->width;
int h = s->height;
if (!s->upscale_h[p])
continue;
if (p==1 || p==2) {
w = AV_CEIL_RSHIFT(w, hshift);
h = AV_CEIL_RSHIFT(h, vshift);
}
if (s->upscale_v[p])
h = (h+1)>>1;
av_assert0(w > 0);
for (i = 0; i < h; i++) {
if (s->upscale_h[p] == 1) {
if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
else line[w - 1] = line[(w - 1) / 2];
for (index = w - 2; index > 0; index--) {
if (is16bit)
((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
else
line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
}
} else if (s->upscale_h[p] == 2) {
if (is16bit) {
((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
if (w > 1)
((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
} else {
line[w - 1] = line[(w - 1) / 3];
if (w > 1)
line[w - 2] = line[w - 1];
}
for (index = w - 3; index > 0; index--) {
line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
}
}
line += s->linesize[p];
}
}
}
if (AV_RB32(s->upscale_v)) {
int p;
av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
avctx->pix_fmt == AV_PIX_FMT_GBRP ||
avctx->pix_fmt == AV_PIX_FMT_GBRAP
);
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
for (p = 0; p < 4; p++) {
uint8_t *dst;
int w = s->width;
int h = s->height;
if (!s->upscale_v[p])
continue;
if (p==1 || p==2) {
w = AV_CEIL_RSHIFT(w, hshift);
h = AV_CEIL_RSHIFT(h, vshift);
}
dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
for (i = h - 1; i; i--) {
uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i / 2 * s->linesize[p]];
uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) / 2 * s->linesize[p]];
if (src1 == src2 || i == h - 1) {
memcpy(dst, src1, w);
} else {
for (index = 0; index < w; index++)
dst[index] = (src1[index] + src2[index]) >> 1;
}
dst -= s->linesize[p];
}
}
}
if (s->flipped) {
int j;
avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
for (index=0; index<4; index++) {
uint8_t *dst = s->picture_ptr->data[index];
int w = s->picture_ptr->width;
int h = s->picture_ptr->height;
if(index && index<3){
w = AV_CEIL_RSHIFT(w, hshift);
h = AV_CEIL_RSHIFT(h, vshift);
}
if(dst){
uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
for (i=0; i<h/2; i++) {
for (j=0; j<w; j++)
FFSWAP(int, dst[j], dst2[j]);
dst += s->picture_ptr->linesize[index];
dst2 -= s->picture_ptr->linesize[index];
}
}
}
}
if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
int w = s->picture_ptr->width;
int h = s->picture_ptr->height;
for (i=0; i<h; i++) {
int j;
uint8_t *dst[4];
for (index=0; index<4; index++) {
dst[index] = s->picture_ptr->data[index]
+ s->picture_ptr->linesize[index]*i;
}
for (j=0; j<w; j++) {
int k = dst[3][j];
int r = dst[0][j] * k;
int g = dst[1][j] * k;
int b = dst[2][j] * k;
dst[0][j] = g*257 >> 16;
dst[1][j] = b*257 >> 16;
dst[2][j] = r*257 >> 16;
dst[3][j] = 255;
}
}
}
if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
int w = s->picture_ptr->width;
int h = s->picture_ptr->height;
for (i=0; i<h; i++) {
int j;
uint8_t *dst[4];
for (index=0; index<4; index++) {
dst[index] = s->picture_ptr->data[index]
+ s->picture_ptr->linesize[index]*i;
}
for (j=0; j<w; j++) {
int k = dst[3][j];
int r = (255 - dst[0][j]) * k;
int g = (128 - dst[1][j]) * k;
int b = (128 - dst[2][j]) * k;
dst[0][j] = r*257 >> 16;
dst[1][j] = (g*257 >> 16) + 128;
dst[2][j] = (b*257 >> 16) + 128;
dst[3][j] = 255;
}
}
}
if (s->stereo3d) {
AVStereo3D *stereo = av_stereo3d_create_side_data(data);
if (stereo) {
stereo->type = s->stereo3d->type;
stereo->flags = s->stereo3d->flags;
}
av_freep(&s->stereo3d);
}
av_dict_copy(avpriv_frame_get_metadatap(data), s->exif_metadata, 0);
av_dict_free(&s->exif_metadata);
the_end_no_picture:
av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
buf_end - buf_ptr);
// return buf_end - buf_ptr;
return buf_ptr - buf;
}
| 1
|
148,995
|
static int r_bin_print_xtrplugin_details(RBin *bin, RBinXtrPlugin *bx, int json) {
if (json == 'q') {
bin->cb_printf ("%s\n", bx->name);
} else if (json) {
bin->cb_printf (
"{\"name\":\"%s\",\"description\":\"%s\","
"\"license\":\"%s\"}\n",
bx->name, bx->desc, bx->license? bx->license: "???");
} else {
bin->cb_printf ("Name: %s\n", bx->name);
bin->cb_printf ("Description: %s\n", bx->desc);
if (bx->license) {
bin->cb_printf ("License: %s\n", bx->license);
}
}
return true;
}
| 0
|
191,183
|
name_owner_foreach (gpointer key, gpointer val, gpointer data)
{
const char *owner;
DBusGProxyNameOwnerForeachData *foreach_data;
GSList *names;
GSList *link;
owner = key;
names = val;
foreach_data = data;
if (foreach_data->owner != NULL)
return;
g_assert (foreach_data->info == NULL);
link = g_slist_find_custom (names, foreach_data->name, find_name_in_info);
if (link)
{
foreach_data->owner = owner;
foreach_data->info = link->data;
}
}
| 0
|
334,695
|
static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
{
BDRVDMGState *s = bs->opaque;
if (!is_sector_in_chunk(s, s->current_chunk, sector_num)) {
int ret;
uint32_t chunk = search_chunk(s, sector_num);
#ifdef CONFIG_BZIP2
uint64_t total_out;
#endif
if (chunk >= s->n_chunks) {
return -1;
}
s->current_chunk = s->n_chunks;
switch (s->types[chunk]) { /* block entry type */
case 0x80000005: { /* zlib compressed */
/* we need to buffer, because only the chunk as whole can be
* inflated. */
ret = bdrv_pread(bs->file, s->offsets[chunk],
s->compressed_chunk, s->lengths[chunk]);
if (ret != s->lengths[chunk]) {
return -1;
}
s->zstream.next_in = s->compressed_chunk;
s->zstream.avail_in = s->lengths[chunk];
s->zstream.next_out = s->uncompressed_chunk;
s->zstream.avail_out = 512 * s->sectorcounts[chunk];
ret = inflateReset(&s->zstream);
if (ret != Z_OK) {
return -1;
}
ret = inflate(&s->zstream, Z_FINISH);
if (ret != Z_STREAM_END ||
s->zstream.total_out != 512 * s->sectorcounts[chunk]) {
return -1;
}
break; }
#ifdef CONFIG_BZIP2
case 0x80000006: /* bzip2 compressed */
/* we need to buffer, because only the chunk as whole can be
* inflated. */
ret = bdrv_pread(bs->file, s->offsets[chunk],
s->compressed_chunk, s->lengths[chunk]);
if (ret != s->lengths[chunk]) {
return -1;
}
ret = BZ2_bzDecompressInit(&s->bzstream, 0, 0);
if (ret != BZ_OK) {
return -1;
}
s->bzstream.next_in = (char *)s->compressed_chunk;
s->bzstream.avail_in = (unsigned int) s->lengths[chunk];
s->bzstream.next_out = (char *)s->uncompressed_chunk;
s->bzstream.avail_out = (unsigned int) 512 * s->sectorcounts[chunk];
ret = BZ2_bzDecompress(&s->bzstream);
total_out = ((uint64_t)s->bzstream.total_out_hi32 << 32) +
s->bzstream.total_out_lo32;
BZ2_bzDecompressEnd(&s->bzstream);
if (ret != BZ_STREAM_END ||
total_out != 512 * s->sectorcounts[chunk]) {
return -1;
}
break;
#endif /* CONFIG_BZIP2 */
case 1: /* copy */
ret = bdrv_pread(bs->file, s->offsets[chunk],
s->uncompressed_chunk, s->lengths[chunk]);
if (ret != s->lengths[chunk]) {
return -1;
}
break;
case 2: /* zero */
memset(s->uncompressed_chunk, 0, 512 * s->sectorcounts[chunk]);
break;
}
s->current_chunk = chunk;
}
return 0;
}
| 0
|
239,390
|
int ssl3_send_client_verify(SSL *s)
{
unsigned char *p,*d;
unsigned char data[MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH];
EVP_PKEY *pkey;
EVP_PKEY_CTX *pctx=NULL;
EVP_MD_CTX mctx;
unsigned u=0;
unsigned long n;
int j;
EVP_MD_CTX_init(&mctx);
if (s->state == SSL3_ST_CW_CERT_VRFY_A)
{
d=(unsigned char *)s->init_buf->data;
p= &(d[4]);
pkey=s->cert->key->privatekey;
/* Create context from key and test if sha1 is allowed as digest */
pctx = EVP_PKEY_CTX_new(pkey,NULL);
EVP_PKEY_sign_init(pctx);
if (EVP_PKEY_CTX_set_signature_md(pctx, EVP_sha1())>0)
{
if (TLS1_get_version(s) < TLS1_2_VERSION)
s->method->ssl3_enc->cert_verify_mac(s,
NID_sha1,
&(data[MD5_DIGEST_LENGTH]));
}
else
{
ERR_clear_error();
}
/* For TLS v1.2 send signature algorithm and signature
* using agreed digest and cached handshake records.
*/
if (TLS1_get_version(s) >= TLS1_2_VERSION)
{
long hdatalen = 0;
void *hdata;
const EVP_MD *md = s->cert->key->digest;
hdatalen = BIO_get_mem_data(s->s3->handshake_buffer,
&hdata);
if (hdatalen <= 0 || !tls12_get_sigandhash(p, pkey, md))
{
SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,
ERR_R_INTERNAL_ERROR);
goto err;
}
p += 2;
#ifdef SSL_DEBUG
fprintf(stderr, "Using TLS 1.2 with client alg %s\n",
EVP_MD_name(md));
#endif
if (!EVP_SignInit_ex(&mctx, md, NULL)
|| !EVP_SignUpdate(&mctx, hdata, hdatalen)
|| !EVP_SignFinal(&mctx, p + 2, &u, pkey))
{
SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,
ERR_R_EVP_LIB);
goto err;
}
s2n(u,p);
n = u + 4;
if (!ssl3_digest_cached_records(s))
goto err;
}
else
#ifndef OPENSSL_NO_RSA
if (pkey->type == EVP_PKEY_RSA)
{
s->method->ssl3_enc->cert_verify_mac(s,
NID_md5,
&(data[0]));
if (RSA_sign(NID_md5_sha1, data,
MD5_DIGEST_LENGTH+SHA_DIGEST_LENGTH,
&(p[2]), &u, pkey->pkey.rsa) <= 0 )
{
SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,ERR_R_RSA_LIB);
goto err;
}
s2n(u,p);
n=u+2;
}
else
#endif
#ifndef OPENSSL_NO_DSA
if (pkey->type == EVP_PKEY_DSA)
{
if (!DSA_sign(pkey->save_type,
&(data[MD5_DIGEST_LENGTH]),
SHA_DIGEST_LENGTH,&(p[2]),
(unsigned int *)&j,pkey->pkey.dsa))
{
SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,ERR_R_DSA_LIB);
goto err;
}
s2n(j,p);
n=j+2;
}
else
#endif
#ifndef OPENSSL_NO_ECDSA
if (pkey->type == EVP_PKEY_EC)
{
if (!ECDSA_sign(pkey->save_type,
&(data[MD5_DIGEST_LENGTH]),
SHA_DIGEST_LENGTH,&(p[2]),
(unsigned int *)&j,pkey->pkey.ec))
{
SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,
ERR_R_ECDSA_LIB);
goto err;
}
s2n(j,p);
n=j+2;
}
else
#endif
if (pkey->type == NID_id_GostR3410_94 || pkey->type == NID_id_GostR3410_2001)
{
unsigned char signbuf[64];
int i;
size_t sigsize=64;
s->method->ssl3_enc->cert_verify_mac(s,
NID_id_GostR3411_94,
data);
if (EVP_PKEY_sign(pctx, signbuf, &sigsize, data, 32) <= 0) {
SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,
ERR_R_INTERNAL_ERROR);
goto err;
}
for (i=63,j=0; i>=0; j++, i--) {
p[2+j]=signbuf[i];
}
s2n(j,p);
n=j+2;
}
else
{
SSLerr(SSL_F_SSL3_SEND_CLIENT_VERIFY,ERR_R_INTERNAL_ERROR);
goto err;
}
*(d++)=SSL3_MT_CERTIFICATE_VERIFY;
l2n3(n,d);
s->state=SSL3_ST_CW_CERT_VRFY_B;
s->init_num=(int)n+4;
s->init_off=0;
}
EVP_MD_CTX_cleanup(&mctx);
EVP_PKEY_CTX_free(pctx);
return(ssl3_do_write(s,SSL3_RT_HANDSHAKE));
err:
EVP_MD_CTX_cleanup(&mctx);
EVP_PKEY_CTX_free(pctx);
return(-1);
}
| 0
|
137,658
|
TEST_P(RedirectIntegrationTest, InternalRedirectCancelledDueToEarlyResponse) {
useAccessLog("%RESPONSE_FLAGS% %RESPONSE_CODE% %RESPONSE_CODE_DETAILS% %RESP(test-header)%");
initialize();
codec_client_ = makeHttpConnection(lookupPort("http"));
default_request_headers_.setHost("handle.internal.redirect");
default_request_headers_.setMethod("POST");
auto encoder_decoder = codec_client_->startRequest(default_request_headers_);
auto& response = encoder_decoder.second;
// Wait for the request headers to be received upstream.
ASSERT_TRUE(fake_upstreams_[0]->waitForHttpConnection(*dispatcher_, fake_upstream_connection_));
ASSERT_TRUE(fake_upstream_connection_->waitForNewStream(*dispatcher_, upstream_request_));
ASSERT_TRUE(upstream_request_->waitForHeadersComplete());
// Respond with a redirect before the request is complete.
upstream_request_->encodeHeaders(redirect_response_, true);
ASSERT_TRUE(response->waitForEndStream());
if (upstreamProtocol() == Http::CodecType::HTTP1) {
ASSERT_TRUE(fake_upstream_connection_->waitForDisconnect());
} else {
ASSERT_TRUE(upstream_request_->waitForReset());
ASSERT_TRUE(fake_upstream_connection_->close());
ASSERT_TRUE(fake_upstream_connection_->waitForDisconnect());
}
if (downstream_protocol_ == Http::CodecType::HTTP1) {
ASSERT_TRUE(codec_client_->waitForDisconnect());
} else {
codec_client_->close();
}
EXPECT_FALSE(upstream_request_->complete());
// Ensure the redirect was returned to the client and not handled internally.
EXPECT_TRUE(response->complete());
EXPECT_EQ("302", response->headers().getStatusValue());
}
| 0
|
350,210
|
static inline void io_req_work_drop_env(struct io_kiocb *req)
{
if (req->work.mm) {
mmdrop(req->work.mm);
req->work.mm = NULL;
}
if (req->work.creds) {
put_cred(req->work.creds);
req->work.creds = NULL;
}
}
| 1
|
5,263
|
String StringUtil::Implode(const Variant& items, const String& delim,
const bool checkIsContainer /* = true */) {
if (checkIsContainer && !isContainer(items)) {
throw_param_is_not_container();
}
int size = getContainerSize(items);
if (size == 0) return empty_string();
req::vector<String> sitems;
sitems.reserve(size);
int len = 0;
int lenDelim = delim.size();
for (ArrayIter iter(items); iter; ++iter) {
sitems.emplace_back(iter.second().toString());
len += sitems.back().size() + lenDelim;
}
len -= lenDelim; // always one delimiter less than count of items
assert(sitems.size() == size);
String s = String(len, ReserveString);
char *buffer = s.mutableData();
const char *sdelim = delim.data();
char *p = buffer;
String &init_str = sitems[0];
int init_len = init_str.size();
memcpy(p, init_str.data(), init_len);
p += init_len;
for (int i = 1; i < size; i++) {
String &item = sitems[i];
memcpy(p, sdelim, lenDelim);
p += lenDelim;
int lenItem = item.size();
memcpy(p, item.data(), lenItem);
p += lenItem;
}
assert(p - buffer == len);
s.setSize(len);
return s;
}
| 1
|
198,744
|
bool BaseArena::willObjectBeLazilySwept(BasePage* page,
void* objectPointer) const {
if (page != m_firstUnsweptPage)
return true;
DCHECK(!page->isLargeObjectPage());
NormalPage* normalPage = reinterpret_cast<NormalPage*>(page);
NormalPageArena* normalArena = normalPage->arenaForNormalPage();
if (!normalArena->isLazySweeping())
return true;
Address pageEnd = normalPage->payloadEnd();
for (Address headerAddress = normalPage->payload();
headerAddress < pageEnd;) {
HeapObjectHeader* header =
reinterpret_cast<HeapObjectHeader*>(headerAddress);
size_t size = header->size();
if (headerAddress > objectPointer)
return false;
if (!header->isFree() && header->isMarked()) {
DCHECK(headerAddress + size < pageEnd);
return true;
}
headerAddress += size;
}
NOTREACHED();
return true;
}
| 0
|
169,956
|
bool Document::IsValidName(const String& name) {
unsigned length = name.length();
if (!length)
return false;
if (name.Is8Bit()) {
const LChar* characters = name.Characters8();
if (IsValidNameASCII(characters, length))
return true;
return IsValidNameNonASCII(characters, length);
}
const UChar* characters = name.Characters16();
if (IsValidNameASCII(characters, length))
return true;
return IsValidNameNonASCII(characters, length);
}
| 0
|
321,907
|
static int mpeg_field_start(MpegEncContext *s){
AVCodecContext *avctx= s->avctx;
Mpeg1Context *s1 = (Mpeg1Context*)s;
/* start frame decoding */
if(s->first_field || s->picture_structure==PICT_FRAME){
if(MPV_frame_start(s, avctx) < 0)
return -1;
ff_er_frame_start(s);
/* first check if we must repeat the frame */
s->current_picture_ptr->repeat_pict = 0;
if (s->repeat_first_field) {
if (s->progressive_sequence) {
if (s->top_field_first)
s->current_picture_ptr->repeat_pict = 4;
else
s->current_picture_ptr->repeat_pict = 2;
} else if (s->progressive_frame) {
s->current_picture_ptr->repeat_pict = 1;
}
}
*s->current_picture_ptr->pan_scan= s1->pan_scan;
}else{ //second field
int i;
if(!s->current_picture_ptr){
av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
return -1;
}
for(i=0; i<4; i++){
s->current_picture.data[i] = s->current_picture_ptr->data[i];
if(s->picture_structure == PICT_BOTTOM_FIELD){
s->current_picture.data[i] += s->current_picture_ptr->linesize[i];
}
}
}
#if CONFIG_MPEG_XVMC_DECODER
// MPV_frame_start will call this function too,
// but we need to call it on every field
if(s->avctx->xvmc_acceleration)
ff_xvmc_field_start(s,avctx);
#endif
return 0;
}
| 0
|
324,675
|
static float pvq_band_cost(CeltPVQ *pvq, CeltFrame *f, OpusRangeCoder *rc, int band,
float *bits, float lambda)
{
int i, b = 0;
uint32_t cm[2] = { (1 << f->blocks) - 1, (1 << f->blocks) - 1 };
const int band_size = ff_celt_freq_range[band] << f->size;
float buf[176 * 2], lowband_scratch[176], norm1[176], norm2[176];
float dist, cost, err_x = 0.0f, err_y = 0.0f;
float *X = buf;
float *X_orig = f->block[0].coeffs + (ff_celt_freq_bands[band] << f->size);
float *Y = (f->channels == 2) ? &buf[176] : NULL;
float *Y_orig = f->block[1].coeffs + (ff_celt_freq_bands[band] << f->size);
OPUS_RC_CHECKPOINT_SPAWN(rc);
memcpy(X, X_orig, band_size*sizeof(float));
if (Y)
memcpy(Y, Y_orig, band_size*sizeof(float));
f->remaining2 = ((f->framebits << 3) - f->anticollapse_needed) - opus_rc_tell_frac(rc) - 1;
if (band <= f->coded_bands - 1) {
int curr_balance = f->remaining / FFMIN(3, f->coded_bands - band);
b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[band] + curr_balance), 14);
}
if (f->dual_stereo) {
pvq->quant_band(pvq, f, rc, band, X, NULL, band_size, b / 2, f->blocks, NULL,
f->size, norm1, 0, 1.0f, lowband_scratch, cm[0]);
pvq->quant_band(pvq, f, rc, band, Y, NULL, band_size, b / 2, f->blocks, NULL,
f->size, norm2, 0, 1.0f, lowband_scratch, cm[1]);
} else {
pvq->quant_band(pvq, f, rc, band, X, Y, band_size, b, f->blocks, NULL, f->size,
norm1, 0, 1.0f, lowband_scratch, cm[0] | cm[1]);
}
for (i = 0; i < band_size; i++) {
err_x += (X[i] - X_orig[i])*(X[i] - X_orig[i]);
if (Y)
err_y += (Y[i] - Y_orig[i])*(Y[i] - Y_orig[i]);
}
dist = sqrtf(err_x) + sqrtf(err_y);
cost = OPUS_RC_CHECKPOINT_BITS(rc)/8.0f;
*bits += cost;
OPUS_RC_CHECKPOINT_ROLLBACK(rc);
return lambda*dist*cost;
}
| 0
|
468,960
|
static int kvm_vm_ioctl_create_vcpu(struct kvm *kvm, u32 id)
{
int r;
struct kvm_vcpu *vcpu;
struct page *page;
if (id >= KVM_MAX_VCPU_ID)
return -EINVAL;
mutex_lock(&kvm->lock);
if (kvm->created_vcpus == KVM_MAX_VCPUS) {
mutex_unlock(&kvm->lock);
return -EINVAL;
}
kvm->created_vcpus++;
mutex_unlock(&kvm->lock);
r = kvm_arch_vcpu_precreate(kvm, id);
if (r)
goto vcpu_decrement;
vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL_ACCOUNT);
if (!vcpu) {
r = -ENOMEM;
goto vcpu_decrement;
}
BUILD_BUG_ON(sizeof(struct kvm_run) > PAGE_SIZE);
page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);
if (!page) {
r = -ENOMEM;
goto vcpu_free;
}
vcpu->run = page_address(page);
kvm_vcpu_init(vcpu, kvm, id);
r = kvm_arch_vcpu_create(vcpu);
if (r)
goto vcpu_free_run_page;
if (kvm->dirty_ring_size) {
r = kvm_dirty_ring_alloc(&vcpu->dirty_ring,
id, kvm->dirty_ring_size);
if (r)
goto arch_vcpu_destroy;
}
mutex_lock(&kvm->lock);
if (kvm_get_vcpu_by_id(kvm, id)) {
r = -EEXIST;
goto unlock_vcpu_destroy;
}
vcpu->vcpu_idx = atomic_read(&kvm->online_vcpus);
BUG_ON(kvm->vcpus[vcpu->vcpu_idx]);
/* Now it's all set up, let userspace reach it */
kvm_get_kvm(kvm);
r = create_vcpu_fd(vcpu);
if (r < 0) {
kvm_put_kvm_no_destroy(kvm);
goto unlock_vcpu_destroy;
}
kvm->vcpus[vcpu->vcpu_idx] = vcpu;
/*
* Pairs with smp_rmb() in kvm_get_vcpu. Write kvm->vcpus
* before kvm->online_vcpu's incremented value.
*/
smp_wmb();
atomic_inc(&kvm->online_vcpus);
mutex_unlock(&kvm->lock);
kvm_arch_vcpu_postcreate(vcpu);
kvm_create_vcpu_debugfs(vcpu);
return r;
unlock_vcpu_destroy:
mutex_unlock(&kvm->lock);
kvm_dirty_ring_free(&vcpu->dirty_ring);
arch_vcpu_destroy:
kvm_arch_vcpu_destroy(vcpu);
vcpu_free_run_page:
free_page((unsigned long)vcpu->run);
vcpu_free:
kmem_cache_free(kvm_vcpu_cache, vcpu);
vcpu_decrement:
mutex_lock(&kvm->lock);
kvm->created_vcpus--;
mutex_unlock(&kvm->lock);
return r;
}
| 0
|
181,203
|
bool ChromeContentRendererClient::IsLinkVisited(unsigned long long link_hash) {
return visited_link_slave_->IsVisited(link_hash);
}
| 0
|
79,254
|
bool kvm_make_vcpus_request_mask(struct kvm *kvm, unsigned int req,
unsigned long *vcpu_bitmap, cpumask_var_t tmp)
{
int i, cpu, me;
struct kvm_vcpu *vcpu;
bool called;
me = get_cpu();
kvm_for_each_vcpu(i, vcpu, kvm) {
if (vcpu_bitmap && !test_bit(i, vcpu_bitmap))
continue;
kvm_make_request(req, vcpu);
cpu = vcpu->cpu;
if (!(req & KVM_REQUEST_NO_WAKEUP) && kvm_vcpu_wake_up(vcpu))
continue;
if (tmp != NULL && cpu != -1 && cpu != me &&
kvm_request_needs_ipi(vcpu, req))
__cpumask_set_cpu(cpu, tmp);
}
called = kvm_kick_many_cpus(tmp, !!(req & KVM_REQUEST_WAIT));
put_cpu();
return called;
}
| 0
|
439,749
|
static void splashOutBlendScreen(SplashColorPtr src, SplashColorPtr dest,
SplashColorPtr blend, SplashColorMode cm) {
int i;
#ifdef SPLASH_CMYK
if (cm == splashModeCMYK8 || cm == splashModeDeviceN8) {
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
dest[i] = 255 - dest[i];
src[i] = 255 - src[i];
}
}
#endif
{
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
blend[i] = dest[i] + src[i] - (dest[i] * src[i]) / 255;
}
}
#ifdef SPLASH_CMYK
if (cm == splashModeCMYK8 || cm == splashModeDeviceN8) {
for (i = 0; i < splashColorModeNComps[cm]; ++i) {
dest[i] = 255 - dest[i];
src[i] = 255 - src[i];
blend[i] = 255 - blend[i];
}
}
#endif
}
| 0
|
339,583
|
static int qsort_strcmp(const void *a, const void *b)
{
return strcmp(a, b);
}
| 0
|
345,880
|
_PUBLIC_ codepoint_t next_codepoint_ext(const char *str, charset_t src_charset,
size_t *size)
{
return next_codepoint_handle_ext(get_iconv_handle(), str,
src_charset, size);
}
| 1
|
248,285
|
void InitWaitForSelectionEvent(ui::SelectionEventType expected_event) {
DCHECK(!run_loop_);
expected_event_ = expected_event;
run_loop_.reset(new base::RunLoop());
}
| 0
|
425,297
|
static int __domain_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
struct scatterlist *sg, unsigned long phys_pfn,
unsigned long nr_pages, int prot)
{
struct dma_pte *first_pte = NULL, *pte = NULL;
phys_addr_t uninitialized_var(pteval);
unsigned long sg_res = 0;
unsigned int largepage_lvl = 0;
unsigned long lvl_pages = 0;
BUG_ON(!domain_pfn_supported(domain, iov_pfn + nr_pages - 1));
if ((prot & (DMA_PTE_READ|DMA_PTE_WRITE)) == 0)
return -EINVAL;
prot &= DMA_PTE_READ | DMA_PTE_WRITE | DMA_PTE_SNP;
if (!sg) {
sg_res = nr_pages;
pteval = ((phys_addr_t)phys_pfn << VTD_PAGE_SHIFT) | prot;
}
while (nr_pages > 0) {
uint64_t tmp;
if (!sg_res) {
unsigned int pgoff = sg->offset & ~PAGE_MASK;
sg_res = aligned_nrpages(sg->offset, sg->length);
sg->dma_address = ((dma_addr_t)iov_pfn << VTD_PAGE_SHIFT) + pgoff;
sg->dma_length = sg->length;
pteval = (sg_phys(sg) - pgoff) | prot;
phys_pfn = pteval >> VTD_PAGE_SHIFT;
}
if (!pte) {
largepage_lvl = hardware_largepage_caps(domain, iov_pfn, phys_pfn, sg_res);
first_pte = pte = pfn_to_dma_pte(domain, iov_pfn, &largepage_lvl);
if (!pte)
return -ENOMEM;
/* It is large page*/
if (largepage_lvl > 1) {
unsigned long nr_superpages, end_pfn;
pteval |= DMA_PTE_LARGE_PAGE;
lvl_pages = lvl_to_nr_pages(largepage_lvl);
nr_superpages = sg_res / lvl_pages;
end_pfn = iov_pfn + nr_superpages * lvl_pages - 1;
/*
* Ensure that old small page tables are
* removed to make room for superpage(s).
* We're adding new large pages, so make sure
* we don't remove their parent tables.
*/
dma_pte_free_pagetable(domain, iov_pfn, end_pfn,
largepage_lvl + 1);
} else {
pteval &= ~(uint64_t)DMA_PTE_LARGE_PAGE;
}
}
/* We don't need lock here, nobody else
* touches the iova range
*/
tmp = cmpxchg64_local(&pte->val, 0ULL, pteval);
if (tmp) {
static int dumps = 5;
pr_crit("ERROR: DMA PTE for vPFN 0x%lx already set (to %llx not %llx)\n",
iov_pfn, tmp, (unsigned long long)pteval);
if (dumps) {
dumps--;
debug_dma_dump_mappings(NULL);
}
WARN_ON(1);
}
lvl_pages = lvl_to_nr_pages(largepage_lvl);
BUG_ON(nr_pages < lvl_pages);
BUG_ON(sg_res < lvl_pages);
nr_pages -= lvl_pages;
iov_pfn += lvl_pages;
phys_pfn += lvl_pages;
pteval += lvl_pages * VTD_PAGE_SIZE;
sg_res -= lvl_pages;
/* If the next PTE would be the first in a new page, then we
need to flush the cache on the entries we've just written.
And then we'll need to recalculate 'pte', so clear it and
let it get set again in the if (!pte) block above.
If we're done (!nr_pages) we need to flush the cache too.
Also if we've been setting superpages, we may need to
recalculate 'pte' and switch back to smaller pages for the
end of the mapping, if the trailing size is not enough to
use another superpage (i.e. sg_res < lvl_pages). */
pte++;
if (!nr_pages || first_pte_in_page(pte) ||
(largepage_lvl > 1 && sg_res < lvl_pages)) {
domain_flush_cache(domain, first_pte,
(void *)pte - (void *)first_pte);
pte = NULL;
}
if (!sg_res && nr_pages)
sg = sg_next(sg);
}
return 0;
}
| 0
|
181,663
|
long ContentEncoding::ParseCompressionEntry(long long start, long long size,
IMkvReader* pReader,
ContentCompression* compression) {
assert(pReader);
assert(compression);
long long pos = start;
const long long stop = start + size;
bool valid = false;
while (pos < stop) {
long long id, size;
const long status = ParseElementHeader(pReader, pos, stop, id, size);
if (status < 0) // error
return status;
if (id == 0x254) {
long long algo = UnserializeUInt(pReader, pos, size);
if (algo < 0)
return E_FILE_FORMAT_INVALID;
compression->algo = algo;
valid = true;
} else if (id == 0x255) {
if (size <= 0)
return E_FILE_FORMAT_INVALID;
const size_t buflen = static_cast<size_t>(size);
unsigned char* buf = SafeArrayAlloc<unsigned char>(1, buflen);
if (buf == NULL)
return -1;
const int read_status =
pReader->Read(pos, static_cast<long>(buflen), buf);
if (read_status) {
delete[] buf;
return status;
}
compression->settings = buf;
compression->settings_len = buflen;
}
pos += size; // consume payload
if (pos > stop)
return E_FILE_FORMAT_INVALID;
}
if (!valid)
return E_FILE_FORMAT_INVALID;
return 0;
}
| 0
|
308,973
|
DEFINE_TRACE(RuleFeature)
{
visitor->trace(rule);
}
| 0
|
174,027
|
bool RenderFrameDevToolsAgentHost::AttachSession(DevToolsSession* session) {
if (!ShouldAllowSession(session))
return false;
protocol::EmulationHandler* emulation_handler =
new protocol::EmulationHandler();
session->AddHandler(base::WrapUnique(new protocol::BrowserHandler()));
session->AddHandler(base::WrapUnique(
new protocol::DOMHandler(session->client()->MayAffectLocalFiles())));
session->AddHandler(base::WrapUnique(emulation_handler));
session->AddHandler(base::WrapUnique(new protocol::InputHandler()));
session->AddHandler(base::WrapUnique(new protocol::InspectorHandler()));
session->AddHandler(base::WrapUnique(new protocol::IOHandler(
GetIOContext())));
session->AddHandler(base::WrapUnique(new protocol::MemoryHandler()));
session->AddHandler(base::WrapUnique(new protocol::NetworkHandler(
GetId(),
frame_tree_node_ ? frame_tree_node_->devtools_frame_token()
: base::UnguessableToken(),
GetIOContext())));
session->AddHandler(base::WrapUnique(new protocol::SchemaHandler()));
session->AddHandler(base::WrapUnique(new protocol::ServiceWorkerHandler()));
session->AddHandler(base::WrapUnique(new protocol::StorageHandler()));
session->AddHandler(base::WrapUnique(new protocol::TargetHandler(
session->client()->MayAttachToBrowser()
? protocol::TargetHandler::AccessMode::kRegular
: protocol::TargetHandler::AccessMode::kAutoAttachOnly,
GetId(), GetRendererChannel(), session->GetRootSession())));
session->AddHandler(base::WrapUnique(new protocol::PageHandler(
emulation_handler, session->client()->MayAffectLocalFiles())));
session->AddHandler(base::WrapUnique(new protocol::SecurityHandler()));
if (!frame_tree_node_ || !frame_tree_node_->parent()) {
session->AddHandler(base::WrapUnique(
new protocol::TracingHandler(frame_tree_node_, GetIOContext())));
}
if (sessions().empty()) {
bool use_video_capture_api = true;
#ifdef OS_ANDROID
if (!CompositorImpl::IsInitialized())
use_video_capture_api = false;
#endif
if (!use_video_capture_api)
frame_trace_recorder_.reset(new DevToolsFrameTraceRecorder());
GrantPolicy();
#if defined(OS_ANDROID)
GetWakeLock()->RequestWakeLock();
#endif
}
return true;
}
| 0
|
184,793
|
bool GetErrorQuery::End(base::subtle::Atomic32 submit_count) {
MarkAsPending(submit_count);
return MarkAsCompleted(manager()->decoder()->GetErrorState()->GetGLError());
}
| 0
|
389,946
|
CertificateRequest::~CertificateRequest()
{
STL::for_each(certificate_authorities_.begin(),
certificate_authorities_.end(),
del_ptr_zero()) ;
}
| 0
|
508,721
|
int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
const unsigned char *key, const unsigned char *iv)
{
return EVP_CipherInit(ctx, cipher, key, iv, 0);
}
| 0
|
10,719
|
void ExtensionWebContentsObserver::RenderViewCreated(
content::RenderViewHost* render_view_host) {
const Extension* extension = GetExtension(render_view_host);
if (!extension)
return;
content::RenderProcessHost* process = render_view_host->GetProcess();
if (type == Manifest::TYPE_EXTENSION ||
type == Manifest::TYPE_LEGACY_PACKAGED_APP ||
(type == Manifest::TYPE_PLATFORM_APP &&
extension->location() == Manifest::COMPONENT)) {
content::ChildProcessSecurityPolicy::GetInstance()->GrantScheme(
process->GetID(), content::kChromeUIScheme);
}
if (type == Manifest::TYPE_EXTENSION ||
type == Manifest::TYPE_LEGACY_PACKAGED_APP) {
ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context_);
if (prefs->AllowFileAccess(extension->id())) {
content::ChildProcessSecurityPolicy::GetInstance()->GrantScheme(
process->GetID(), url::kFileScheme);
}
}
render_view_host->Send(new ExtensionMsg_ActivateExtension(extension->id()));
}
| 1
|
470,923
|
gs_lib_ctx_stash_sanitized_arg(gs_lib_ctx_t *ctx, const char *arg)
{
gs_lib_ctx_core_t *core;
size_t len;
const char *p;
int elide = 0;
if (ctx == NULL || ctx->core == NULL || arg == NULL)
return 0;
/* Sanitize arg */
switch(*arg)
{
case '-':
switch (arg[1])
{
case 0: /* We can let - through unchanged */
case '-': /* Need to check for permitted file lists */
/* By default, we want to keep the key, but lose the value */
p = arg+2;
while (*p && *p != '=')
p++;
if (*p == '=')
p++;
if (*p == 0)
break; /* No value to elide */
/* Check for our blocked values here */
#define ARG_MATCHES(STR, ARG, LEN) \
(strlen(STR) == LEN && !memcmp(STR, ARG, LEN))
if (ARG_MATCHES("permit-file-read", arg+2, p-arg-3))
elide=1;
if (ARG_MATCHES("permit-file-write", arg+2, p-arg-3))
elide=1;
if (ARG_MATCHES("permit-file-control", arg+2, p-arg-3))
elide=1;
if (ARG_MATCHES("permit-file-all", arg+2, p-arg-3))
elide=1;
#undef ARG_MATCHES
/* Didn't match a blocked value, so allow it. */
break;
case 'd': /* We can let -dFoo=<whatever> through unchanged */
case 'D': /* We can let -DFoo=<whatever> through unchanged */
case 'r': /* We can let -r through unchanged */
case 'Z': /* We can let -Z through unchanged */
case 'g': /* We can let -g through unchanged */
case 'P': /* We can let -P through unchanged */
case '+': /* We can let -+ through unchanged */
case '_': /* We can let -_ through unchanged */
case 'u': /* We can let -u through unchanged */
case 'q': /* We can let -q through unchanged */
break;
case 'I': /* Let through the I, but hide anything else */
case 'f': /* Let through the I, but hide anything else */
if (arg[2] == 0)
break;
p = arg+2;
while (*p == 32)
p++;
elide = 1;
break;
case 's':
case 'S':
/* By default, we want to keep the key, but lose the value */
p = arg+2;
while (*p && *p != '=')
p++;
if (*p == '=')
p++;
if (*p == 0)
break; /* No value to elide */
/* Check for our whitelisted values here */
#define ARG_MATCHES(STR, ARG, LEN) \
(strlen(STR) == LEN && !memcmp(STR, ARG, LEN))
if (ARG_MATCHES("DEFAULTPAPERSIZE", arg+2, p-arg-3))
break;
if (ARG_MATCHES("DEVICE", arg+2, p-arg-3))
break;
if (ARG_MATCHES("PAPERSIZE", arg+2, p-arg-3))
break;
if (ARG_MATCHES("SUBSTFONT", arg+2, p-arg-3))
break;
if (ARG_MATCHES("ColorConversionStrategy", arg+2, p-arg-3))
break;
if (ARG_MATCHES("NupControl", arg+2, p-arg-3))
break;
if (ARG_MATCHES("PageList", arg+2, p-arg-3))
break;
if (ARG_MATCHES("ProcessColorModel", arg+2, p-arg-3))
break;
#undef ARG_MATCHES
/* Didn't match a whitelisted value, so elide it. */
elide = 1;
break;
default:
/* Shouldn't happen, but elide it just in case */
arg = "?";
break;
}
break;
case '@':
/* Shouldn't happen */
default:
/* Anything else should be elided */
arg = "?";
break;
}
core = ctx->core;
if (elide)
len = p-arg;
else
len = strlen(arg);
if (core->arg_max == core->argc) {
char **argv;
int newlen = core->arg_max * 2;
if (newlen == 0)
newlen = 4;
argv = (char **)gs_alloc_bytes(ctx->core->memory, sizeof(char *) * newlen,
"gs_lib_ctx_args");
if (argv == NULL)
return gs_error_VMerror;
if (core->argc > 0) {
memcpy(argv, core->argv, sizeof(char *) * core->argc);
gs_free_object(ctx->memory, core->argv, "gs_lib_ctx_args");
}
core->argv = argv;
core->arg_max = newlen;
}
core->argv[core->argc] = (char *)gs_alloc_bytes(ctx->core->memory, len+1+elide,
"gs_lib_ctx_arg");
if (core->argv[core->argc] == NULL)
return gs_error_VMerror;
memcpy(core->argv[core->argc], arg, len);
if (elide) {
core->argv[core->argc][len] = '?';
}
core->argv[core->argc][len+elide] = 0;
core->argc++;
return 0;
}
| 0
|
246,299
|
bool Extension::IsDisallowedExperimentalPermission(
ExtensionAPIPermission::ID permission) const {
return permission == ExtensionAPIPermission::kExperimental &&
!CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableExperimentalExtensionApis);
}
| 0
|
149,593
|
add_msg_hist(
char_u *s,
int len, // -1 for undetermined length
int attr)
{
struct msg_hist *p;
if (msg_hist_off || msg_silent != 0)
return;
// Don't let the message history get too big
while (msg_hist_len > MAX_MSG_HIST_LEN)
(void)delete_first_msg();
// allocate an entry and add the message at the end of the history
p = ALLOC_ONE(struct msg_hist);
if (p != NULL)
{
if (len < 0)
len = (int)STRLEN(s);
// remove leading and trailing newlines
while (len > 0 && *s == '\n')
{
++s;
--len;
}
while (len > 0 && s[len - 1] == '\n')
--len;
p->msg = vim_strnsave(s, len);
p->next = NULL;
p->attr = attr;
if (last_msg_hist != NULL)
last_msg_hist->next = p;
last_msg_hist = p;
if (first_msg_hist == NULL)
first_msg_hist = last_msg_hist;
++msg_hist_len;
}
}
| 0
|
503,846
|
Status ServerConnectionImpl::onMessageBeginBase() {
if (!resetStreamCalled()) {
ASSERT(active_request_ == nullptr);
active_request_ = std::make_unique<ActiveRequest>(*this, std::move(bytes_meter_before_stream_));
if (resetStreamCalled()) {
return codecClientError("cannot create new streams after calling reset");
}
active_request_->request_decoder_ = &callbacks_.newStream(active_request_->response_encoder_);
// Check for pipelined request flood as we prepare to accept a new request.
// Parse errors that happen prior to onMessageBegin result in stream termination, it is not
// possible to overflow output buffers with early parse errors.
RETURN_IF_ERROR(doFloodProtectionChecks());
}
return okStatus();
}
| 0
|
173,408
|
void OmniboxViewWin::OnCopy() {
string16 text(GetSelectedText());
if (text.empty())
return;
CHARRANGE sel;
GURL url;
bool write_url = false;
GetSel(sel);
model_->AdjustTextForCopy(sel.cpMin, IsSelectAll(), &text, &url, &write_url);
ui::ScopedClipboardWriter scw(g_browser_process->clipboard());
scw.WriteText(text);
if (write_url) {
scw.WriteBookmark(text, url.spec());
scw.WriteHyperlink(net::EscapeForHTML(text), url.spec());
}
}
| 0
|
355,450
|
static struct ip_tunnel * ipip6_tunnel_locate(struct net *net,
struct ip_tunnel_parm *parms, int create)
{
__be32 remote = parms->iph.daddr;
__be32 local = parms->iph.saddr;
struct ip_tunnel *t, **tp, *nt;
struct net_device *dev;
char name[IFNAMSIZ];
struct sit_net *sitn = net_generic(net, sit_net_id);
for (tp = __ipip6_bucket(sitn, parms); (t = *tp) != NULL; tp = &t->next) {
if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
return t;
}
if (!create)
goto failed;
if (parms->name[0])
strlcpy(name, parms->name, IFNAMSIZ);
else
sprintf(name, "sit%%d");
dev = alloc_netdev(sizeof(*t), name, ipip6_tunnel_setup);
if (dev == NULL)
return NULL;
dev_net_set(dev, net);
if (strchr(name, '%')) {
if (dev_alloc_name(dev, name) < 0)
goto failed_free;
}
nt = netdev_priv(dev);
dev->init = ipip6_tunnel_init;
nt->parms = *parms;
if (parms->i_flags & SIT_ISATAP)
dev->priv_flags |= IFF_ISATAP;
if (register_netdevice(dev) < 0)
goto failed_free;
dev_hold(dev);
ipip6_tunnel_link(sitn, nt);
return nt;
failed_free:
free_netdev(dev);
failed:
return NULL;
}
| 0
|
460,997
|
static void mptsas_scsi_realize(PCIDevice *dev, Error **errp)
{
MPTSASState *s = MPT_SAS(dev);
Error *err = NULL;
int ret;
dev->config[PCI_LATENCY_TIMER] = 0;
dev->config[PCI_INTERRUPT_PIN] = 0x01;
if (s->msi != ON_OFF_AUTO_OFF) {
ret = msi_init(dev, 0, 1, true, false, &err);
/* Any error other than -ENOTSUP(board's MSI support is broken)
* is a programming error */
assert(!ret || ret == -ENOTSUP);
if (ret && s->msi == ON_OFF_AUTO_ON) {
/* Can't satisfy user's explicit msi=on request, fail */
error_append_hint(&err, "You have to use msi=auto (default) or "
"msi=off with this machine type.\n");
error_propagate(errp, err);
return;
}
assert(!err || s->msi == ON_OFF_AUTO_AUTO);
/* With msi=auto, we fall back to MSI off silently */
error_free(err);
/* Only used for migration. */
s->msi_in_use = (ret == 0);
}
memory_region_init_io(&s->mmio_io, OBJECT(s), &mptsas_mmio_ops, s,
"mptsas-mmio", 0x4000);
memory_region_init_io(&s->port_io, OBJECT(s), &mptsas_port_ops, s,
"mptsas-io", 256);
memory_region_init_io(&s->diag_io, OBJECT(s), &mptsas_diag_ops, s,
"mptsas-diag", 0x10000);
pci_register_bar(dev, 0, PCI_BASE_ADDRESS_SPACE_IO, &s->port_io);
pci_register_bar(dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY |
PCI_BASE_ADDRESS_MEM_TYPE_32, &s->mmio_io);
pci_register_bar(dev, 2, PCI_BASE_ADDRESS_SPACE_MEMORY |
PCI_BASE_ADDRESS_MEM_TYPE_32, &s->diag_io);
if (!s->sas_addr) {
s->sas_addr = ((NAA_LOCALLY_ASSIGNED_ID << 24) |
IEEE_COMPANY_LOCALLY_ASSIGNED) << 36;
s->sas_addr |= (pci_dev_bus_num(dev) << 16);
s->sas_addr |= (PCI_SLOT(dev->devfn) << 8);
s->sas_addr |= PCI_FUNC(dev->devfn);
}
s->max_devices = MPTSAS_NUM_PORTS;
s->request_bh = qemu_bh_new(mptsas_fetch_requests, s);
scsi_bus_new(&s->bus, sizeof(s->bus), &dev->qdev, &mptsas_scsi_info, NULL);
}
| 0
|
464,366
|
static long vhost_vdpa_set_config(struct vhost_vdpa *v,
struct vhost_vdpa_config __user *c)
{
struct vdpa_device *vdpa = v->vdpa;
const struct vdpa_config_ops *ops = vdpa->config;
struct vhost_vdpa_config config;
unsigned long size = offsetof(struct vhost_vdpa_config, buf);
u8 *buf;
if (copy_from_user(&config, c, size))
return -EFAULT;
if (vhost_vdpa_config_validate(v, &config))
return -EINVAL;
buf = vmemdup_user(c->buf, config.len);
if (IS_ERR(buf))
return PTR_ERR(buf);
ops->set_config(vdpa, config.off, buf, config.len);
kvfree(buf);
return 0;
}
| 0
|
486,839
|
void KrecipesView::showRecipes( const QList<int> &recipeIDs )
{
if ( viewPanel->loadRecipes( recipeIDs ) )
slotSetPanel( RecipeView );
}
| 0
|
14,659
|
do_REMOTE_syscall()
{
int condor_sysnum;
int rval = -1, result = -1, fd = -1, mode = -1, uid = -1, gid = -1;
int length = -1;
condor_errno_t terrno;
char *path = NULL, *buffer = NULL;
void *buf = NULL;
syscall_sock->decode();
dprintf(D_SYSCALLS, "About to decode condor_sysnum\n");
rval = syscall_sock->code(condor_sysnum);
if (!rval) {
MyString err_msg;
err_msg = "Can no longer talk to condor_starter <";
err_msg += syscall_sock->peer_ip_str();
err_msg += ':';
err_msg += syscall_sock->peer_port();
err_msg += '>';
thisRemoteResource->closeClaimSock();
/* It is possible that we are failing to read the
syscall number because the starter went away
because we *asked* it to go away. Don't be shocked
and surprised if the startd/starter actually did
what we asked when we deactivated the claim */
if ( thisRemoteResource->wasClaimDeactivated() ) {
return 0;
}
if( Shadow->supportsReconnect() ) {
dprintf( D_ALWAYS, "%s\n", err_msg.Value() );
const char* txt = "Socket between submit and execute hosts "
"closed unexpectedly";
Shadow->logDisconnectedEvent( txt );
if (!Shadow->shouldAttemptReconnect(thisRemoteResource)) {
dprintf(D_ALWAYS, "This job cannot reconnect to starter, so job exiting\n");
Shadow->gracefulShutDown();
EXCEPT( "%s", err_msg.Value() );
}
Shadow->reconnect();
return 0;
} else {
EXCEPT( "%s", err_msg.Value() );
}
}
dprintf(D_SYSCALLS,
"Got request for syscall %s (%d)\n",
shadow_syscall_name(condor_sysnum), condor_sysnum);
switch( condor_sysnum ) {
case CONDOR_register_starter_info:
{
ClassAd ad;
result = ( ad.initFromStream(*syscall_sock) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pseudo_register_starter_info( &ad );
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_register_job_info:
{
ClassAd ad;
result = ( ad.initFromStream(*syscall_sock) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pseudo_register_job_info( &ad );
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_get_job_info:
{
ClassAd *ad = NULL;
bool delete_ad;
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pseudo_get_job_info(ad, delete_ad);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
} else {
result = ( ad->put(*syscall_sock) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
if ( delete_ad ) {
delete ad;
}
return 0;
}
case CONDOR_get_user_info:
{
ClassAd *ad = NULL;
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pseudo_get_user_info(ad);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
} else {
result = ( ad->put(*syscall_sock) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_job_exit:
{
int status=0;
int reason=0;
ClassAd ad;
result = ( syscall_sock->code(status) );
ASSERT( result );
result = ( syscall_sock->code(reason) );
ASSERT( result );
result = ( ad.initFromStream(*syscall_sock) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pseudo_job_exit(status, reason, &ad);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return -1;
}
case CONDOR_job_termination:
{
ClassAd ad;
result = ( ad.initFromStream(*syscall_sock) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pseudo_job_termination( &ad );
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_begin_execution:
{
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pseudo_begin_execution();
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_open:
{
open_flags_t flags;
int lastarg;
result = ( syscall_sock->code(flags) );
ASSERT( result );
dprintf( D_SYSCALLS, " flags = %d\n", flags );
result = ( syscall_sock->code(lastarg) );
ASSERT( result );
dprintf( D_SYSCALLS, " lastarg = %d\n", lastarg );
path = NULL;
result = ( syscall_sock->code(path) );
dprintf( D_SYSCALLS, " path = %s\n", path );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
bool access_ok;
if ( flags & O_RDONLY ) {
access_ok = read_access(path);
} else {
access_ok = write_access(path);
}
errno = 0;
if ( access_ok ) {
rval = safe_open_wrapper_follow( path , flags , lastarg);
} else {
rval = -1;
errno = EACCES;
}
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char *)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_close:
{
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = close( fd);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_read:
{
size_t len;
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(len) );
ASSERT( result );
dprintf( D_SYSCALLS, " len = %ld\n", (long)len );
buf = (void *)malloc( (unsigned)len );
memset( buf, 0, (unsigned)len );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = read( fd , buf , len);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
if( rval >= 0 ) {
result = ( syscall_sock->code_bytes_bool(buf, rval) );
ASSERT( result );
}
free( buf );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_write:
{
size_t len;
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(len) );
ASSERT( result );
dprintf( D_SYSCALLS, " len = %ld\n", (long)len );
buf = (void *)malloc( (unsigned)len );
memset( buf, 0, (unsigned)len );
result = ( syscall_sock->code_bytes_bool(buf, len) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = write( fd , buf , len);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( buf );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_lseek:
case CONDOR_lseek64:
case CONDOR_llseek:
{
off_t offset;
int whence;
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(offset) );
ASSERT( result );
dprintf( D_SYSCALLS, " offset = %ld\n", (long)offset );
result = ( syscall_sock->code(whence) );
ASSERT( result );
dprintf( D_SYSCALLS, " whence = %d\n", whence );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = lseek( fd , offset , whence);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_unlink:
{
path = NULL;
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
if ( write_access(path) ) {
errno = 0;
rval = unlink( path);
} else {
rval = -1;
errno = EACCES;
}
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char *)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_rename:
{
char * from;
char * to;
to = NULL;
from = NULL;
result = ( syscall_sock->code(from) );
ASSERT( result );
dprintf( D_SYSCALLS, " from = %s\n", from );
result = ( syscall_sock->code(to) );
ASSERT( result );
dprintf( D_SYSCALLS, " to = %s\n", to );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
if ( write_access(from) && write_access(to) ) {
errno = 0;
rval = rename( from , to);
} else {
rval = -1;
errno = EACCES;
}
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char *)to );
free( (char *)from );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_register_mpi_master_info:
{
ClassAd ad;
result = ( ad.initFromStream(*syscall_sock) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pseudo_register_mpi_master_info( &ad );
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_mkdir:
{
path = NULL;
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(mode) );
ASSERT( result );
dprintf( D_SYSCALLS, " mode = %d\n", mode );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
if ( write_access(path) ) {
errno = 0;
rval = mkdir(path,mode);
} else {
rval = -1;
errno = EACCES;
}
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char *)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_rmdir:
{
path = NULL;
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
if ( write_access(path) ) {
errno = 0;
rval = rmdir( path);
} else {
rval = -1;
errno = EACCES;
}
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_fsync:
{
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fs = %d\n", fd );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = fsync(fd);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_get_file_info_new:
{
char * logical_name;
char * actual_url;
actual_url = NULL;
logical_name = NULL;
ASSERT( syscall_sock->code(logical_name) );
ASSERT( syscall_sock->end_of_message() );;
errno = (condor_errno_t)0;
rval = pseudo_get_file_info_new( logical_name , actual_url );
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, (int)terrno );
syscall_sock->encode();
ASSERT( syscall_sock->code(rval) );
if( rval < 0 ) {
ASSERT( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
ASSERT( syscall_sock->code(actual_url) );
}
free( (char *)actual_url );
free( (char *)logical_name );
ASSERT( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_ulog:
{
ClassAd ad;
result = ( ad.initFromStream(*syscall_sock) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
rval = pseudo_ulog(&ad);
dprintf( D_SYSCALLS, "\trval = %d\n", rval );
return 0;
}
case CONDOR_get_job_attr:
{
char * attrname = 0;
assert( syscall_sock->code(attrname) );
assert( syscall_sock->end_of_message() );;
errno = (condor_errno_t)0;
MyString expr;
if ( thisRemoteResource->allowRemoteReadAttributeAccess(attrname) ) {
rval = pseudo_get_job_attr( attrname , expr);
terrno = (condor_errno_t)errno;
} else {
rval = -1;
terrno = (condor_errno_t)EACCES;
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, (int)terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
if( rval >= 0 ) {
assert( syscall_sock->put(expr.Value()) );
}
free( (char *)attrname );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_set_job_attr:
{
char * attrname = 0;
char * expr = 0;
assert( syscall_sock->code(expr) );
assert( syscall_sock->code(attrname) );
assert( syscall_sock->end_of_message() );;
errno = (condor_errno_t)0;
if ( thisRemoteResource->allowRemoteWriteAttributeAccess(attrname) ) {
rval = pseudo_set_job_attr( attrname , expr , true );
terrno = (condor_errno_t)errno;
} else {
rval = -1;
terrno = (condor_errno_t)EACCES;
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, (int)terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
free( (char *)expr );
free( (char *)attrname );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_constrain:
{
char * expr = 0;
assert( syscall_sock->code(expr) );
assert( syscall_sock->end_of_message() );;
errno = (condor_errno_t)0;
if ( thisRemoteResource->allowRemoteWriteAttributeAccess(ATTR_REQUIREMENTS) ) {
rval = pseudo_constrain( expr);
terrno = (condor_errno_t)errno;
} else {
rval = -1;
terrno = (condor_errno_t)EACCES;
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, (int)terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
free( (char *)expr );
assert( syscall_sock->end_of_message() );;
return 0;
}
case CONDOR_get_sec_session_info:
{
MyString starter_reconnect_session_info;
MyString starter_filetrans_session_info;
MyString reconnect_session_id;
MyString reconnect_session_info;
MyString reconnect_session_key;
MyString filetrans_session_id;
MyString filetrans_session_info;
MyString filetrans_session_key;
bool socket_default_crypto = syscall_sock->get_encryption();
if( !socket_default_crypto ) {
syscall_sock->set_crypto_mode(true);
}
assert( syscall_sock->code(starter_reconnect_session_info) );
assert( syscall_sock->code(starter_filetrans_session_info) );
assert( syscall_sock->end_of_message() );
errno = (condor_errno_t)0;
rval = pseudo_get_sec_session_info(
starter_reconnect_session_info.Value(),
reconnect_session_id,
reconnect_session_info,
reconnect_session_key,
starter_filetrans_session_info.Value(),
filetrans_session_id,
filetrans_session_info,
filetrans_session_key );
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, (int)terrno );
syscall_sock->encode();
assert( syscall_sock->code(rval) );
if( rval < 0 ) {
assert( syscall_sock->code(terrno) );
}
else {
assert( syscall_sock->code(reconnect_session_id) );
assert( syscall_sock->code(reconnect_session_info) );
assert( syscall_sock->code(reconnect_session_key) );
assert( syscall_sock->code(filetrans_session_id) );
assert( syscall_sock->code(filetrans_session_info) );
assert( syscall_sock->code(filetrans_session_key) );
}
assert( syscall_sock->end_of_message() );
if( !socket_default_crypto ) {
syscall_sock->set_crypto_mode( false ); // restore default
}
return 0;
}
#ifdef WIN32
#else
case CONDOR_pread:
{
size_t len, offset;
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(len) );
ASSERT( result );
dprintf( D_SYSCALLS, " len = %ld\n", (long)len );
result = ( syscall_sock->code(offset) );
ASSERT( result );
dprintf( D_SYSCALLS, " offset = %ld\n", (long)offset );
buf = (void *)malloc( (unsigned)len );
memset( buf, 0, (unsigned)len );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pread( fd , buf , len, offset );
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(buf, rval) );
ASSERT( result );
}
free( buf );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_pwrite:
{
size_t len, offset;
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(len) );
ASSERT( result );
dprintf( D_SYSCALLS, " len = %ld\n", (long)len );
result = ( syscall_sock->code(offset) );
ASSERT( result );
dprintf( D_SYSCALLS, " offset = %ld\n", (long)offset);
buf = malloc( (unsigned)len );
memset( buf, 0, (unsigned)len );
result = ( syscall_sock->code_bytes_bool(buf, len) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = pwrite( fd , buf , len, offset);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( buf );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_sread:
{
size_t len, offset, stride_length, stride_skip;
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(len) );
ASSERT( result );
dprintf( D_SYSCALLS, " len = %ld\n", (long)len );
result = ( syscall_sock->code(offset) );
ASSERT( result );
dprintf( D_SYSCALLS, " offset = %ld\n", (long)offset );
result = ( syscall_sock->code(stride_length) );
ASSERT( result );
dprintf( D_SYSCALLS, " stride_length = %ld\n", (long)stride_length);
result = ( syscall_sock->code(stride_skip) );
ASSERT( result );
dprintf( D_SYSCALLS, " stride_skip = %ld\n", (long)stride_skip);
buf = (void *)malloc( (unsigned)len );
memset( buf, 0, (unsigned)len );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = EINVAL;
rval = -1;
unsigned int total = 0;
buffer = (char*)buf;
while(total < len && stride_length > 0) {
if(len - total < stride_length) {
stride_length = len - total;
}
rval = pread( fd, (void*)&buffer[total], stride_length, offset );
if(rval >= 0) {
total += rval;
offset += stride_skip;
}
else {
break;
}
}
syscall_sock->encode();
if( rval < 0 ) {
result = ( syscall_sock->code(rval) );
ASSERT( result );
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", total, terrno );
result = ( syscall_sock->code(total) );
ASSERT( result );
dprintf( D_ALWAYS, "buffer: %s\n", buffer);
result = ( syscall_sock->code_bytes_bool(buf, total) );
ASSERT( result );
}
free( buf );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_swrite:
{
size_t len, offset, stride_length, stride_skip;
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(len) );
ASSERT( result );
dprintf( D_SYSCALLS, " len = %ld\n", (long)len );
result = ( syscall_sock->code(offset) );
ASSERT( result );
dprintf( D_SYSCALLS, " offset = %ld\n", (long)offset);
result = ( syscall_sock->code(stride_length) );
ASSERT( result );
dprintf( D_SYSCALLS, " stride_length = %ld\n", (long)stride_length);
result = ( syscall_sock->code(stride_skip) );
ASSERT( result );
dprintf( D_SYSCALLS, " stride_skip = %ld\n", (long)stride_skip);
buf = (void *)malloc( (unsigned)len );
memset( buf, 0, (unsigned)len );
result = ( syscall_sock->code_bytes_bool(buf, len) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = EINVAL;
rval = -1;
unsigned int total = 0;
buffer = (char*)buf;
while(total < len && stride_length > 0) {
if(len - total < stride_length) {
stride_length = len - total;
}
rval = pwrite( fd, (void*)&buffer[total], stride_length, offset);
if(rval >= 0) {
total += rval;
offset += stride_skip;
}
else {
break;
}
}
syscall_sock->encode();
if( rval < 0 ) {
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d (%s)\n", rval, terrno, strerror(errno));
result = ( syscall_sock->code(rval) );
ASSERT( result );
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
dprintf( D_SYSCALLS, "\trval = %d, errno = %d (%s)\n", total, terrno, strerror(errno));
result = ( syscall_sock->code(total) );
ASSERT( result );
}
free( buf );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_rmall:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
if ( write_access(path) ) {
rval = rmdir(path);
if(rval == -1) {
Directory dir(path);
if(dir.Remove_Entire_Directory()) {
rval = rmdir(path);
}
}
} else {
rval = -1;
errno = EACCES;
}
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char *)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_getfile:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
fd = safe_open_wrapper_follow( path, O_RDONLY );
if(fd >= 0) {
struct stat info;
stat(path, &info);
length = info.st_size;
buf = (void *)malloc( (unsigned)length );
memset( buf, 0, (unsigned)length );
errno = 0;
rval = read( fd , buf , length);
} else {
rval = fd;
}
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(buf, rval) );
ASSERT( result );
}
free( (char *)path );
free( buf );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_putfile:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf(D_SYSCALLS, " path: %s\n", path);
result = ( syscall_sock->code(mode) );
ASSERT( result );
dprintf(D_SYSCALLS, " mode: %d\n", mode);
result = ( syscall_sock->code(length) );
ASSERT( result );
dprintf(D_SYSCALLS, " length: %d\n", length);
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
fd = safe_open_wrapper_follow(path, O_CREAT | O_WRONLY | O_TRUNC, mode);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(fd) );
ASSERT( result );
if( fd < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
int num = -1;
if(fd >= 0) {
syscall_sock->decode();
buffer = (char*)malloc( (unsigned)length );
memset( buffer, 0, (unsigned)length );
result = ( syscall_sock->code_bytes_bool(buffer, length) );
ASSERT( result );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
num = write(fd, buffer, length);
}
else {
dprintf(D_SYSCALLS, "Unable to put file %s\n", path);
}
close(fd);
syscall_sock->encode();
result = ( syscall_sock->code(num) );
ASSERT( result );
if( num < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free((char*)path);
free((char*)buffer);
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_getlongdir:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = -1;
MyString msg, check;
const char *next;
Directory directory(path);
struct stat stat_buf;
char line[1024];
while((next = directory.Next())) {
dprintf(D_ALWAYS, "next: %s\n", next);
msg.sprintf_cat("%s\n", next);
check.sprintf("%s%c%s", path, DIR_DELIM_CHAR, next);
rval = stat(check.Value(), &stat_buf);
terrno = (condor_errno_t)errno;
if(rval == -1) {
break;
}
if(stat_string(line, &stat_buf) < 0) {
rval = -1;
break;
}
msg.sprintf_cat("%s", line);
}
terrno = (condor_errno_t)errno;
if(msg.Length() > 0) {
msg.sprintf_cat("\n"); // Needed to signify end of data
rval = msg.Length();
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->put(msg.Value()) );
ASSERT( result );
}
free((char*)path);
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_getdir:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = -1;
MyString msg;
const char *next;
Directory directory(path);
while((next = directory.Next())) {
msg.sprintf_cat(next);
msg.sprintf_cat("\n");
}
terrno = (condor_errno_t)errno;
if(msg.Length() > 0) {
msg.sprintf_cat("\n"); // Needed to signify end of data
rval = msg.Length();
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->put(msg.Value()) );
ASSERT( result );
}
free((char*)path);
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_whoami:
{
result = ( syscall_sock->code(length) );
ASSERT( result );
dprintf( D_SYSCALLS, " length = %d\n", length );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
buffer = (char*)malloc( (unsigned)length );
int size = 6;
if(length < size) {
rval = -1;
terrno = (condor_errno_t) ENOSPC;
}
else {
rval = sprintf(buffer, "CONDOR");
terrno = (condor_errno_t) errno;
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval != size) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(buffer, rval));
ASSERT( result );
}
free((char*)buffer);
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_whoareyou:
{
char *host = NULL;
result = ( syscall_sock->code(host) );
ASSERT( result );
dprintf( D_SYSCALLS, " host = %s\n", host );
result = ( syscall_sock->code(length) );
ASSERT( result );
dprintf( D_SYSCALLS, " length = %d\n", length );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
buffer = (char*)malloc( (unsigned)length );
int size = 7;
if(length < size) {
rval = -1;
terrno = (condor_errno_t) ENOSPC;
}
else {
rval = sprintf(buffer, "UNKNOWN");
terrno = (condor_errno_t) errno;
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval != size) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(buffer, rval));
ASSERT( result );
}
free((char*)buffer);
free((char*)host);
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_fstatfs:
{
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
#if defined(Solaris)
struct statvfs statfs_buf;
rval = fstatvfs(fd, &statfs_buf);
#else
struct statfs statfs_buf;
rval = fstatfs(fd, &statfs_buf);
#endif
terrno = (condor_errno_t)errno;
char line[1024];
if(rval == 0) {
if(statfs_string(line, &statfs_buf) < 0) {
rval = -1;
terrno = (condor_errno_t)errno;
}
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(line, 1024) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_fchown:
{
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(uid) );
ASSERT( result );
dprintf( D_SYSCALLS, " uid = %d\n", uid );
result = ( syscall_sock->code(gid) );
ASSERT( result );
dprintf( D_SYSCALLS, " gid = %d\n", gid );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = fchown(fd, uid, gid);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_fchmod:
{
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(mode) );
ASSERT( result );
dprintf( D_SYSCALLS, " mode = %d\n", mode );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = fchmod(fd, (mode_t)mode);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if(rval < 0) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_ftruncate:
{
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->code(length) );
ASSERT( result );
dprintf( D_SYSCALLS, " length = %d\n", length );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = ftruncate(fd, length);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if(rval < 0) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_link:
{
char *newpath = NULL;
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(newpath) );
ASSERT( result );
dprintf( D_SYSCALLS, " newpath = %s\n", newpath );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = link(path, newpath);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if(rval < 0) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free((char*)path);
free((char*)newpath);
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_symlink:
{
char *newpath = NULL;
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(newpath) );
ASSERT( result );
dprintf( D_SYSCALLS, " newpath = %s\n", newpath );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = symlink(path, newpath);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if(rval < 0) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free((char*)path);
free((char*)newpath);
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_readlink:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(length) );
ASSERT( result );
dprintf( D_SYSCALLS, " length = %d\n", length );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
char *lbuffer = (char*)malloc(length);
errno = 0;
rval = readlink(path, lbuffer, length);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(lbuffer, rval));
ASSERT( result );
}
free(lbuffer);
free(path);
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_lstat:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
struct stat stat_buf;
rval = lstat(path, &stat_buf);
terrno = (condor_errno_t)errno;
char line[1024];
if(rval == 0) {
if(stat_string(line, &stat_buf) < 0) {
rval = -1;
terrno = (condor_errno_t)errno;
}
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(line, 1024) );
ASSERT( result );
}
free( (char*)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_statfs:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
#if defined(Solaris)
struct statvfs statfs_buf;
rval = statvfs(path, &statfs_buf);
#else
struct statfs statfs_buf;
rval = statfs(path, &statfs_buf);
#endif
terrno = (condor_errno_t)errno;
char line[1024];
if(rval == 0) {
if(statfs_string(line, &statfs_buf) < 0) {
rval = -1;
terrno = (condor_errno_t)errno;
}
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(line, 1024) );
ASSERT( result );
}
free( (char*)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_chown:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(uid) );
ASSERT( result );
dprintf( D_SYSCALLS, " uid = %d\n", uid );
result = ( syscall_sock->code(gid) );
ASSERT( result );
dprintf( D_SYSCALLS, " gid = %d\n", gid );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = chown(path, uid, gid);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char*)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_lchown:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(uid) );
ASSERT( result );
dprintf( D_SYSCALLS, " uid = %d\n", uid );
result = ( syscall_sock->code(gid) );
ASSERT( result );
dprintf( D_SYSCALLS, " gid = %d\n", gid );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = lchown(path, uid, gid);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char*)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_truncate:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(length) );
ASSERT( result );
dprintf( D_SYSCALLS, " length = %d\n", length );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
if ( write_access(path) ) {
errno = 0;
rval = truncate(path, length);
} else {
rval = -1;
errno = EACCES;
}
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if(rval < 0) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char*)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
#endif // ! WIN32
case CONDOR_fstat:
{
result = ( syscall_sock->code(fd) );
ASSERT( result );
dprintf( D_SYSCALLS, " fd = %d\n", fd );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
struct stat stat_buf;
rval = fstat(fd, &stat_buf);
terrno = (condor_errno_t)errno;
char line[1024];
if(rval == 0) {
if(stat_string(line, &stat_buf) < 0) {
rval = -1;
terrno = (condor_errno_t)errno;
}
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(line, 1024) );
ASSERT( result );
}
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_stat:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
struct stat stat_buf;
rval = stat(path, &stat_buf);
terrno = (condor_errno_t)errno;
char line[1024];
if(rval == 0) {
if(stat_string(line, &stat_buf) < 0) {
rval = -1;
terrno = (condor_errno_t)errno;
}
}
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if( rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
else {
result = ( syscall_sock->code_bytes_bool(line, 1024) );
ASSERT( result );
}
free( (char*)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_access:
{
int flags = -1;
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(flags) );
ASSERT( result );
dprintf( D_SYSCALLS, " flags = %d\n", flags );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = access(path, flags);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if(rval < 0 ) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char*)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_chmod:
{
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(mode) );
ASSERT( result );
dprintf( D_SYSCALLS, " mode = %d\n", mode );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
errno = 0;
rval = chmod(path, mode);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if(rval < 0) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char*)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
case CONDOR_utime:
{
time_t actime = -1, modtime = -1;
result = ( syscall_sock->code(path) );
ASSERT( result );
dprintf( D_SYSCALLS, " path = %s\n", path );
result = ( syscall_sock->code(actime) );
ASSERT( result );
dprintf( D_SYSCALLS, " actime = %ld\n", actime );
result = ( syscall_sock->code(modtime) );
ASSERT( result );
dprintf( D_SYSCALLS, " modtime = %ld\n", modtime );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
struct utimbuf ut;
ut.actime = actime;
ut.modtime = modtime;
errno = 0;
rval = utime(path, &ut);
terrno = (condor_errno_t)errno;
dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno );
syscall_sock->encode();
result = ( syscall_sock->code(rval) );
ASSERT( result );
if(rval < 0) {
result = ( syscall_sock->code( terrno ) );
ASSERT( result );
}
free( (char*)path );
result = ( syscall_sock->end_of_message() );
ASSERT( result );
return 0;
}
default:
{
dprintf(D_ALWAYS, "ERROR: unknown syscall %d received\n", condor_sysnum );
return 0;
}
} /* End of switch on system call number */
return -1;
} /* End of do_REMOTE_syscall() procedure */
| 1
|
407,262
|
aspath_add_seq (struct aspath *aspath, as_t asno)
{
return aspath_add_asns (aspath, asno, AS_SEQUENCE, 1);
}
| 0
|
270,480
|
static int __init hugetlb_nrpages_setup(char *s)
{
unsigned long *mhp;
static unsigned long *last_mhp;
if (!parsed_valid_hugepagesz) {
pr_warn("hugepages = %s preceded by "
"an unsupported hugepagesz, ignoring\n", s);
parsed_valid_hugepagesz = true;
return 1;
}
/*
* !hugetlb_max_hstate means we haven't parsed a hugepagesz= parameter yet,
* so this hugepages= parameter goes to the "default hstate".
*/
else if (!hugetlb_max_hstate)
mhp = &default_hstate_max_huge_pages;
else
mhp = &parsed_hstate->max_huge_pages;
if (mhp == last_mhp) {
pr_warn("hugepages= specified twice without interleaving hugepagesz=, ignoring\n");
return 1;
}
if (sscanf(s, "%lu", mhp) <= 0)
*mhp = 0;
/*
* Global state is always initialized later in hugetlb_init.
* But we need to allocate >= MAX_ORDER hstates here early to still
* use the bootmem allocator.
*/
if (hugetlb_max_hstate && parsed_hstate->order >= MAX_ORDER)
hugetlb_hstate_alloc_pages(parsed_hstate);
last_mhp = mhp;
return 1;
}
| 0
|
405,958
|
parse_port_mod_ethernet_property(struct ofpbuf *property,
struct ofputil_port_mod *pm)
{
ovs_be32 advertise;
enum ofperr error;
error = ofpprop_parse_be32(property, &advertise);
if (!error) {
pm->advertise = netdev_port_features_from_ofp11(advertise);
}
return error;
}
| 0
|
334,875
|
static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
{
const char *proto = avio_find_protocol_name(s->filename);
int http_base_proto = !av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https");
if (c->method) {
av_dict_set(options, "method", c->method, 0);
} else if (proto && http_base_proto) {
av_log(c, AV_LOG_WARNING, "No HTTP method set, hls muxer defaulting to method PUT.\n");
av_dict_set(options, "method", "PUT", 0);
}
}
| 0
|
357,287
|
int cap_netlink_recv(struct sk_buff *skb, int cap)
{
if (!cap_raised(NETLINK_CB(skb).eff_cap, cap))
return -EPERM;
return 0;
}
| 0
|
79,571
|
static VALUE cState_space_before(VALUE self)
{
GET_STATE(self);
return state->space_before ? rb_str_new(state->space_before, state->space_before_len) : rb_str_new2("");
}
| 0
|
186,436
|
void TabSpecificContentSettings::OnGeolocationPermissionSet(
const GURL& requesting_origin,
bool allowed) {
geolocation_settings_state_.OnGeolocationPermissionSet(requesting_origin,
allowed);
content::NotificationService::current()->Notify(
chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
content::Source<WebContents>(web_contents()),
content::NotificationService::NoDetails());
}
| 0
|
438,253
|
uint64_t matrix_coefficients() const { return matrix_coefficients_; }
| 0
|
452,341
|
static gboolean vdagent_message_check_size(const VDAgentMessage *message_header)
{
uint32_t min_size = 0;
if (message_header->protocol != VD_AGENT_PROTOCOL) {
syslog(LOG_ERR, "message with wrong protocol version ignoring");
return FALSE;
}
if (!message_header->type ||
message_header->type >= G_N_ELEMENTS(vdagent_message_min_size)) {
syslog(LOG_WARNING, "unknown message type %d, ignoring",
message_header->type);
return FALSE;
}
min_size = vdagent_message_min_size[message_header->type];
if (VD_AGENT_HAS_CAPABILITY(capabilities, capabilities_size,
VD_AGENT_CAP_CLIPBOARD_SELECTION)) {
switch (message_header->type) {
case VD_AGENT_CLIPBOARD_GRAB:
case VD_AGENT_CLIPBOARD_REQUEST:
case VD_AGENT_CLIPBOARD:
case VD_AGENT_CLIPBOARD_RELEASE:
min_size += 4;
}
}
if (VD_AGENT_HAS_CAPABILITY(capabilities, capabilities_size,
VD_AGENT_CAP_CLIPBOARD_GRAB_SERIAL)
&& message_header->type == VD_AGENT_CLIPBOARD_GRAB) {
min_size += 4;
}
switch (message_header->type) {
case VD_AGENT_MONITORS_CONFIG:
case VD_AGENT_FILE_XFER_START:
case VD_AGENT_FILE_XFER_DATA:
case VD_AGENT_CLIPBOARD:
case VD_AGENT_CLIPBOARD_GRAB:
case VD_AGENT_AUDIO_VOLUME_SYNC:
case VD_AGENT_ANNOUNCE_CAPABILITIES:
case VD_AGENT_GRAPHICS_DEVICE_INFO:
if (message_header->size < min_size) {
syslog(LOG_ERR, "read: invalid message size: %u for message type: %u",
message_header->size, message_header->type);
return FALSE;
}
break;
case VD_AGENT_MOUSE_STATE:
case VD_AGENT_FILE_XFER_STATUS:
case VD_AGENT_DISPLAY_CONFIG:
case VD_AGENT_REPLY:
case VD_AGENT_CLIPBOARD_REQUEST:
case VD_AGENT_CLIPBOARD_RELEASE:
case VD_AGENT_MAX_CLIPBOARD:
case VD_AGENT_CLIENT_DISCONNECTED:
if (message_header->size != min_size) {
syslog(LOG_ERR, "read: invalid message size: %u for message type: %u",
message_header->size, message_header->type);
return FALSE;
}
break;
default:
g_warn_if_reached();
return FALSE;
}
return TRUE;
}
| 0
|
193,916
|
polling_inhibitor_disconnected_cb (Inhibitor *inhibitor,
Device *device)
{
device->priv->polling_inhibitors = g_list_remove (device->priv->polling_inhibitors, inhibitor);
g_signal_handlers_disconnect_by_func (inhibitor, polling_inhibitor_disconnected_cb, device);
g_object_unref (inhibitor);
update_info (device);
drain_pending_changes (device, FALSE);
daemon_local_update_poller (device->priv->daemon);
}
| 0
|
418,709
|
main(
int argc,
char ** argv)
{
int c;
char *command;
application_argument_t argument;
int i;
#ifdef BSDTAR
bsdtar_path = g_strdup(BSDTAR);
#else
bsdtar_path = NULL;
#endif
state_dir = NULL;
bsdtar_directory = NULL;
bsdtar_onefilesystem = 1;
exit_handling = NULL;
/* initialize */
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
if (argc < 2) {
printf("ERROR no command given to ambsdtar\n");
error(_("No command given to ambsdtar"));
}
/* drop root privileges */
if (!set_root_privs(0)) {
if (g_str_equal(argv[1], "selfcheck")) {
printf("ERROR ambsdtar must be run setuid root\n");
}
error(_("ambsdtar must be run setuid root"));
}
safe_fd(3, 2);
set_pname("ambsdtar");
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
#if defined(USE_DBMALLOC)
malloc_size_1 = malloc_inuse(&malloc_hist_1);
#endif
add_amanda_log_handler(amanda_log_stderr);
add_amanda_log_handler(amanda_log_syslog);
dbopen(DBG_SUBDIR_CLIENT);
startclock();
g_debug(_("version %s"), VERSION);
config_init(CONFIG_INIT_CLIENT, NULL);
//check_running_as(RUNNING_AS_DUMPUSER_PREFERRED);
//root for amrecover
//RUNNING_AS_CLIENT_LOGIN from selfcheck, sendsize, sendbackup
/* parse argument */
command = argv[1];
argument.config = NULL;
argument.host = NULL;
argument.message = 0;
argument.collection = 0;
argument.calcsize = 0;
argument.tar_blocksize = NULL;
argument.level = NULL;
argument.command_options = NULL;
argument.verbose = 0;
init_dle(&argument.dle);
argument.dle.record = 0;
while (1) {
int option_index = 0;
c = getopt_long (argc, argv, "", long_options, &option_index);
if (c == -1) {
break;
}
switch (c) {
case 1: amfree(argument.config);
argument.config = g_strdup(optarg);
break;
case 2: amfree(argument.host);
argument.host = g_strdup(optarg);
break;
case 3: amfree(argument.dle.disk);
argument.dle.disk = g_strdup(optarg);
break;
case 4: amfree(argument.dle.device);
argument.dle.device = g_strdup(optarg);
break;
case 5: argument.level = g_slist_append(argument.level,
GINT_TO_POINTER(atoi(optarg)));
break;
case 6: argument.dle.create_index = 1;
break;
case 7: argument.message = 1;
break;
case 8: argument.collection = 1;
break;
case 9: argument.dle.record = 1;
break;
case 10: amfree(bsdtar_path);
bsdtar_path = g_strdup(optarg);
break;
case 11: amfree(state_dir);
state_dir = g_strdup(optarg);
break;
case 12: if (strcasecmp(optarg, "NO") == 0)
bsdtar_onefilesystem = 0;
else if (strcasecmp(optarg, "YES") == 0)
bsdtar_onefilesystem = 1;
else if (strcasecmp(command, "selfcheck") == 0)
printf(_("ERROR [%s: bad ONE-FILE-SYSTEM property value (%s)]\n"), get_pname(), optarg);
break;
case 16: argument.dle.include_file =
append_sl(argument.dle.include_file, optarg);
break;
case 17: argument.dle.include_list =
append_sl(argument.dle.include_list, optarg);
break;
case 18: argument.dle.include_optional = 1;
break;
case 19: argument.dle.exclude_file =
append_sl(argument.dle.exclude_file, optarg);
break;
case 20: argument.dle.exclude_list =
append_sl(argument.dle.exclude_list, optarg);
break;
case 21: argument.dle.exclude_optional = 1;
break;
case 22: amfree(bsdtar_directory);
bsdtar_directory = g_strdup(optarg);
break;
case 23: normal_message =
g_slist_append(normal_message, optarg);
break;
case 24: ignore_message =
g_slist_append(ignore_message, optarg);
break;
case 25: strange_message =
g_slist_append(strange_message, optarg);
break;
case 26: amfree(exit_handling);
exit_handling = g_strdup(optarg);
break;
case 27: argument.calcsize = 1;
break;
case 28: amfree(argument.tar_blocksize);
argument.tar_blocksize = g_strdup(optarg);
gblocksize = atoi(argument.tar_blocksize);
break;
case 33: argument.command_options =
g_slist_append(argument.command_options,
g_strdup(optarg));
break;
case 36: if (strcasecmp(optarg, "YES") == 0)
argument.verbose = 1;
break;
case ':':
case '?':
break;
}
}
if (!argument.dle.disk && argument.dle.device)
argument.dle.disk = g_strdup(argument.dle.device);
if (!argument.dle.device && argument.dle.disk)
argument.dle.device = g_strdup(argument.dle.disk);
argument.argc = argc - optind;
argument.argv = argv + optind;
if (argument.config) {
config_init(CONFIG_INIT_CLIENT | CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_OVERLAY,
argument.config);
dbrename(get_config_name(), DBG_SUBDIR_CLIENT);
}
if (config_errors(NULL) >= CFGERR_ERRORS) {
g_critical(_("errors processing config file"));
}
if (state_dir && strlen(state_dir) == 0)
amfree(state_dir);
if (!state_dir) {
state_dir = g_strdup_printf("%s/%s", amdatadir, "bsdtar");
}
re_table = build_re_table(init_re_table, normal_message, ignore_message,
strange_message);
for(i=0;i<256;i++)
exit_value[i] = 1; /* BAD */
exit_value[0] = 0; /* GOOD */
if (exit_handling) {
char *s = exit_handling;
while (s) {
char *r = strchr(s, '=');
if (r) {
int j = atoi(s);
if (j >= 0 && j < 256) {
r++;
if (strncasecmp(r, "GOOD", 4) == 0) {
exit_value[j] = 0;
}
}
}
s = strchr(s+1, ' ');
}
}
if (bsdtar_path) {
g_debug("BSDTAR-PATH %s", bsdtar_path);
} else {
g_debug("BSDTAR-PATH is not set");
}
if (state_dir) {
g_debug("STATE-DIR %s", state_dir);
} else {
g_debug("STATE-DIR is not set");
}
if (bsdtar_directory) {
g_debug("DIRECTORY %s", bsdtar_directory);
}
g_debug("ONE-FILE-SYSTEM %s", bsdtar_onefilesystem? "yes":"no");
{
amregex_t *rp;
for (rp = re_table; rp->regex != NULL; rp++) {
switch (rp->typ) {
case DMP_NORMAL : g_debug("NORMAL %s", rp->regex); break;
case DMP_IGNORE : g_debug("IGNORE %s", rp->regex); break;
case DMP_STRANGE: g_debug("STRANGE %s", rp->regex); break;
case DMP_SIZE : g_debug("SIZE %s", rp->regex); break;
case DMP_ERROR : g_debug("ERROR %s", rp->regex); break;
}
}
}
if (g_str_equal(command, "support")) {
ambsdtar_support(&argument);
} else if (g_str_equal(command, "selfcheck")) {
ambsdtar_selfcheck(&argument);
} else if (g_str_equal(command, "estimate")) {
ambsdtar_estimate(&argument);
} else if (g_str_equal(command, "backup")) {
ambsdtar_backup(&argument);
} else if (g_str_equal(command, "restore")) {
ambsdtar_restore(&argument);
} else if (g_str_equal(command, "validate")) {
ambsdtar_validate(&argument);
} else if (g_str_equal(command, "index")) {
ambsdtar_index(&argument);
} else {
g_debug("Unknown command `%s'.", command);
fprintf(stderr, "Unknown command `%s'.\n", command);
exit (1);
}
g_free(argument.config);
g_free(argument.host);
g_free(argument.dle.disk);
g_free(argument.dle.device);
g_free(argument.tar_blocksize);
g_slist_free(argument.level);
dbclose();
return exit_status;
}
| 0
|
409,345
|
static void bnx2x_pf_q_prep_general(struct bnx2x *bp,
struct bnx2x_fastpath *fp, struct bnx2x_general_setup_params *gen_init,
u8 cos)
{
gen_init->stat_id = bnx2x_stats_id(fp);
gen_init->spcl_id = fp->cl_id;
/* Always use mini-jumbo MTU for FCoE L2 ring */
if (IS_FCOE_FP(fp))
gen_init->mtu = BNX2X_FCOE_MINI_JUMBO_MTU;
else
gen_init->mtu = bp->dev->mtu;
gen_init->cos = cos;
gen_init->fp_hsi = ETH_FP_HSI_VERSION;
}
| 0
|
449,843
|
tok_match(const struct Token *a, const struct Token *b)
{
return a->type == b->type && tok_text_match(a, b);
}
| 0
|
435,107
|
psutil_users(PyObject *self, PyObject *args) {
struct utmpx *ut;
PyObject *py_tuple = NULL;
PyObject *py_username = NULL;
PyObject *py_tty = NULL;
PyObject *py_hostname = NULL;
PyObject *py_user_proc = NULL;
PyObject *py_retlist = PyList_New(0);
if (py_retlist == NULL)
return NULL;
setutxent();
while (NULL != (ut = getutxent())) {
if (ut->ut_type == USER_PROCESS)
py_user_proc = Py_True;
else
py_user_proc = Py_False;
py_username = PyUnicode_DecodeFSDefault(ut->ut_user);
if (! py_username)
goto error;
py_tty = PyUnicode_DecodeFSDefault(ut->ut_line);
if (! py_tty)
goto error;
py_hostname = PyUnicode_DecodeFSDefault(ut->ut_host);
if (! py_hostname)
goto error;
py_tuple = Py_BuildValue(
"(OOOfOi)",
py_username, // username
py_tty, // tty
py_hostname, // hostname
(float)ut->ut_tv.tv_sec, // tstamp
py_user_proc, // (bool) user process
ut->ut_pid // process id
);
if (py_tuple == NULL)
goto error;
if (PyList_Append(py_retlist, py_tuple))
goto error;
Py_CLEAR(py_username);
Py_CLEAR(py_tty);
Py_CLEAR(py_hostname);
Py_CLEAR(py_tuple);
}
endutxent();
return py_retlist;
error:
Py_XDECREF(py_username);
Py_XDECREF(py_tty);
Py_XDECREF(py_hostname);
Py_XDECREF(py_tuple);
Py_DECREF(py_retlist);
endutxent();
return NULL;
}
| 0
|
407,825
|
static int drbg_hmac_update(struct drbg_state *drbg, struct list_head *seed,
int reseed)
{
int ret = -EFAULT;
int i = 0;
struct drbg_string seed1, seed2, vdata;
LIST_HEAD(seedlist);
LIST_HEAD(vdatalist);
if (!reseed)
/* 10.1.2.3 step 2 -- memset(0) of C is implicit with kzalloc */
memset(drbg->V, 1, drbg_statelen(drbg));
drbg_string_fill(&seed1, drbg->V, drbg_statelen(drbg));
list_add_tail(&seed1.list, &seedlist);
/* buffer of seed2 will be filled in for loop below with one byte */
drbg_string_fill(&seed2, NULL, 1);
list_add_tail(&seed2.list, &seedlist);
/* input data of seed is allowed to be NULL at this point */
if (seed)
list_splice_tail(seed, &seedlist);
drbg_string_fill(&vdata, drbg->V, drbg_statelen(drbg));
list_add_tail(&vdata.list, &vdatalist);
for (i = 2; 0 < i; i--) {
/* first round uses 0x0, second 0x1 */
unsigned char prefix = DRBG_PREFIX0;
if (1 == i)
prefix = DRBG_PREFIX1;
/* 10.1.2.2 step 1 and 4 -- concatenation and HMAC for key */
seed2.buf = &prefix;
ret = drbg_kcapi_hash(drbg, drbg->C, drbg->C, &seedlist);
if (ret)
return ret;
/* 10.1.2.2 step 2 and 5 -- HMAC for V */
ret = drbg_kcapi_hash(drbg, drbg->C, drbg->V, &vdatalist);
if (ret)
return ret;
/* 10.1.2.2 step 3 */
if (!seed)
return ret;
}
return 0;
}
| 0
|
24,283
|
static void tscc2_idct4_put ( int * in , int q [ 3 ] , uint8_t * dst , int stride ) {
int i ;
int tblk [ 4 * 4 ] ;
int t0 , t1 , t2 , t3 ;
for ( i = 0 ;
i < 4 ;
i ++ ) {
t0 = DEQUANT ( q [ 0 + ( i & 1 ) ] , in [ 0 * 4 + i ] ) ;
t1 = DEQUANT ( q [ 1 + ( i & 1 ) ] , in [ 1 * 4 + i ] ) ;
t2 = DEQUANT ( q [ 0 + ( i & 1 ) ] , in [ 2 * 4 + i ] ) ;
t3 = DEQUANT ( q [ 1 + ( i & 1 ) ] , in [ 3 * 4 + i ] ) ;
DCT1D ( tblk [ 0 * 4 + i ] , tblk [ 1 * 4 + i ] , tblk [ 2 * 4 + i ] , tblk [ 3 * 4 + i ] , t0 , t1 , t2 , t3 , COL_OP ) ;
}
for ( i = 0 ;
i < 4 ;
i ++ ) {
DCT1D ( dst [ 0 ] , dst [ 1 ] , dst [ 2 ] , dst [ 3 ] , tblk [ i * 4 + 0 ] , tblk [ i * 4 + 1 ] , tblk [ i * 4 + 2 ] , tblk [ i * 4 + 3 ] , ROW_OP ) ;
dst += stride ;
}
}
| 0
|
489,576
|
GF_Err xtra_box_dump(GF_Box *a, FILE * trace)
{
GF_XtraBox *ptr = (GF_XtraBox *)a;
u32 i, count = gf_list_count(ptr->tags);
gf_isom_box_dump_start(a, "XtraBox", trace);
gf_fprintf(trace, ">\n");
for (i=0; i<count; i++) {
GF_XtraTag *tag = gf_list_get(ptr->tags, i);
gf_fprintf(trace, "<WMATag name=\"%s\" version=\"%d\" type=\"%d\"", tag->name, tag->flags, tag->prop_type);
if (!tag->prop_type) {
u16 *src_str = (u16 *) tag->prop_value;
u32 len = UTF8_MAX_BYTES_PER_CHAR * gf_utf8_wcslen(src_str);
char *utf8str = (char *)gf_malloc(len + 1);
u32 res_len = gf_utf8_wcstombs(utf8str, len, (const unsigned short **) &src_str);
if (res_len != GF_UTF8_FAIL) {
utf8str[res_len] = 0;
gf_fprintf(trace, " value=\"%s\">\n", utf8str);
}
gf_free(utf8str);
} else {
gf_fprintf(trace, " value=\"");
dump_data_hex(trace, tag->prop_value, tag->prop_size);
gf_fprintf(trace, "\">\n");
}
}
gf_isom_box_dump_done("XtraBox", a, trace);
return GF_OK;
}
| 0
|
275,028
|
static void Float32ArrayAttributeAttributeGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Local<v8::Object> holder = info.Holder();
TestObject* impl = V8TestObject::ToImpl(holder);
V8SetReturnValueFast(info, impl->float32ArrayAttribute(), impl);
}
| 0
|
256,512
|
WandPrivate MagickBooleanType CLIListOperatorImages(MagickCLI *cli_wand,
const char *option,const char *arg1n,const char *arg2n)
{
const char /* percent escaped versions of the args */
*arg1,
*arg2;
Image
*new_images;
MagickStatusType
status;
ssize_t
parse;
#define _image_info (cli_wand->wand.image_info)
#define _images (cli_wand->wand.images)
#define _exception (cli_wand->wand.exception)
#define _draw_info (cli_wand->draw_info)
#define _quantize_info (cli_wand->quantize_info)
#define _process_flags (cli_wand->process_flags)
#define _option_type ((CommandOptionFlags) cli_wand->command->flags)
#define IfNormalOp (*option=='-')
#define IfPlusOp (*option!='-')
#define IsNormalOp IfNormalOp ? MagickTrue : MagickFalse
assert(cli_wand != (MagickCLI *) NULL);
assert(cli_wand->signature == MagickWandSignature);
assert(cli_wand->wand.signature == MagickWandSignature);
assert(_images != (Image *) NULL); /* _images must be present */
if (cli_wand->wand.debug != MagickFalse)
(void) CLILogEvent(cli_wand,CommandEvent,GetMagickModule(),
"- List Operator: %s \"%s\" \"%s\"", option,
arg1n == (const char *) NULL ? "null" : arg1n,
arg2n == (const char *) NULL ? "null" : arg2n);
arg1 = arg1n;
arg2 = arg2n;
/* Interpret Percent Escapes in Arguments - using first image */
if ( (((_process_flags & ProcessInterpretProperities) != 0 )
|| ((_option_type & AlwaysInterpretArgsFlag) != 0)
) && ((_option_type & NeverInterpretArgsFlag) == 0) ) {
/* Interpret Percent escapes in argument 1 */
if (arg1n != (char *) NULL) {
arg1=InterpretImageProperties(_image_info,_images,arg1n,_exception);
if (arg1 == (char *) NULL) {
CLIWandException(OptionWarning,"InterpretPropertyFailure",option);
arg1=arg1n; /* use the given argument as is */
}
}
if (arg2n != (char *) NULL) {
arg2=InterpretImageProperties(_image_info,_images,arg2n,_exception);
if (arg2 == (char *) NULL) {
CLIWandException(OptionWarning,"InterpretPropertyFailure",option);
arg2=arg2n; /* use the given argument as is */
}
}
}
#undef _process_flags
#undef _option_type
status=MagickTrue;
new_images=NewImageList();
switch (*(option+1))
{
case 'a':
{
if (LocaleCompare("append",option+1) == 0)
{
new_images=AppendImages(_images,IsNormalOp,_exception);
break;
}
if (LocaleCompare("average",option+1) == 0)
{
CLIWandWarnReplaced("-evaluate-sequence Mean");
(void) CLIListOperatorImages(cli_wand,"-evaluate-sequence","Mean",
NULL);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'c':
{
if (LocaleCompare("channel-fx",option+1) == 0)
{
new_images=ChannelFxImage(_images,arg1,_exception);
break;
}
if (LocaleCompare("clut",option+1) == 0)
{
Image
*clut_image;
/* FUTURE - make this a compose option, and thus can be used
with layers compose or even compose last image over all other
_images.
*/
new_images=RemoveFirstImageFromList(&_images);
clut_image=RemoveLastImageFromList(&_images);
/* FUTURE - produce Exception, rather than silent fail */
if (clut_image == (Image *) NULL)
break;
(void) ClutImage(new_images,clut_image,new_images->interpolate,
_exception);
clut_image=DestroyImage(clut_image);
break;
}
if (LocaleCompare("coalesce",option+1) == 0)
{
new_images=CoalesceImages(_images,_exception);
break;
}
if (LocaleCompare("combine",option+1) == 0)
{
parse=(ssize_t) _images->colorspace;
if (_images->number_channels < GetImageListLength(_images))
parse=sRGBColorspace;
if ( IfPlusOp )
parse=ParseCommandOption(MagickColorspaceOptions,MagickFalse,arg1);
if (parse < 0)
CLIWandExceptArgBreak(OptionError,"UnrecognizedColorspace",option,
arg1);
new_images=CombineImages(_images,(ColorspaceType) parse,_exception);
break;
}
if (LocaleCompare("compare",option+1) == 0)
{
double
distortion;
Image
*image,
*reconstruct_image;
MetricType
metric;
/*
Mathematically and visually annotate the difference between an
image and its reconstruction.
*/
image=RemoveFirstImageFromList(&_images);
reconstruct_image=RemoveFirstImageFromList(&_images);
/* FUTURE - produce Exception, rather than silent fail */
if (reconstruct_image == (Image *) NULL)
{
image=DestroyImage(image);
break;
}
metric=UndefinedErrorMetric;
option=GetImageOption(_image_info,"metric");
if (option != (const char *) NULL)
metric=(MetricType) ParseCommandOption(MagickMetricOptions,
MagickFalse,option);
new_images=CompareImages(image,reconstruct_image,metric,&distortion,
_exception);
(void) distortion;
reconstruct_image=DestroyImage(reconstruct_image);
image=DestroyImage(image);
break;
}
if (LocaleCompare("complex",option+1) == 0)
{
parse=ParseCommandOption(MagickComplexOptions,MagickFalse,arg1);
if (parse < 0)
CLIWandExceptArgBreak(OptionError,"UnrecognizedEvaluateOperator",
option,arg1);
new_images=ComplexImages(_images,(ComplexOperator) parse,_exception);
break;
}
if (LocaleCompare("composite",option+1) == 0)
{
CompositeOperator
compose;
const char*
value;
MagickBooleanType
clip_to_self;
Image
*mask_image,
*source_image;
RectangleInfo
geometry;
/* Compose value from "-compose" option only */
value=GetImageOption(_image_info,"compose");
if (value == (const char *) NULL)
compose=OverCompositeOp; /* use Over not source_image->compose */
else
compose=(CompositeOperator) ParseCommandOption(MagickComposeOptions,
MagickFalse,value);
/* Get "clip-to-self" expert setting (false is normal) */
clip_to_self=GetCompositeClipToSelf(compose);
value=GetImageOption(_image_info,"compose:clip-to-self");
if (value != (const char *) NULL)
clip_to_self=IsStringTrue(value);
value=GetImageOption(_image_info,"compose:outside-overlay");
if (value != (const char *) NULL)
clip_to_self=IsStringFalse(value); /* deprecated */
new_images=RemoveFirstImageFromList(&_images);
source_image=RemoveFirstImageFromList(&_images);
if (source_image == (Image *) NULL)
break; /* FUTURE - produce Exception, rather than silent fail */
/* FUTURE - this should not be here! - should be part of -geometry */
if (source_image->geometry != (char *) NULL)
{
RectangleInfo
resize_geometry;
(void) ParseRegionGeometry(source_image,source_image->geometry,
&resize_geometry,_exception);
if ((source_image->columns != resize_geometry.width) ||
(source_image->rows != resize_geometry.height))
{
Image
*resize_image;
resize_image=ResizeImage(source_image,resize_geometry.width,
resize_geometry.height,source_image->filter,_exception);
if (resize_image != (Image *) NULL)
{
source_image=DestroyImage(source_image);
source_image=resize_image;
}
}
}
SetGeometry(source_image,&geometry);
(void) ParseAbsoluteGeometry(source_image->geometry,&geometry);
GravityAdjustGeometry(new_images->columns,new_images->rows,
new_images->gravity, &geometry);
mask_image=RemoveFirstImageFromList(&_images);
if (mask_image == (Image *) NULL)
status&=CompositeImage(new_images,source_image,compose,clip_to_self,
geometry.x,geometry.y,_exception);
else
{
if ((compose == DisplaceCompositeOp) ||
(compose == DistortCompositeOp))
{
status&=CompositeImage(source_image,mask_image,
CopyGreenCompositeOp,MagickTrue,0,0,_exception);
status&=CompositeImage(new_images,source_image,compose,
clip_to_self,geometry.x,geometry.y,_exception);
}
else
{
Image
*clone_image;
clone_image=CloneImage(new_images,0,0,MagickTrue,_exception);
if (clone_image == (Image *) NULL)
break;
status&=CompositeImage(new_images,source_image,compose,
clip_to_self,geometry.x,geometry.y,_exception);
status&=CompositeImage(new_images,mask_image,
CopyAlphaCompositeOp,MagickTrue,0,0,_exception);
status&=CompositeImage(clone_image,new_images,OverCompositeOp,
clip_to_self,0,0,_exception);
new_images=DestroyImageList(new_images);
new_images=clone_image;
}
mask_image=DestroyImage(mask_image);
}
source_image=DestroyImage(source_image);
break;
}
if (LocaleCompare("copy",option+1) == 0)
{
Image
*source_image;
OffsetInfo
offset;
RectangleInfo
geometry;
/*
Copy image pixels.
*/
if (IsGeometry(arg1) == MagickFalse)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
if (IsGeometry(arg2) == MagickFalse)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
(void) ParsePageGeometry(_images,arg2,&geometry,_exception);
offset.x=geometry.x;
offset.y=geometry.y;
source_image=_images;
if (source_image->next != (Image *) NULL)
source_image=source_image->next;
(void) ParsePageGeometry(source_image,arg1,&geometry,_exception);
(void) CopyImagePixels(_images,source_image,&geometry,&offset,
_exception);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'd':
{
if (LocaleCompare("deconstruct",option+1) == 0)
{
CLIWandWarnReplaced("-layer CompareAny");
(void) CLIListOperatorImages(cli_wand,"-layer","CompareAny",NULL);
break;
}
if (LocaleCompare("delete",option+1) == 0)
{
if (IfNormalOp)
DeleteImages(&_images,arg1,_exception);
else
DeleteImages(&_images,"-1",_exception);
break;
}
if (LocaleCompare("duplicate",option+1) == 0)
{
if (IfNormalOp)
{
const char
*p;
size_t
number_duplicates;
if (IsGeometry(arg1) == MagickFalse)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,
arg1);
number_duplicates=(size_t) StringToLong(arg1);
p=strchr(arg1,',');
if (p == (const char *) NULL)
new_images=DuplicateImages(_images,number_duplicates,"-1",
_exception);
else
new_images=DuplicateImages(_images,number_duplicates,p,
_exception);
}
else
new_images=DuplicateImages(_images,1,"-1",_exception);
AppendImageToList(&_images, new_images);
new_images=(Image *) NULL;
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'e':
{
if (LocaleCompare("evaluate-sequence",option+1) == 0)
{
parse=ParseCommandOption(MagickEvaluateOptions,MagickFalse,arg1);
if (parse < 0)
CLIWandExceptArgBreak(OptionError,"UnrecognizedEvaluateOperator",
option,arg1);
new_images=EvaluateImages(_images,(MagickEvaluateOperator) parse,
_exception);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'f':
{
if (LocaleCompare("fft",option+1) == 0)
{
new_images=ForwardFourierTransformImage(_images,IsNormalOp,
_exception);
break;
}
if (LocaleCompare("flatten",option+1) == 0)
{
/* REDIRECTED to use -layers flatten instead */
(void) CLIListOperatorImages(cli_wand,"-layers",option+1,NULL);
break;
}
if (LocaleCompare("fx",option+1) == 0)
{
new_images=FxImage(_images,arg1,_exception);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'h':
{
if (LocaleCompare("hald-clut",option+1) == 0)
{
/* FUTURE - make this a compose option (and thus layers compose )
or perhaps compose last image over all other _images.
*/
Image
*hald_image;
new_images=RemoveFirstImageFromList(&_images);
hald_image=RemoveLastImageFromList(&_images);
if (hald_image == (Image *) NULL)
break;
(void) HaldClutImage(new_images,hald_image,_exception);
hald_image=DestroyImage(hald_image);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'i':
{
if (LocaleCompare("ift",option+1) == 0)
{
Image
*magnitude_image,
*phase_image;
magnitude_image=RemoveFirstImageFromList(&_images);
phase_image=RemoveFirstImageFromList(&_images);
/* FUTURE - produce Exception, rather than silent fail */
if (phase_image == (Image *) NULL)
break;
new_images=InverseFourierTransformImage(magnitude_image,phase_image,
IsNormalOp,_exception);
magnitude_image=DestroyImage(magnitude_image);
phase_image=DestroyImage(phase_image);
break;
}
if (LocaleCompare("insert",option+1) == 0)
{
Image
*insert_image,
*index_image;
ssize_t
index;
if (IfNormalOp && (IsGeometry(arg1) == MagickFalse))
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
index=0;
insert_image=RemoveLastImageFromList(&_images);
if (IfNormalOp)
index=(ssize_t) StringToLong(arg1);
index_image=insert_image;
if (index == 0)
PrependImageToList(&_images,insert_image);
else if (index == (ssize_t) GetImageListLength(_images))
AppendImageToList(&_images,insert_image);
else
{
index_image=GetImageFromList(_images,index-1);
if (index_image == (Image *) NULL)
{
insert_image=DestroyImage(insert_image);
CLIWandExceptArgBreak(OptionError,"NoSuchImage",option,arg1);
}
InsertImageInList(&index_image,insert_image);
}
_images=GetFirstImageInList(index_image);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'l':
{
if (LocaleCompare("layers",option+1) == 0)
{
parse=ParseCommandOption(MagickLayerOptions,MagickFalse,arg1);
if ( parse < 0 )
CLIWandExceptArgBreak(OptionError,"UnrecognizedLayerMethod",
option,arg1);
switch ((LayerMethod) parse)
{
case CoalesceLayer:
{
new_images=CoalesceImages(_images,_exception);
break;
}
case CompareAnyLayer:
case CompareClearLayer:
case CompareOverlayLayer:
default:
{
new_images=CompareImagesLayers(_images,(LayerMethod) parse,
_exception);
break;
}
case MergeLayer:
case FlattenLayer:
case MosaicLayer:
case TrimBoundsLayer:
{
new_images=MergeImageLayers(_images,(LayerMethod) parse,
_exception);
break;
}
case DisposeLayer:
{
new_images=DisposeImages(_images,_exception);
break;
}
case OptimizeImageLayer:
{
new_images=OptimizeImageLayers(_images,_exception);
break;
}
case OptimizePlusLayer:
{
new_images=OptimizePlusImageLayers(_images,_exception);
break;
}
case OptimizeTransLayer:
{
OptimizeImageTransparency(_images,_exception);
break;
}
case RemoveDupsLayer:
{
RemoveDuplicateLayers(&_images,_exception);
break;
}
case RemoveZeroLayer:
{
RemoveZeroDelayLayers(&_images,_exception);
break;
}
case OptimizeLayer:
{ /* General Purpose, GIF Animation Optimizer. */
new_images=CoalesceImages(_images,_exception);
if (new_images == (Image *) NULL)
break;
_images=DestroyImageList(_images);
_images=OptimizeImageLayers(new_images,_exception);
if (_images == (Image *) NULL)
break;
new_images=DestroyImageList(new_images);
OptimizeImageTransparency(_images,_exception);
(void) RemapImages(_quantize_info,_images,(Image *) NULL,
_exception);
break;
}
case CompositeLayer:
{
Image
*source;
RectangleInfo
geometry;
CompositeOperator
compose;
const char*
value;
value=GetImageOption(_image_info,"compose");
compose=OverCompositeOp; /* Default to Over */
if (value != (const char *) NULL)
compose=(CompositeOperator) ParseCommandOption(
MagickComposeOptions,MagickFalse,value);
/* Split image sequence at the first 'NULL:' image. */
source=_images;
while (source != (Image *) NULL)
{
source=GetNextImageInList(source);
if ((source != (Image *) NULL) &&
(LocaleCompare(source->magick,"NULL") == 0))
break;
}
if (source != (Image *) NULL)
{
if ((GetPreviousImageInList(source) == (Image *) NULL) ||
(GetNextImageInList(source) == (Image *) NULL))
source=(Image *) NULL;
else
{ /* Separate the two lists, junk the null: image. */
source=SplitImageList(source->previous);
DeleteImageFromList(&source);
}
}
if (source == (Image *) NULL)
{
(void) ThrowMagickException(_exception,GetMagickModule(),
OptionError,"MissingNullSeparator","layers Composite");
break;
}
/* Adjust offset with gravity and virtual canvas. */
SetGeometry(_images,&geometry);
(void) ParseAbsoluteGeometry(_images->geometry,&geometry);
geometry.width=source->page.width != 0 ?
source->page.width : source->columns;
geometry.height=source->page.height != 0 ?
source->page.height : source->rows;
GravityAdjustGeometry(_images->page.width != 0 ?
_images->page.width : _images->columns,
_images->page.height != 0 ? _images->page.height :
_images->rows,_images->gravity,&geometry);
/* Compose the two image sequences together */
CompositeLayers(_images,compose,source,geometry.x,geometry.y,
_exception);
source=DestroyImageList(source);
break;
}
}
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'm':
{
if (LocaleCompare("map",option+1) == 0)
{
CLIWandWarnReplaced("+remap");
(void) RemapImages(_quantize_info,_images,(Image *) NULL,_exception);
break;
}
if (LocaleCompare("metric",option+1) == 0)
{
(void) SetImageOption(_image_info,option+1,arg1);
break;
}
if (LocaleCompare("morph",option+1) == 0)
{
Image
*morph_image;
if (IsGeometry(arg1) == MagickFalse)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
morph_image=MorphImages(_images,StringToUnsignedLong(arg1),
_exception);
if (morph_image == (Image *) NULL)
break;
_images=DestroyImageList(_images);
_images=morph_image;
break;
}
if (LocaleCompare("mosaic",option+1) == 0)
{
/* REDIRECTED to use -layers mosaic instead */
(void) CLIListOperatorImages(cli_wand,"-layers",option+1,NULL);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'p':
{
if (LocaleCompare("poly",option+1) == 0)
{
double
*args;
ssize_t
count;
/* convert argument string into an array of doubles */
args = StringToArrayOfDoubles(arg1,&count,_exception);
if (args == (double *) NULL )
CLIWandExceptArgBreak(OptionError,"InvalidNumberList",option,arg1);
new_images=PolynomialImage(_images,(size_t) (count >> 1),args,
_exception);
args=(double *) RelinquishMagickMemory(args);
break;
}
if (LocaleCompare("process",option+1) == 0)
{
/* FUTURE: better parsing using ScriptToken() from string ??? */
char
**arguments;
int
j,
number_arguments;
arguments=StringToArgv(arg1,&number_arguments);
if (arguments == (char **) NULL)
break;
if (strchr(arguments[1],'=') != (char *) NULL)
{
char
breaker,
quote,
*token;
const char
*arguments;
int
next,
status;
size_t
length;
TokenInfo
*token_info;
/*
Support old style syntax, filter="-option arg1".
*/
assert(arg1 != (const char *) NULL);
length=strlen(arg1);
token=(char *) NULL;
if (~length >= (MagickPathExtent-1))
token=(char *) AcquireQuantumMemory(length+MagickPathExtent,
sizeof(*token));
if (token == (char *) NULL)
break;
next=0;
arguments=arg1;
token_info=AcquireTokenInfo();
status=Tokenizer(token_info,0,token,length,arguments,"","=",
"\"",'\0',&breaker,&next,"e);
token_info=DestroyTokenInfo(token_info);
if (status == 0)
{
const char
*argv;
argv=(&(arguments[next]));
(void) InvokeDynamicImageFilter(token,&_images,1,&argv,
_exception);
}
token=DestroyString(token);
break;
}
(void) SubstituteString(&arguments[1],"-","");
(void) InvokeDynamicImageFilter(arguments[1],&_images,
number_arguments-2,(const char **) arguments+2,_exception);
for (j=0; j < number_arguments; j++)
arguments[j]=DestroyString(arguments[j]);
arguments=(char **) RelinquishMagickMemory(arguments);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 'r':
{
if (LocaleCompare("remap",option+1) == 0)
{
(void) RemapImages(_quantize_info,_images,(Image *) NULL,_exception);
break;
}
if (LocaleCompare("reverse",option+1) == 0)
{
ReverseImageList(&_images);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
case 's':
{
if (LocaleCompare("smush",option+1) == 0)
{
/* FUTURE: this option needs more work to make better */
ssize_t
offset;
if (IsGeometry(arg1) == MagickFalse)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
offset=(ssize_t) StringToLong(arg1);
new_images=SmushImages(_images,IsNormalOp,offset,_exception);
break;
}
if (LocaleCompare("subimage",option+1) == 0)
{
Image
*base_image,
*compare_image;
const char
*value;
MetricType
metric;
double
similarity;
RectangleInfo
offset;
base_image=GetImageFromList(_images,0);
compare_image=GetImageFromList(_images,1);
/* Comparision Metric */
metric=UndefinedErrorMetric;
value=GetImageOption(_image_info,"metric");
if (value != (const char *) NULL)
metric=(MetricType) ParseCommandOption(MagickMetricOptions,
MagickFalse,value);
new_images=SimilarityImage(base_image,compare_image,metric,0.0,
&offset,&similarity,_exception);
if (new_images != (Image *) NULL)
{
char
result[MagickPathExtent];
(void) FormatLocaleString(result,MagickPathExtent,"%lf",
similarity);
(void) SetImageProperty(new_images,"subimage:similarity",result,
_exception);
(void) FormatLocaleString(result,MagickPathExtent,"%+ld",(long)
offset.x);
(void) SetImageProperty(new_images,"subimage:x",result,
_exception);
(void) FormatLocaleString(result,MagickPathExtent,"%+ld",(long)
offset.y);
(void) SetImageProperty(new_images,"subimage:y",result,
_exception);
(void) FormatLocaleString(result,MagickPathExtent,
"%lux%lu%+ld%+ld",(unsigned long) offset.width,(unsigned long)
offset.height,(long) offset.x,(long) offset.y);
(void) SetImageProperty(new_images,"subimage:offset",result,
_exception);
}
break;
}
if (LocaleCompare("swap",option+1) == 0)
{
Image
*p,
*q,
*swap;
ssize_t
index,
swap_index;
index=(-1);
swap_index=(-2);
if (IfNormalOp) {
GeometryInfo
geometry_info;
MagickStatusType
flags;
swap_index=(-1);
flags=ParseGeometry(arg1,&geometry_info);
if ((flags & RhoValue) == 0)
CLIWandExceptArgBreak(OptionError,"InvalidArgument",option,arg1);
index=(ssize_t) geometry_info.rho;
if ((flags & SigmaValue) != 0)
swap_index=(ssize_t) geometry_info.sigma;
}
p=GetImageFromList(_images,index);
q=GetImageFromList(_images,swap_index);
if ((p == (Image *) NULL) || (q == (Image *) NULL)) {
if (IfNormalOp)
CLIWandExceptArgBreak(OptionError,"InvalidImageIndex",option,arg1)
else
CLIWandExceptionBreak(OptionError,"TwoOrMoreImagesRequired",option);
}
if (p == q)
CLIWandExceptArgBreak(OptionError,"InvalidImageIndex",option,arg1);
swap=CloneImage(p,0,0,MagickTrue,_exception);
if (swap == (Image *) NULL)
CLIWandExceptArgBreak(ResourceLimitError,"MemoryAllocationFailed",
option,GetExceptionMessage(errno));
ReplaceImageInList(&p,CloneImage(q,0,0,MagickTrue,_exception));
ReplaceImageInList(&q,swap);
_images=GetFirstImageInList(q);
break;
}
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
default:
CLIWandExceptionBreak(OptionError,"UnrecognizedOption",option);
}
/* clean up percent escape interpreted strings */
if (arg1 != arg1n )
arg1=DestroyString((char *)arg1);
if (arg2 != arg2n )
arg2=DestroyString((char *)arg2);
/* if new image list generated, replace existing image list */
if (new_images == (Image *) NULL)
return(status == 0 ? MagickFalse : MagickTrue);
_images=DestroyImageList(_images);
_images=GetFirstImageInList(new_images);
return(status == 0 ? MagickFalse : MagickTrue);
#undef _image_info
#undef _images
#undef _exception
#undef _draw_info
#undef _quantize_info
#undef IfNormalOp
#undef IfPlusOp
#undef IsNormalOp
}
| 1
|
142,431
|
static double mp_image_stats(_cimg_math_parser& mp) {
double *ptrd = &_mp_arg(1) + 1;
unsigned int ind = (unsigned int)mp.opcode[2];
if (ind==~0U) CImg<doubleT>(ptrd,14,1,1,1,true) = mp.imgout.get_stats();
else {
ind = (unsigned int)cimg::mod((int)_mp_arg(2),mp.listin.width());
CImg<doubleT>(ptrd,14,1,1,1,true) = mp.listout[ind].get_stats();
}
return cimg::type<double>::nan();
| 0
|
202,529
|
_fep_transceive_control_message (Fep *fep,
int fd,
FepControlMessage *request,
FepControlMessage *response)
{
FepList *messages = NULL;
int retval = 0;
retval = _fep_write_control_message (fd, request);
if (retval < 0)
return retval;
while (true)
{
FepControlMessage message;
retval = _fep_read_control_message (fd, &message);
if (retval < 0)
goto out;
if (message.command == FEP_CONTROL_RESPONSE)
{
memcpy (response, &message, sizeof (FepControlMessage));
break;
}
fep_log (FEP_LOG_LEVEL_DEBUG,
"not a control response %d",
message.command);
messages = _fep_append_control_message (messages, &message);
}
if (response->n_args == 0)
{
_fep_control_message_free_args (response);
fep_log (FEP_LOG_LEVEL_WARNING,
"too few arguments for RESPONSE");
retval = -1;
goto out;
}
if (response->args[0].len != 1)
{
_fep_control_message_free_args (response);
fep_log (FEP_LOG_LEVEL_WARNING,
"can't extract command from RESPONSE");
retval = -1;
goto out;
}
if (*response->args[0].str != request->command)
{
_fep_control_message_free_args (response);
fep_log (FEP_LOG_LEVEL_WARNING,
"commands do not match (%d != %d)",
*response->args[0].str,
request->command);
retval = -1;
goto out;
}
out:
/* flush queued messages received during waiting for response */
while (messages)
{
FepList *_head = messages;
FepControlMessage *_message = _head->data;
messages = _head->next;
_fep_dispatch_control_message (fep, _message);
_fep_control_message_free (_message);
free (_head);
}
return retval;
}
| 0
|
84,149
|
static int lsm_set_label_at(int lsm_labelfd, int on_exec, char *lsm_label)
{
int fret = -1;
const char* name;
char *command = NULL;
name = lsm_name();
if (strcmp(name, "nop") == 0)
return 0;
if (strcmp(name, "none") == 0)
return 0;
/* We don't support on-exec with AppArmor */
if (strcmp(name, "AppArmor") == 0)
on_exec = 0;
if (strcmp(name, "AppArmor") == 0) {
int size;
command = malloc(strlen(lsm_label) + strlen("changeprofile ") + 1);
if (!command) {
SYSERROR("Failed to write apparmor profile");
goto out;
}
size = sprintf(command, "changeprofile %s", lsm_label);
if (size < 0) {
SYSERROR("Failed to write apparmor profile");
goto out;
}
if (write(lsm_labelfd, command, size + 1) < 0) {
SYSERROR("Unable to set LSM label: %s.", command);
goto out;
}
INFO("Set LSM label to: %s.", command);
} else if (strcmp(name, "SELinux") == 0) {
if (write(lsm_labelfd, lsm_label, strlen(lsm_label) + 1) < 0) {
SYSERROR("Unable to set LSM label");
goto out;
}
INFO("Set LSM label to: %s.", lsm_label);
} else {
ERROR("Unable to restore label for unknown LSM: %s", name);
goto out;
}
fret = 0;
out:
free(command);
if (lsm_labelfd != -1)
close(lsm_labelfd);
return fret;
}
| 0
|
346,390
|
static int mb86a20s_read_status(struct dvb_frontend *fe, enum fe_status *status)
{
struct mb86a20s_state *state = fe->demodulator_priv;
int val;
*status = 0;
val = mb86a20s_readreg(state, 0x0a) & 0xf;
if (val < 0)
return val;
if (val >= 2)
*status |= FE_HAS_SIGNAL;
if (val >= 4)
*status |= FE_HAS_CARRIER;
if (val >= 5)
*status |= FE_HAS_VITERBI;
if (val >= 7)
*status |= FE_HAS_SYNC;
if (val >= 8) /* Maybe 9? */
*status |= FE_HAS_LOCK;
dev_dbg(&state->i2c->dev, "%s: Status = 0x%02x (state = %d)\n",
__func__, *status, val);
return val;
}
| 1
|
373,842
|
void getQueryStuff(const char *&query, int& ntoreturn) {
int *i = (int *) (data + strlen(data) + 1);
ntoreturn = *i;
i++;
query = (const char *) i;
}
| 0
|
421,889
|
flatpak_dir_update_appstream_oci (FlatpakDir *self,
const char *remote,
const char *arch,
gboolean *out_changed,
OstreeAsyncProgress *progress,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GFile) arch_dir = NULL;
g_autoptr(GFile) lock_file = NULL;
g_auto(GLnxLockFile) lock = { 0, };
g_autoptr(GFile) index_cache = NULL;
g_autofree char *index_uri = NULL;
g_autoptr(GFile) timestamp_file = NULL;
g_autoptr(GFile) icons_dir = NULL;
glnx_autofd int icons_dfd = -1;
g_autoptr(GBytes) appstream = NULL;
g_autoptr(GFile) new_appstream_file = NULL;
arch_dir = flatpak_build_file (flatpak_dir_get_path (self),
"appstream", remote, arch, NULL);
if (g_mkdir_with_parents (flatpak_file_get_path_cached (arch_dir), 0755) != 0)
{
glnx_set_error_from_errno (error);
return FALSE;
}
lock_file = g_file_get_child (arch_dir, "lock");
if (!glnx_make_lock_file (AT_FDCWD, flatpak_file_get_path_cached (lock_file),
LOCK_EX, &lock, error))
return FALSE;
index_cache = flatpak_dir_update_oci_index (self, remote, &index_uri, cancellable, error);
if (index_cache == NULL)
return FALSE;
timestamp_file = g_file_get_child (arch_dir, ".timestamp");
if (check_destination_mtime (index_cache, timestamp_file, cancellable))
return TRUE;
icons_dir = g_file_get_child (arch_dir, "icons");
if (g_mkdir_with_parents (flatpak_file_get_path_cached (icons_dir), 0755) != 0)
{
glnx_set_error_from_errno (error);
return FALSE;
}
if (!glnx_opendirat (AT_FDCWD, flatpak_file_get_path_cached (icons_dir),
FALSE, &icons_dfd, error))
return FALSE;
ensure_soup_session (self);
appstream = flatpak_oci_index_make_appstream (self->soup_session,
index_cache,
index_uri,
arch,
icons_dfd,
cancellable,
error);
if (appstream == NULL)
return FALSE;
new_appstream_file = g_file_get_child (arch_dir, "appstream.xml.gz");
if (!replace_contents_compressed (new_appstream_file, appstream, cancellable, error))
return FALSE;
if (!g_file_replace_contents (timestamp_file, "", 0, NULL, FALSE,
G_FILE_CREATE_REPLACE_DESTINATION, NULL, NULL, error))
return FALSE;
if (out_changed)
*out_changed = TRUE;
return TRUE;
}
| 0
|
116,416
|
void xmlrpc_send_string(const char *value)
{
int len;
char buf[1024];
const char *ss;
mowgli_string_t *s = mowgli_string_create();
char *s2;
char *header;
if (xmlrpc.encode)
{
snprintf(buf, sizeof buf, "<?xml version=\"1.0\" encoding=\"%s\" ?>\r\n<methodResponse>\r\n<params>\r\n", xmlrpc.encode);
}
else
{
snprintf(buf, sizeof buf, "<?xml version=\"1.0\"?>\r\n<methodResponse>\r\n<params>\r\n");
}
s->append(s, buf, strlen(buf));
ss = " <param>\r\n <value>\r\n <string>";
s->append(s, ss, strlen(ss));
xmlrpc_append_char_encode(s, value);
ss = "</string>\r\n </value>\r\n </param>\r\n";
s->append(s, ss, strlen(ss));
ss = "</params>\r\n</methodResponse>";
s->append(s, ss, strlen(ss));
len = s->pos;
if (xmlrpc.httpheader)
{
header = xmlrpc_write_header(len);
s2 = smalloc(strlen(header) + len + 1);
strcpy(s2, header);
memcpy(s2 + strlen(header), s->str, len);
xmlrpc.setbuffer(s2, len + strlen(header));
free(header);
free(s2);
xmlrpc.httpheader = 1;
}
else
{
xmlrpc.setbuffer(s->str, len);
}
if (xmlrpc.encode)
{
free(xmlrpc.encode);
xmlrpc.encode = NULL;
}
s->destroy(s);
}
| 0
|
497,260
|
static void parse_sec_attr(sc_file_t *file, const u8 *buf, size_t len)
{
size_t i;
const int *idx;
idx = (file->type == SC_FILE_TYPE_DF) ? df_acl : ef_acl;
/* acl defaults to 0xFF if unspecified */
for (i = 0; i < 9; i++)
if (idx[i] != -1)
add_acl_entry(file, idx[i], (u8)((i < len) ? buf[i] : 0xFF));
}
| 0
|
373,595
|
static void init_amd_k6(struct cpuinfo_x86 *c)
{
u32 l, h;
int mbytes = get_num_physpages() >> (20-PAGE_SHIFT);
if (c->x86_model < 6) {
/* Based on AMD doc 20734R - June 2000 */
if (c->x86_model == 0) {
clear_cpu_cap(c, X86_FEATURE_APIC);
set_cpu_cap(c, X86_FEATURE_PGE);
}
return;
}
if (c->x86_model == 6 && c->x86_mask == 1) {
const int K6_BUG_LOOP = 1000000;
int n;
void (*f_vide)(void);
unsigned long d, d2;
printk(KERN_INFO "AMD K6 stepping B detected - ");
/*
* It looks like AMD fixed the 2.6.2 bug and improved indirect
* calls at the same time.
*/
n = K6_BUG_LOOP;
f_vide = vide;
rdtscl(d);
while (n--)
f_vide();
rdtscl(d2);
d = d2-d;
if (d > 20*K6_BUG_LOOP)
printk(KERN_CONT
"system stability may be impaired when more than 32 MB are used.\n");
else
printk(KERN_CONT "probably OK (after B9730xxxx).\n");
}
/* K6 with old style WHCR */
if (c->x86_model < 8 ||
(c->x86_model == 8 && c->x86_mask < 8)) {
/* We can only write allocate on the low 508Mb */
if (mbytes > 508)
mbytes = 508;
rdmsr(MSR_K6_WHCR, l, h);
if ((l&0x0000FFFF) == 0) {
unsigned long flags;
l = (1<<0)|((mbytes/4)<<1);
local_irq_save(flags);
wbinvd();
wrmsr(MSR_K6_WHCR, l, h);
local_irq_restore(flags);
printk(KERN_INFO "Enabling old style K6 write allocation for %d Mb\n",
mbytes);
}
return;
}
if ((c->x86_model == 8 && c->x86_mask > 7) ||
c->x86_model == 9 || c->x86_model == 13) {
/* The more serious chips .. */
if (mbytes > 4092)
mbytes = 4092;
rdmsr(MSR_K6_WHCR, l, h);
if ((l&0xFFFF0000) == 0) {
unsigned long flags;
l = ((mbytes>>2)<<22)|(1<<16);
local_irq_save(flags);
wbinvd();
wrmsr(MSR_K6_WHCR, l, h);
local_irq_restore(flags);
printk(KERN_INFO "Enabling new style K6 write allocation for %d Mb\n",
mbytes);
}
return;
}
if (c->x86_model == 10) {
/* AMD Geode LX is model 10 */
/* placeholder for any needed mods */
return;
}
}
| 0
|
180,365
|
void UserCloudPolicyManagerChromeOS::StartRefreshSchedulerIfReady() {
if (core()->refresh_scheduler())
return; // Already started.
if (wait_for_policy_fetch_)
return; // Still waiting for the initial, blocking fetch.
if (!service() || !local_state_)
return; // Not connected.
if (component_policy_service() &&
!component_policy_service()->is_initialized()) {
return;
}
core()->StartRefreshScheduler();
core()->TrackRefreshDelayPref(local_state_,
policy_prefs::kUserPolicyRefreshRate);
}
| 0
|
302,570
|
void CreateExtremalDataAndRunAveragePool(bool padding_same) {
const int batch = UniformRandomInt(1, 2);
const int input_depth = UniformRandomInt(1, 700);
const int output_depth = input_depth;
const int input_width_offset = UniformRandomInt(1, 30);
const int input_height_offset = UniformRandomInt(1, 30);
const int stride_width = UniformRandomInt(1, 128);
const int stride_height = UniformRandomInt(1, 128);
const int filter_width = UniformRandomInt(1, 28);
const int filter_height = UniformRandomInt(1, 28);
if (filter_width * filter_height > 64) {
std::cout << "should test 32 version" << std::endl;
}
const int input_width = input_width_offset + filter_width;
const int input_height = input_height_offset + filter_height;
const int output_width =
padding_same ? (input_width + stride_width - 1) / stride_width
: (input_width - filter_width + stride_width) / stride_width;
const int output_height =
padding_same
? (input_height + stride_height - 1) / stride_height
: (input_height - filter_height + stride_height) / stride_height;
auto input_shape =
RuntimeShape({batch, input_height, input_width, input_depth});
auto output_shape =
RuntimeShape({batch, output_height, output_width, output_depth});
PoolParams params;
params.stride_height = stride_height;
params.stride_width = stride_width;
params.filter_height = filter_height;
params.filter_width = filter_width;
params.quantized_activation_min =
static_cast<int8_t>(std::numeric_limits<int8_t>::lowest());
params.quantized_activation_max =
static_cast<int8_t>(std::numeric_limits<int8_t>::max());
auto compute_padding = [](int stride, int in_size, int filter_size,
int out_size) {
int padding = ((out_size - 1) * stride + filter_size - in_size) / 2;
return padding > 0 ? padding : 0;
};
params.padding_values.width =
compute_padding(stride_width, input_width, filter_width, output_width);
params.padding_values.height = compute_padding(stride_height, input_height,
filter_height, output_height);
const int buffer_size = input_shape.FlatSize();
std::vector<int8> input_data(buffer_size);
// Test small values
int8 min = std::numeric_limits<int8>::min();
int8 max = std::numeric_limits<int8>::min() + 10;
FillRandom(&input_data, min, max);
RunOneAveragePoolTest(params, input_shape, input_data.data(), output_shape);
// Test large values
min = std::numeric_limits<int8>::max() - 10;
max = std::numeric_limits<int8>::max();
FillRandom(&input_data, min, max);
RunOneAveragePoolTest(params, input_shape, input_data.data(), output_shape);
}
| 0
|
83,105
|
static int cbs_av1_read_increment(CodedBitstreamContext *ctx, GetBitContext *gbc,
uint32_t range_min, uint32_t range_max,
const char *name, uint32_t *write_to)
{
uint32_t value;
int position, i;
char bits[33];
av_assert0(range_min <= range_max && range_max - range_min < sizeof(bits) - 1);
if (ctx->trace_enable)
position = get_bits_count(gbc);
for (i = 0, value = range_min; value < range_max;) {
if (get_bits_left(gbc) < 1) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid increment value at "
"%s: bitstream ended.\n", name);
return AVERROR_INVALIDDATA;
}
if (get_bits1(gbc)) {
bits[i++] = '1';
++value;
} else {
bits[i++] = '0';
break;
}
}
if (ctx->trace_enable) {
bits[i] = 0;
ff_cbs_trace_syntax_element(ctx, position,
name, NULL, bits, value);
}
*write_to = value;
return 0;
}
| 0
|
308,255
|
static void ParseCharacterContent(XMLTreeRoot *root,char *xml,
const size_t length,const char state)
{
XMLTreeInfo
*xml_info;
xml_info=root->node;
if ((xml_info == (XMLTreeInfo *) NULL) || (xml_info->tag == (char *) NULL) ||
(length == 0))
return;
xml[length]='\0';
xml=ParseEntities(xml,root->entities,state);
if ((xml_info->content != (char *) NULL) && (*xml_info->content != '\0'))
{
(void) ConcatenateString(&xml_info->content,xml);
xml=DestroyString(xml);
}
else
{
if (xml_info->content != (char *) NULL)
xml_info->content=DestroyString(xml_info->content);
xml_info->content=xml;
}
}
| 0
|
81,599
|
static void write_sse_reg(struct x86_emulate_ctxt *ctxt, sse128_t *data,
int reg)
{
ctxt->ops->get_fpu(ctxt);
switch (reg) {
case 0: asm("movdqu %0, %%xmm0" : : "m"(*data)); break;
case 1: asm("movdqu %0, %%xmm1" : : "m"(*data)); break;
case 2: asm("movdqu %0, %%xmm2" : : "m"(*data)); break;
case 3: asm("movdqu %0, %%xmm3" : : "m"(*data)); break;
case 4: asm("movdqu %0, %%xmm4" : : "m"(*data)); break;
case 5: asm("movdqu %0, %%xmm5" : : "m"(*data)); break;
case 6: asm("movdqu %0, %%xmm6" : : "m"(*data)); break;
case 7: asm("movdqu %0, %%xmm7" : : "m"(*data)); break;
#ifdef CONFIG_X86_64
case 8: asm("movdqu %0, %%xmm8" : : "m"(*data)); break;
case 9: asm("movdqu %0, %%xmm9" : : "m"(*data)); break;
case 10: asm("movdqu %0, %%xmm10" : : "m"(*data)); break;
case 11: asm("movdqu %0, %%xmm11" : : "m"(*data)); break;
case 12: asm("movdqu %0, %%xmm12" : : "m"(*data)); break;
case 13: asm("movdqu %0, %%xmm13" : : "m"(*data)); break;
case 14: asm("movdqu %0, %%xmm14" : : "m"(*data)); break;
case 15: asm("movdqu %0, %%xmm15" : : "m"(*data)); break;
#endif
default: BUG();
}
ctxt->ops->put_fpu(ctxt);
}
| 0
|
124,137
|
static inline bool is_invalid_opcode(u32 intr_info)
{
return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
INTR_INFO_VALID_MASK)) ==
(INTR_TYPE_HARD_EXCEPTION | UD_VECTOR | INTR_INFO_VALID_MASK);
}
| 0
|
172,270
|
int FileStream::Read(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) {
if (!IsOpen())
return ERR_UNEXPECTED;
DCHECK_GT(buf_len, 0);
return context_->Read(buf, buf_len, callback);
}
| 0
|
338,746
|
static void pmac_dma_write(BlockBackend *blk,
int64_t sector_num, int nb_sectors,
void (*cb)(void *opaque, int ret), void *opaque)
{
DBDMA_io *io = opaque;
MACIOIDEState *m = io->opaque;
IDEState *s = idebus_active_if(&m->bus);
dma_addr_t dma_addr, dma_len;
void *mem;
int nsector, remainder;
int extra = 0;
qemu_iovec_destroy(&io->iov);
qemu_iovec_init(&io->iov, io->len / MACIO_PAGE_SIZE + 1);
if (io->remainder_len > 0) {
/* Return remainder of request */
int transfer = MIN(io->remainder_len, io->len);
MACIO_DPRINTF("--- processing write remainder %x\n", transfer);
cpu_physical_memory_read(io->addr,
&io->remainder + (0x200 - transfer),
transfer);
io->remainder_len -= transfer;
io->len -= transfer;
io->addr += transfer;
s->io_buffer_index += transfer;
s->io_buffer_size -= transfer;
if (io->remainder_len != 0) {
/* Still waiting for remainder */
return;
}
MACIO_DPRINTF("--> prepending bounce buffer with size 0x200\n");
/* Sector transfer complete - prepend to request */
qemu_iovec_add(&io->iov, &io->remainder, 0x200);
extra = 1;
}
if (s->drive_kind == IDE_CD) {
sector_num = (int64_t)(s->lba << 2) + (s->io_buffer_index >> 9);
} else {
sector_num = ide_get_sector(s) + (s->io_buffer_index >> 9);
}
nsector = (io->len >> 9);
remainder = io->len - (nsector << 9);
MACIO_DPRINTF("--- DMA write transfer - addr: %" HWADDR_PRIx " len: %x\n",
io->addr, io->len);
MACIO_DPRINTF("xxx remainder: %x\n", remainder);
MACIO_DPRINTF("xxx sector_num: %"PRIx64" nsector: %x\n",
sector_num, nsector);
dma_addr = io->addr;
dma_len = io->len;
mem = dma_memory_map(&address_space_memory, dma_addr, &dma_len,
DMA_DIRECTION_TO_DEVICE);
if (!remainder) {
MACIO_DPRINTF("--- DMA write aligned - addr: %" HWADDR_PRIx
" len: %x\n", io->addr, io->len);
qemu_iovec_add(&io->iov, mem, io->len);
} else {
/* Write up to last complete sector */
MACIO_DPRINTF("--- DMA write unaligned - addr: %" HWADDR_PRIx
" len: %x\n", io->addr, (nsector << 9));
qemu_iovec_add(&io->iov, mem, (nsector << 9));
MACIO_DPRINTF("--- DMA write read - bounce addr: %p "
"remainder_len: %x\n", &io->remainder, remainder);
cpu_physical_memory_read(io->addr + (nsector << 9), &io->remainder,
remainder);
io->remainder_len = 0x200 - remainder;
MACIO_DPRINTF("xxx remainder_len: %x\n", io->remainder_len);
}
s->io_buffer_size -= ((nsector + extra) << 9);
s->io_buffer_index += ((nsector + extra) << 9);
io->len = 0;
MACIO_DPRINTF("--- Block write transfer - sector_num: %"PRIx64" "
"nsector: %x\n", sector_num, nsector + extra);
m->aiocb = blk_aio_writev(blk, sector_num, &io->iov, nsector + extra, cb,
io);
}
| 1
|
142,098
|
void isor_reader_get_sample(ISOMChannel *ch)
{
GF_Err e;
u32 sample_desc_index;
if (ch->sample) return;
if (ch->next_track) {
ch->track = ch->next_track;
ch->next_track = 0;
}
if (ch->to_init) {
init_reader(ch);
sample_desc_index = ch->last_sample_desc_index;
} else if (ch->speed < 0) {
if (ch->last_state == GF_EOS) {
ch->sample = NULL;
return;
}
if (ch->static_sample->IsRAP) {
ch->last_rap_sample_time = ch->sample_time;
}
e = gf_isom_get_sample_for_movie_time(ch->owner->mov, ch->track, ch->sample_time + 1, &sample_desc_index, GF_ISOM_SEARCH_FORWARD, &ch->static_sample, &ch->sample_num, NULL);
if ((e==GF_EOS) || (ch->static_sample->IsRAP)) {
if (!ch->last_rap_sample_time) {
e = GF_EOS;
} else {
e = gf_isom_get_sample_for_movie_time(ch->owner->mov, ch->track, ch->last_rap_sample_time - 1, &sample_desc_index, GF_ISOM_SEARCH_SYNC_BACKWARD, &ch->static_sample, &ch->sample_num, NULL);
}
}
if (e) {
if ((e==GF_EOS) && !ch->owner->frag_type) {
ch->last_state = GF_EOS;
}
ch->sample = NULL;
return;
}
ch->sample = ch->static_sample;
if (ch->sample->DTS == ch->sample_time) {
if (!ch->owner->frag_type) {
ch->last_state = GF_EOS;
}
}
if (ch->sample) {
ch->sample_time = ch->sample->DTS;
}
} else if (ch->has_edit_list) {
u32 prev_sample = ch->sample_num;
e = gf_isom_get_sample_for_movie_time(ch->owner->mov, ch->track, ch->sample_time + 1, &sample_desc_index, GF_ISOM_SEARCH_FORWARD, &ch->static_sample, &ch->sample_num, &ch->sample_data_offset);
if (e == GF_OK) {
ch->sample = ch->static_sample;
/*we are in forced seek mode: fetch all samples before the one matching the sample time*/
if (ch->edit_sync_frame) {
ch->edit_sync_frame++;
if (ch->edit_sync_frame < ch->sample_num) {
ch->sample = gf_isom_get_sample_ex(ch->owner->mov, ch->track, ch->edit_sync_frame, &sample_desc_index, ch->static_sample, &ch->sample_data_offset);
ch->sample->DTS = ch->sample_time;
ch->sample->CTS_Offset = 0;
} else {
ch->edit_sync_frame = 0;
if (ch->sample) ch->sample_time = ch->sample->DTS;
}
} else {
/*if we get the same sample, figure out next interesting time (current sample + DTS gap to next sample should be a good bet)*/
if (prev_sample == ch->sample_num) {
if (ch->owner->frag_type && (ch->sample_num==gf_isom_get_sample_count(ch->owner->mov, ch->track))) {
ch->sample = NULL;
} else {
u32 sample_num = ch->sample_num ? ch->sample_num : 1;
if (sample_num >= gf_isom_get_sample_count(ch->owner->mov, ch->track) ) {
//e = GF_EOS;
} else {
u32 time_diff = gf_isom_get_sample_duration(ch->owner->mov, ch->track, sample_num);
e = gf_isom_get_sample_for_movie_time(ch->owner->mov, ch->track, ch->sample_time + time_diff, &sample_desc_index, GF_ISOM_SEARCH_FORWARD, &ch->static_sample, &ch->sample_num, &ch->sample_data_offset);
if (e==GF_OK) {
if (ch->sample_num == prev_sample) {
ch->sample_time += time_diff;
ch->sample = NULL;
return;
} else {
ch->sample = ch->static_sample;
}
}
}
}
}
/*we jumped to another segment - if RAP is needed look for closest rap in decoding order and
force seek mode*/
if (ch->sample && !ch->sample->IsRAP && ch->has_rap && (ch->sample_num != prev_sample+1)) {
GF_ISOSample *found = ch->static_sample;
u32 samp_num = ch->sample_num;
ch->sample = NULL;
e = gf_isom_get_sample_for_movie_time(ch->owner->mov, ch->track, ch->sample_time + 1, &sample_desc_index, GF_ISOM_SEARCH_SYNC_BACKWARD, &ch->static_sample, &ch->sample_num, &ch->sample_data_offset);
if (e == GF_OK) ch->sample = ch->static_sample;
/*if no sync point in the past, use the first non-sync for the given time*/
if (!ch->sample || !ch->sample->data) {
ch->sample = ch->static_sample = found;
ch->sample_time = ch->sample->DTS;
ch->sample_num = samp_num;
} else {
ch->sample = ch->static_sample;
ch->edit_sync_frame = ch->sample_num;
ch->sample->DTS = ch->sample_time;
ch->sample->CTS_Offset = 0;
}
} else {
if (ch->sample) ch->sample_time = ch->sample->DTS;
}
}
}
} else {
Bool do_fetch = GF_TRUE;
ch->sample_num++;
if (ch->sap_only) {
Bool is_rap = gf_isom_get_sample_sync(ch->owner->mov, ch->track, ch->sample_num);
if (!is_rap) {
GF_ISOSampleRollType roll_type;
gf_isom_get_sample_rap_roll_info(ch->owner->mov, ch->track, ch->sample_num, &is_rap, &roll_type, NULL);
if (roll_type) is_rap = GF_TRUE;
}
if (!is_rap) {
do_fetch = GF_FALSE;
} else if (ch->sap_only==2) {
ch->sap_only = 0;
}
}
if (do_fetch) {
if (ch->owner->nodata) {
ch->sample = gf_isom_get_sample_info_ex(ch->owner->mov, ch->track, ch->sample_num, &sample_desc_index, &ch->sample_data_offset, ch->static_sample);
} else {
ch->sample = gf_isom_get_sample_ex(ch->owner->mov, ch->track, ch->sample_num, &sample_desc_index, ch->static_sample, &ch->sample_data_offset);
}
/*if sync shadow / carousel RAP skip*/
if (ch->sample && (ch->sample->IsRAP==RAP_REDUNDANT)) {
ch->sample = NULL;
ch->sample_num++;
isor_reader_get_sample(ch);
return;
}
}
}
//check scalable track change
if (ch->sample && ch->sample->IsRAP && ch->next_track) {
ch->track = ch->next_track;
ch->next_track = 0;
ch->sample = NULL;
isor_reader_get_sample(ch);
return;
}
if (!ch->sample) {
u32 sample_count = gf_isom_get_sample_count(ch->owner->mov, ch->track);
ch->sample_data_offset = 0;
/*incomplete file - check if we're still downloading or not*/
if (gf_isom_get_missing_bytes(ch->owner->mov, ch->track)) {
ch->last_state = GF_ISOM_INCOMPLETE_FILE;
if (ch->owner->mem_load_mode==2)
ch->owner->force_fetch = GF_TRUE;
if (!ch->owner->input_loaded) {
ch->last_state = GF_OK;
if (!ch->has_edit_list && ch->sample_num)
ch->sample_num--;
} else {
if (ch->to_init && ch->sample_num) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[IsoMedia] Failed to fetch initial sample %d for track %d\n"));
ch->last_state = GF_ISOM_INVALID_FILE;
}
if (ch->sample_num >= gf_isom_get_sample_count(ch->owner->mov, ch->track)) {
ch->last_state = GF_EOS;
}
}
}
else if (!ch->sample_num
|| ((ch->speed >= 0) && (ch->sample_num >= sample_count))
|| ((ch->speed < 0) && (ch->sample_time == gf_isom_get_current_tfdt(ch->owner->mov, ch->track) ))
) {
if (ch->owner->frag_type==1) {
/*if sample cannot be found and file is fragmented, rewind sample*/
if (ch->sample_num) ch->sample_num--;
ch->last_state = GF_EOS;
} else if (ch->last_state != GF_EOS) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[IsoMedia] Track #%d end of stream reached\n", ch->track));
ch->last_state = GF_EOS;
if (ch->sample_num>sample_count) ch->sample_num = sample_count;
} else {
if (ch->sample_num>sample_count) ch->sample_num = sample_count;
}
} else {
e = gf_isom_last_error(ch->owner->mov);
GF_LOG((e==GF_ISOM_INCOMPLETE_FILE) ? GF_LOG_DEBUG : GF_LOG_WARNING, GF_LOG_DASH, ("[IsoMedia] Track #%d fail to fetch sample %d / %d: %s\n", ch->track, ch->sample_num, gf_isom_get_sample_count(ch->owner->mov, ch->track), gf_error_to_string(e) ));
}
return;
}
if (sample_desc_index != ch->last_sample_desc_index) {
if (!ch->owner->stsd) {
//we used sample entry 1 by default to setup, if no active prev sample (edit list might trigger this)
//and new sample desc is 1, do not reconfigure
if (!ch->last_sample_desc_index && (sample_desc_index==1)) {
} else {
ch->needs_pid_reconfig = GF_TRUE;
}
}
ch->last_sample_desc_index = sample_desc_index;
}
ch->last_state = GF_OK;
ch->au_duration = gf_isom_get_sample_duration(ch->owner->mov, ch->track, ch->sample_num);
ch->sap_3 = GF_FALSE;
ch->sap_4_type = 0;
ch->roll = 0;
ch->set_disc = ch->owner->clock_discontinuity ? 2 : 0;
ch->owner->clock_discontinuity = 0;
if (ch->sample) {
gf_isom_get_sample_rap_roll_info(ch->owner->mov, ch->track, ch->sample_num, &ch->sap_3, &ch->sap_4_type, &ch->roll);
/*still seeking or not ?
1- when speed is negative, the RAP found is "after" the seek point in playback order since we used backward RAP search: nothing to do
2- otherwise set DTS+CTS to start value
*/
if ((ch->speed < 0) || (ch->start <= ch->sample->DTS + ch->sample->CTS_Offset)) {
ch->dts = ch->sample->DTS;
ch->cts = ch->sample->DTS + ch->sample->CTS_Offset;
ch->seek_flag = 0;
} else {
ch->cts = ch->start;
ch->seek_flag = 1;
ch->dts = ch->start;
}
if (ch->end && (ch->end < ch->sample->DTS + ch->sample->CTS_Offset + ch->au_duration)) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[IsoMedia] End of Channel "LLD" (CTS "LLD")\n", ch->end, ch->sample->DTS + ch->sample->CTS_Offset));
ch->sample = NULL;
ch->last_state = GF_EOS;
ch->playing = 2;
return;
}
}
if (ch->owner->last_sender_ntp && ch->cts==ch->owner->cts_for_last_sender_ntp) {
ch->sender_ntp = ch->owner->last_sender_ntp;
ch->ntp_at_server_ntp = ch->owner->ntp_at_last_sender_ntp;
} else if (ch->owner->last_sender_ntp && ch->dts==ch->owner->cts_for_last_sender_ntp) {
ch->sender_ntp = ch->owner->last_sender_ntp;
ch->ntp_at_server_ntp = ch->owner->ntp_at_last_sender_ntp;
} else {
ch->sender_ntp = ch->ntp_at_server_ntp = 0;
}
if (!ch->sample_num) return;
gf_isom_get_sample_flags(ch->owner->mov, ch->track, ch->sample_num, &ch->isLeading, &ch->dependsOn, &ch->dependedOn, &ch->redundant);
if (ch->is_encrypted) {
/*in case of CENC: we write sample auxiliary information to slh->sai; its size is in saiz*/
if (gf_isom_is_cenc_media(ch->owner->mov, ch->track, ch->last_sample_desc_index)) {
isor_update_cenc_info(ch, GF_FALSE);
} else if (gf_isom_is_media_encrypted(ch->owner->mov, ch->track, ch->last_sample_desc_index)) {
ch->pck_encrypted = GF_TRUE;
} else {
ch->pck_encrypted = GF_FALSE;
}
}
if (ch->sample && ch->sample->nb_pack)
ch->sample_num += ch->sample->nb_pack-1;
}
| 0
|
179,401
|
void ChromeContentUtilityClient::RegisterMojoServices(
content::ServiceRegistry* registry) {
#if !defined(OS_ANDROID)
registry->AddService<net::interfaces::ProxyResolverFactory>(
base::Bind(CreateProxyResolverFactory));
registry->AddService<ResourceUsageReporter>(
base::Bind(CreateResourceUsageReporter));
#endif
}
| 0
|
26,664
|
static bool str_array_contains ( ARRAY_TYPE ( const_string ) * arr , const char * str ) {
const char * const * p ;
array_foreach ( arr , p ) {
if ( strcmp ( * p , str ) == 0 ) return TRUE ;
}
return FALSE ;
}
| 0
|
449,432
|
void ttm_tt_unbind(struct ttm_tt *ttm)
{
if (ttm->state == tt_bound) {
ttm->func->unbind(ttm);
ttm->state = tt_unbound;
}
}
| 0
|
366,810
|
static int selinux_secmark_enabled(void)
{
return (atomic_read(&selinux_secmark_refcount) > 0);
}
| 0
|
401,640
|
static zend_always_inline int add_function_fast(zval *result, zval *op1, zval *op2) /* {{{ */
{
zend_uchar type_pair = TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2));
if (EXPECTED(type_pair == TYPE_PAIR(IS_LONG, IS_LONG))) {
fast_long_add_function(result, op1, op2);
return SUCCESS;
} else if (EXPECTED(type_pair == TYPE_PAIR(IS_DOUBLE, IS_DOUBLE))) {
ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
return SUCCESS;
} else if (EXPECTED(type_pair == TYPE_PAIR(IS_LONG, IS_DOUBLE))) {
ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));
return SUCCESS;
} else if (EXPECTED(type_pair == TYPE_PAIR(IS_DOUBLE, IS_LONG))) {
ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));
return SUCCESS;
} else if (EXPECTED(type_pair == TYPE_PAIR(IS_ARRAY, IS_ARRAY))) {
add_function_array(result, op1, op2);
return SUCCESS;
} else {
return FAILURE;
}
} /* }}} */
| 0
|
104,877
|
file_push_buffer(struct magic_set *ms)
{
file_pushbuf_t *pb;
if (ms->event_flags & EVENT_HAD_ERR)
return NULL;
if ((pb = (CAST(file_pushbuf_t *, malloc(sizeof(*pb))))) == NULL)
return NULL;
pb->buf = ms->o.buf;
pb->offset = ms->offset;
ms->o.buf = NULL;
ms->offset = 0;
return pb;
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.