project
stringclasses 788
values | commit_id
stringlengths 6
81
| CVE ID
stringlengths 13
16
| CWE ID
stringclasses 126
values | func
stringlengths 14
482k
| vul
int8 0
1
|
|---|---|---|---|---|---|
linux | 163ae1c6ad6299b19e22b4a35d5ab24a89791a98 | NOT_APPLICABLE | NOT_APPLICABLE | int fscrypt_inherit_context(struct inode *parent, struct inode *child,
void *fs_data, bool preload)
{
struct fscrypt_context ctx;
struct fscrypt_info *ci;
int res;
if (!parent->i_sb->s_cop->set_context)
return -EOPNOTSUPP;
res = fscrypt_get_encryption_info(parent);
if (res < 0)
return res;
ci = parent->i_crypt_info;
if (ci == NULL)
return -ENOKEY;
ctx.format = FS_ENCRYPTION_CONTEXT_FORMAT_V1;
if (fscrypt_dummy_context_enabled(parent)) {
ctx.contents_encryption_mode = FS_ENCRYPTION_MODE_AES_256_XTS;
ctx.filenames_encryption_mode = FS_ENCRYPTION_MODE_AES_256_CTS;
ctx.flags = 0;
memset(ctx.master_key_descriptor, 0x42, FS_KEY_DESCRIPTOR_SIZE);
res = 0;
} else {
ctx.contents_encryption_mode = ci->ci_data_mode;
ctx.filenames_encryption_mode = ci->ci_filename_mode;
ctx.flags = ci->ci_flags;
memcpy(ctx.master_key_descriptor, ci->ci_master_key,
FS_KEY_DESCRIPTOR_SIZE);
}
get_random_bytes(ctx.nonce, FS_KEY_DERIVATION_NONCE_SIZE);
res = parent->i_sb->s_cop->set_context(child, &ctx,
sizeof(ctx), fs_data);
if (res)
return res;
return preload ? fscrypt_get_encryption_info(child): 0;
}
| 0 |
zziplib | 596d9dfce2624e849417d4301e8d67935608aa5e | NOT_APPLICABLE | NOT_APPLICABLE | zzip_disk_munmap(ZZIP_DISK* disk)
{
if (! disk) return 0;
_zzip_munmap (disk->mapped, disk->buffer, disk->endbuf-disk->buffer);
free (disk);
return 0;
} | 0 |
nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | CVE-2012-2675 | CWE-189 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpcalloc(nedpool *p, size_t no, size_t size) THROWSPEC
{
unsigned flags=NEDMALLOC_FORCERESERVE(p, 0, no*size);
return nedpmalloc2(p, size*no, 0, M2_ZERO_MEMORY|flags);
}
| 1 |
linux-2.6 | c25b9abbc2c2c0da88e180c3933d6e773245815a | NOT_APPLICABLE | NOT_APPLICABLE | static void CheckSourceAddress(unsigned char *frame, unsigned char *hw_addr)
{
unsigned char SRBit;
if ((((unsigned long) frame[1 + 6]) & ~0x01) != 0) // source routing bit
return;
if ((unsigned short) frame[1 + 10] != 0)
return;
SRBit = frame[1 + 6] & 0x01;
memcpy(&frame[1 + 6], hw_addr, 6);
frame[8] |= SRBit;
} // CheckSourceAddress | 0 |
linux | 0a54917c3fc295cb61f3fb52373c173fd3b69f48 | NOT_APPLICABLE | NOT_APPLICABLE | static int orinoco_ioctl_getrate(struct net_device *dev,
struct iw_request_info *info,
struct iw_param *rrq,
char *extra)
{
struct orinoco_private *priv = ndev_priv(dev);
int err = 0;
int bitrate, automatic;
unsigned long flags;
if (orinoco_lock(priv, &flags) != 0)
return -EBUSY;
orinoco_get_ratemode_cfg(priv->bitratemode, &bitrate, &automatic);
/* If the interface is running we try to find more about the
current mode */
if (netif_running(dev)) {
int act_bitrate;
int lerr;
/* Ignore errors if we can't get the actual bitrate */
lerr = orinoco_hw_get_act_bitrate(priv, &act_bitrate);
if (!lerr)
bitrate = act_bitrate;
}
orinoco_unlock(priv, &flags);
rrq->value = bitrate;
rrq->fixed = !automatic;
rrq->disabled = 0;
return err;
}
| 0 |
file-roller | b147281293a8307808475e102a14857055f81631 | NOT_APPLICABLE | NOT_APPLICABLE | get_icon (FrWindow *window,
FileData *fdata)
{
GIcon *icon = NULL;
GdkPixbuf *pixbuf = NULL;
if (fdata->link != NULL)
icon = g_themed_icon_new ("emblem-symbolic-link");
else {
const char *content_type;
if (file_data_is_dir (fdata))
content_type = MIME_TYPE_DIRECTORY;
else
content_type = fdata->content_type;
icon = g_content_type_get_icon (content_type);
}
pixbuf = gth_icon_cache_get_pixbuf (window->priv->list_icon_cache, icon);
g_object_unref (icon);
return pixbuf;
} | 0 |
unbound | 6c3a0b54ed8ace93d5b5ca7b8078dc87e75cd640 | NOT_APPLICABLE | NOT_APPLICABLE | repinfo_copy_rrsets(struct reply_info* dest, struct reply_info* from,
struct regional* region)
{
size_t i, s;
struct packed_rrset_data* fd, *dd;
struct ub_packed_rrset_key* fk, *dk;
for(i=0; i<dest->rrset_count; i++) {
fk = from->rrsets[i];
dk = dest->rrsets[i];
fd = (struct packed_rrset_data*)fk->entry.data;
dk->entry.hash = fk->entry.hash;
dk->rk = fk->rk;
if(region) {
dk->id = fk->id;
dk->rk.dname = (uint8_t*)regional_alloc_init(region,
fk->rk.dname, fk->rk.dname_len);
} else
dk->rk.dname = (uint8_t*)memdup(fk->rk.dname,
fk->rk.dname_len);
if(!dk->rk.dname)
return 0;
s = packed_rrset_sizeof(fd);
if(region)
dd = (struct packed_rrset_data*)regional_alloc_init(
region, fd, s);
else dd = (struct packed_rrset_data*)memdup(fd, s);
if(!dd)
return 0;
packed_rrset_ptr_fixup(dd);
dk->entry.data = (void*)dd;
}
return 1;
} | 0 |
tensorflow | 8b5b9dc96666a3a5d27fad7179ff215e3b74b67c | NOT_APPLICABLE | NOT_APPLICABLE | static std::vector<std::string> AllDirectoryPrefixes(const std::string& d) {
std::vector<std::string> dirs;
const std::string patched = PatchPattern(d);
StringPiece dir(patched);
// If the pattern ends with a `/` (or `\\` on Windows), we need to strip it
// otherwise we would have one additional matching step and the result set
// would be empty.
bool is_directory = d[d.size() - 1] == '/';
#ifdef PLATFORM_WINDOWS
is_directory = is_directory || (d[d.size() - 1] == '\\');
#endif
if (is_directory) {
dir = io::Dirname(dir);
}
while (!dir.empty()) {
dirs.emplace_back(dir);
StringPiece new_dir(io::Dirname(dir));
// io::Dirname("/") returns "/" so we need to break the loop.
// On Windows, io::Dirname("C:\\") would return "C:\\", so we check for
// identity of the result instead of checking for dir[0] == `/`.
if (dir == new_dir) break;
dir = new_dir;
}
// Order the array from parent to ancestor (reverse order).
std::reverse(dirs.begin(), dirs.end());
return dirs;
} | 0 |
jasper | dee11ec440d7908d1daf69f40a3324b27cf213ba | NOT_APPLICABLE | NOT_APPLICABLE | int jas_image_writecmpt(jas_image_t *image, int cmptno, jas_image_coord_t x, jas_image_coord_t y, jas_image_coord_t width,
jas_image_coord_t height, jas_matrix_t *data)
{
jas_image_cmpt_t *cmpt;
jas_image_coord_t i;
jas_image_coord_t j;
jas_seqent_t *d;
jas_seqent_t *dr;
int drs;
jas_seqent_t v;
int k;
int c;
if (cmptno < 0 || cmptno >= image->numcmpts_) {
return -1;
}
cmpt = image->cmpts_[cmptno];
if (x >= cmpt->width_ || y >= cmpt->height_ ||
x + width > cmpt->width_ ||
y + height > cmpt->height_) {
return -1;
}
if (!jas_matrix_numrows(data) || !jas_matrix_numcols(data)) {
return -1;
}
if (jas_matrix_numrows(data) != height || jas_matrix_numcols(data) != width) {
return -1;
}
dr = jas_matrix_getref(data, 0, 0);
drs = jas_matrix_rowstep(data);
for (i = 0; i < height; ++i, dr += drs) {
d = dr;
if (jas_stream_seek(cmpt->stream_, (cmpt->width_ * (y + i) + x)
* cmpt->cps_, SEEK_SET) < 0) {
return -1;
}
for (j = width; j > 0; --j, ++d) {
v = inttobits(*d, cmpt->prec_, cmpt->sgnd_);
for (k = cmpt->cps_; k > 0; --k) {
c = (v >> (8 * (cmpt->cps_ - 1))) & 0xff;
if (jas_stream_putc(cmpt->stream_,
(unsigned char) c) == EOF) {
return -1;
}
v <<= 8;
}
}
}
return 0;
}
| 0 |
Chrome | a79e1bbb765af34d446e42d34cd00a312b381113 | NOT_APPLICABLE | NOT_APPLICABLE | void UiSceneCreator::CreateAudioPermissionPrompt() {
std::unique_ptr<UiElement> element;
auto backplane = base::MakeUnique<InvisibleHitTarget>();
backplane->SetDrawPhase(kPhaseForeground);
backplane->SetName(kAudioPermissionPromptBackplane);
backplane->SetSize(kPromptBackplaneSize, kPromptBackplaneSize);
backplane->SetTranslate(0.0, kContentVerticalOffset, -kOverlayPlaneDistance);
EventHandlers event_handlers;
event_handlers.button_up = base::Bind(
[](UiBrowserInterface* browser, Model* m) {
browser->OnExitVrPromptResult(
ExitVrPromptChoice::CHOICE_NONE,
GetReasonForPrompt(m->active_modal_prompt_type));
},
base::Unretained(browser_), base::Unretained(model_));
backplane->set_event_handlers(event_handlers);
backplane->SetVisible(false);
backplane->SetTransitionedProperties({OPACITY});
backplane->AddBinding(VR_BIND_FUNC(
bool, Model, model_,
active_modal_prompt_type ==
kModalPromptTypeExitVRForVoiceSearchRecordAudioOsPermission,
UiElement, backplane.get(), SetVisible));
std::unique_ptr<Shadow> shadow = base::MakeUnique<Shadow>();
shadow->SetName(kAudioPermissionPromptShadow);
shadow->SetDrawPhase(kPhaseForeground);
std::unique_ptr<AudioPermissionPrompt> prompt =
base::MakeUnique<AudioPermissionPrompt>(
1024,
base::Bind(
&UiBrowserInterface::OnExitVrPromptResult,
base::Unretained(browser_), ExitVrPromptChoice::CHOICE_EXIT,
UiUnsupportedMode::kVoiceSearchNeedsRecordAudioOsPermission),
base::Bind(
&UiBrowserInterface::OnExitVrPromptResult,
base::Unretained(browser_), ExitVrPromptChoice::CHOICE_STAY,
UiUnsupportedMode::kVoiceSearchNeedsRecordAudioOsPermission));
prompt->SetName(kAudioPermissionPrompt);
prompt->SetDrawPhase(kPhaseForeground);
prompt->SetSize(kAudioPermissionPromptWidth, kAudioPermissionPromptHeight);
prompt->SetTranslate(0.0, 0.0f, kAudionPermisionPromptDepth);
BindButtonColors(model_, prompt.get(),
&ColorScheme::audio_permission_prompt_primary_button_colors,
&AudioPermissionPrompt::SetPrimaryButtonColors);
BindButtonColors(
model_, prompt.get(),
&ColorScheme::audio_permission_prompt_secondary_button_colors,
&AudioPermissionPrompt::SetSecondaryButtonColors);
BindColor(model_, prompt.get(),
&ColorScheme::audio_permission_prompt_icon_foreground,
&AudioPermissionPrompt::SetIconColor);
BindColor(model_, prompt.get(),
&ColorScheme::audio_permission_prompt_background,
&TexturedElement::SetBackgroundColor);
BindColor(model_, prompt.get(), &ColorScheme::element_foreground,
&TexturedElement::SetForegroundColor);
shadow->AddChild(std::move(prompt));
backplane->AddChild(std::move(shadow));
scene_->AddUiElement(k2dBrowsingRoot, std::move(backplane));
}
| 0 |
jasper | 1f0dfe5a42911b6880a1445f13f6d615ddb55387 | NOT_APPLICABLE | NOT_APPLICABLE | void jpc_pchglist_destroy(jpc_pchglist_t *pchglist)
{
int pchgno;
if (pchglist->pchgs) {
for (pchgno = 0; pchgno < pchglist->numpchgs; ++pchgno) {
jpc_pchg_destroy(pchglist->pchgs[pchgno]);
}
jas_free(pchglist->pchgs);
}
jas_free(pchglist);
}
| 0 |
Chrome | 2649de11c562aa96d336c06136a1a20c01711be0 | NOT_APPLICABLE | NOT_APPLICABLE | void ExtensionsAPIClient::AddAdditionalValueStoreCaches(
content::BrowserContext* context,
const scoped_refptr<ValueStoreFactory>& factory,
const scoped_refptr<base::ObserverListThreadSafe<SettingsObserver>>&
observers,
std::map<settings_namespace::Namespace, ValueStoreCache*>* caches) {}
| 0 |
Chrome | eb4d5d9ab41449b79fcf6f84d8983be2b12bd490 | NOT_APPLICABLE | NOT_APPLICABLE | bool ContainerNode::getUpperLeftCorner(FloatPoint& point) const
{
if (!layoutObject())
return false;
LayoutObject* o = layoutObject();
if (!o->isInline() || o->isReplaced()) {
point = o->localToAbsolute(FloatPoint(), UseTransforms);
return true;
}
while (o) {
LayoutObject* p = o;
if (LayoutObject* oFirstChild = o->slowFirstChild()) {
o = oFirstChild;
} else if (o->nextSibling()) {
o = o->nextSibling();
} else {
LayoutObject* next = nullptr;
while (!next && o->parent()) {
o = o->parent();
next = o->nextSibling();
}
o = next;
if (!o)
break;
}
ASSERT(o);
if (!o->isInline() || o->isReplaced()) {
point = o->localToAbsolute(FloatPoint(), UseTransforms);
return true;
}
if (p->node() && p->node() == this && o->isText() && !o->isBR() && !toLayoutText(o)->hasTextBoxes()) {
} else if ((o->isText() && !o->isBR()) || o->isReplaced()) {
point = FloatPoint();
if (o->isText() && toLayoutText(o)->firstTextBox()) {
point.move(toLayoutText(o)->linesBoundingBox().x(), toLayoutText(o)->firstTextBox()->root().lineTop().toFloat());
point = o->localToAbsolute(point, UseTransforms);
} else if (o->isBox()) {
LayoutBox* box = toLayoutBox(o);
point.moveBy(box->location());
point = o->container()->localToAbsolute(point, UseTransforms);
}
return true;
}
}
if (!o && document().view()) {
point = FloatPoint(0, document().view()->contentsHeight());
return true;
}
return false;
}
| 0 |
Chrome | 3aad1a37affb1ab70d1897f2b03eb8c077264984 | NOT_APPLICABLE | NOT_APPLICABLE | bool GLES2DecoderImpl::DoIsFramebuffer(GLuint client_id) {
const FramebufferManager::FramebufferInfo* framebuffer =
GetFramebufferInfo(client_id);
return framebuffer && framebuffer->IsValid() && !framebuffer->IsDeleted();
}
| 0 |
linux | afca6c5b2595fc44383919fba740c194b0b76aff | NOT_APPLICABLE | NOT_APPLICABLE | xfs_inode_free_callback(
struct rcu_head *head)
{
struct inode *inode = container_of(head, struct inode, i_rcu);
struct xfs_inode *ip = XFS_I(inode);
switch (VFS_I(ip)->i_mode & S_IFMT) {
case S_IFREG:
case S_IFDIR:
case S_IFLNK:
xfs_idestroy_fork(ip, XFS_DATA_FORK);
break;
}
if (ip->i_afp)
xfs_idestroy_fork(ip, XFS_ATTR_FORK);
if (ip->i_cowfp)
xfs_idestroy_fork(ip, XFS_COW_FORK);
if (ip->i_itemp) {
ASSERT(!(ip->i_itemp->ili_item.li_flags & XFS_LI_IN_AIL));
xfs_inode_item_destroy(ip);
ip->i_itemp = NULL;
}
kmem_zone_free(xfs_inode_zone, ip);
}
| 0 |
jdk11u | 6c0ba0785a2f0900be301f72764cf4dcfa720991 | NOT_APPLICABLE | NOT_APPLICABLE | void ciEnv::validate_compile_task_dependencies(ciMethod* target) {
if (failing()) return; // no need for further checks
Dependencies::DepType result = dependencies()->validate_dependencies(_task);
if (result != Dependencies::end_marker) {
if (result == Dependencies::call_site_target_value) {
_inc_decompile_count_on_failure = false;
record_failure("call site target change");
} else if (Dependencies::is_klass_type(result)) {
record_failure("concurrent class loading");
} else {
record_failure("invalid non-klass dependency");
}
}
} | 0 |
Chrome | 59296d9276ffcc8bced092828210748d2ed19ab0 | NOT_APPLICABLE | NOT_APPLICABLE | int32_t PepperFlashRendererHost::OnGetProxyForURL(
ppapi::host::HostMessageContext* host_context,
const std::string& url) {
GURL gurl(url);
if (!gurl.is_valid())
return PP_ERROR_FAILED;
std::string proxy;
bool result = content::RenderThread::Get()->ResolveProxy(gurl, &proxy);
if (!result)
return PP_ERROR_FAILED;
host_context->reply_msg = PpapiPluginMsg_Flash_GetProxyForURLReply(proxy);
return PP_OK;
}
| 0 |
linux | ee8f844e3c5a73b999edf733df1c529d6503ec2f | NOT_APPLICABLE | NOT_APPLICABLE | long keyctl_read_key(key_serial_t keyid, char __user *buffer, size_t buflen)
{
struct key *key;
key_ref_t key_ref;
long ret;
/* find the key first */
key_ref = lookup_user_key(keyid, 0, 0);
if (IS_ERR(key_ref)) {
ret = -ENOKEY;
goto error;
}
key = key_ref_to_ptr(key_ref);
/* see if we can read it directly */
ret = key_permission(key_ref, KEY_NEED_READ);
if (ret == 0)
goto can_read_key;
if (ret != -EACCES)
goto error;
/* we can't; see if it's searchable from this process's keyrings
* - we automatically take account of the fact that it may be
* dangling off an instantiation key
*/
if (!is_key_possessed(key_ref)) {
ret = -EACCES;
goto error2;
}
/* the key is probably readable - now try to read it */
can_read_key:
ret = -EOPNOTSUPP;
if (key->type->read) {
/* Read the data with the semaphore held (since we might sleep)
* to protect against the key being updated or revoked.
*/
down_read(&key->sem);
ret = key_validate(key);
if (ret == 0)
ret = key->type->read(key, buffer, buflen);
up_read(&key->sem);
}
error2:
key_put(key);
error:
return ret;
} | 0 |
linux | 85dfb745ee40232876663ae206cba35f24ab2a40 | NOT_APPLICABLE | NOT_APPLICABLE | static void __net_exit pfkey_exit_proc(struct net *net)
{
remove_proc_entry("pfkey", net->proc_net);
}
| 0 |
php-src | 64f42c73efc58e88671ad76b6b6bc8e2b62713e1 | NOT_APPLICABLE | NOT_APPLICABLE | mbfl_buffer_converter_result(mbfl_buffer_converter *convd, mbfl_string *result)
{
if (convd == NULL || result == NULL) {
return NULL;
}
result->no_encoding = convd->to->no_encoding;
return mbfl_memory_device_result(&convd->device, result);
} | 0 |
ImageMagick | 406da3af9e09649cda152663c179902edf5ab3ac | NOT_APPLICABLE | NOT_APPLICABLE | MagickExport MagickBooleanType ExportImagePixels(const Image *image,
const ssize_t x,const ssize_t y,const size_t width,const size_t height,
const char *map,const StorageType type,void *pixels,ExceptionInfo *exception)
{
MagickBooleanType
status;
QuantumType
*quantum_map;
RectangleInfo
roi;
register ssize_t
i;
size_t
length;
assert(image != (Image *) NULL);
assert(image->signature == MagickCoreSignature);
if (image->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
length=strlen(map);
quantum_map=(QuantumType *) AcquireQuantumMemory(length,sizeof(*quantum_map));
if (quantum_map == (QuantumType *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
return(MagickFalse);
}
for (i=0; i < (ssize_t) length; i++)
{
switch (map[i])
{
case 'A':
case 'a':
{
quantum_map[i]=AlphaQuantum;
break;
}
case 'B':
case 'b':
{
quantum_map[i]=BlueQuantum;
break;
}
case 'C':
case 'c':
{
quantum_map[i]=CyanQuantum;
if (image->colorspace == CMYKColorspace)
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColorSeparatedImageRequired","`%s'",map);
return(MagickFalse);
}
case 'g':
case 'G':
{
quantum_map[i]=GreenQuantum;
break;
}
case 'I':
case 'i':
{
quantum_map[i]=IndexQuantum;
break;
}
case 'K':
case 'k':
{
quantum_map[i]=BlackQuantum;
if (image->colorspace == CMYKColorspace)
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColorSeparatedImageRequired","`%s'",map);
return(MagickFalse);
}
case 'M':
case 'm':
{
quantum_map[i]=MagentaQuantum;
if (image->colorspace == CMYKColorspace)
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColorSeparatedImageRequired","`%s'",map);
return(MagickFalse);
}
case 'o':
case 'O':
{
quantum_map[i]=OpacityQuantum;
break;
}
case 'P':
case 'p':
{
quantum_map[i]=UndefinedQuantum;
break;
}
case 'R':
case 'r':
{
quantum_map[i]=RedQuantum;
break;
}
case 'Y':
case 'y':
{
quantum_map[i]=YellowQuantum;
if (image->colorspace == CMYKColorspace)
break;
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),ImageError,
"ColorSeparatedImageRequired","`%s'",map);
return(MagickFalse);
}
default:
{
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"UnrecognizedPixelMap","`%s'",map);
return(MagickFalse);
}
}
}
roi.width=width;
roi.height=height;
roi.x=x;
roi.y=y;
switch (type)
{
case CharPixel:
{
status=ExportCharPixel(image,&roi,map,quantum_map,pixels,exception);
break;
}
case DoublePixel:
{
status=ExportDoublePixel(image,&roi,map,quantum_map,pixels,exception);
break;
}
case FloatPixel:
{
status=ExportFloatPixel(image,&roi,map,quantum_map,pixels,exception);
break;
}
case LongPixel:
{
status=ExportLongPixel(image,&roi,map,quantum_map,pixels,exception);
break;
}
case LongLongPixel:
{
status=ExportLongLongPixel(image,&roi,map,quantum_map,pixels,exception);
break;
}
case QuantumPixel:
{
status=ExportQuantumPixel(image,&roi,map,quantum_map,pixels,exception);
break;
}
case ShortPixel:
{
status=ExportShortPixel(image,&roi,map,quantum_map,pixels,exception);
break;
}
default:
{
(void) ThrowMagickException(exception,GetMagickModule(),OptionError,
"UnrecognizedPixelMap","`%s'",map);
status=MagickFalse;
}
}
quantum_map=(QuantumType *) RelinquishMagickMemory(quantum_map);
return(status);
} | 0 |
qemu | e2c57529c9306e4c9aac75d9879f6e7699584a22 | NOT_APPLICABLE | NOT_APPLICABLE | static uint16_t nvme_flush(NvmeCtrl *n, NvmeRequest *req)
{
NvmeFlushAIOCB *iocb;
uint32_t nsid = le32_to_cpu(req->cmd.nsid);
uint16_t status;
iocb = qemu_aio_get(&nvme_flush_aiocb_info, NULL, nvme_misc_cb, req);
iocb->req = req;
iocb->bh = qemu_bh_new(nvme_flush_bh, iocb);
iocb->ret = 0;
iocb->ns = NULL;
iocb->nsid = 0;
iocb->broadcast = (nsid == NVME_NSID_BROADCAST);
if (!iocb->broadcast) {
if (!nvme_nsid_valid(n, nsid)) {
status = NVME_INVALID_NSID | NVME_DNR;
goto out;
}
iocb->ns = nvme_ns(n, nsid);
if (!iocb->ns) {
status = NVME_INVALID_FIELD | NVME_DNR;
goto out;
}
iocb->nsid = nsid;
}
req->aiocb = &iocb->common;
qemu_bh_schedule(iocb->bh);
return NVME_NO_COMPLETE;
out:
qemu_bh_delete(iocb->bh);
iocb->bh = NULL;
qemu_aio_unref(iocb);
return status;
} | 0 |
linux | 4a491b1ab11ca0556d2fda1ff1301e862a2d44c4 | NOT_APPLICABLE | NOT_APPLICABLE | static int sas_check_eeds(struct domain_device *child,
struct ex_phy *parent_phy,
struct ex_phy *child_phy)
{
int res = 0;
struct domain_device *parent = child->parent;
if (SAS_ADDR(parent->port->disc.fanout_sas_addr) != 0) {
res = -ENODEV;
SAS_DPRINTK("edge ex %016llx phy S:0x%x <--> edge ex %016llx "
"phy S:0x%x, while there is a fanout ex %016llx\n",
SAS_ADDR(parent->sas_addr),
parent_phy->phy_id,
SAS_ADDR(child->sas_addr),
child_phy->phy_id,
SAS_ADDR(parent->port->disc.fanout_sas_addr));
} else if (SAS_ADDR(parent->port->disc.eeds_a) == 0) {
memcpy(parent->port->disc.eeds_a, parent->sas_addr,
SAS_ADDR_SIZE);
memcpy(parent->port->disc.eeds_b, child->sas_addr,
SAS_ADDR_SIZE);
} else if (((SAS_ADDR(parent->port->disc.eeds_a) ==
SAS_ADDR(parent->sas_addr)) ||
(SAS_ADDR(parent->port->disc.eeds_a) ==
SAS_ADDR(child->sas_addr)))
&&
((SAS_ADDR(parent->port->disc.eeds_b) ==
SAS_ADDR(parent->sas_addr)) ||
(SAS_ADDR(parent->port->disc.eeds_b) ==
SAS_ADDR(child->sas_addr))))
;
else {
res = -ENODEV;
SAS_DPRINTK("edge ex %016llx phy 0x%x <--> edge ex %016llx "
"phy 0x%x link forms a third EEDS!\n",
SAS_ADDR(parent->sas_addr),
parent_phy->phy_id,
SAS_ADDR(child->sas_addr),
child_phy->phy_id);
}
return res;
}
| 0 |
php-src | c395c6e5d7e8df37a21265ff76e48fe75ceb5ae6?w=1 | NOT_APPLICABLE | NOT_APPLICABLE | static void gdImageBrushApply (gdImagePtr im, int x, int y)
{
int lx, ly;
int hy, hx;
int x1, y1, x2, y2;
int srcx, srcy;
if (!im->brush) {
return;
}
hy = gdImageSY(im->brush) / 2;
y1 = y - hy;
y2 = y1 + gdImageSY(im->brush);
hx = gdImageSX(im->brush) / 2;
x1 = x - hx;
x2 = x1 + gdImageSX(im->brush);
srcy = 0;
if (im->trueColor) {
if (im->brush->trueColor) {
for (ly = y1; ly < y2; ly++) {
srcx = 0;
for (lx = x1; (lx < x2); lx++) {
int p;
p = gdImageGetTrueColorPixel(im->brush, srcx, srcy);
/* 2.0.9, Thomas Winzig: apply simple full transparency */
if (p != gdImageGetTransparent(im->brush)) {
gdImageSetPixel(im, lx, ly, p);
}
srcx++;
}
srcy++;
}
} else {
/* 2.0.12: Brush palette, image truecolor (thanks to Thorben Kundinger for pointing out the issue) */
for (ly = y1; ly < y2; ly++) {
srcx = 0;
for (lx = x1; lx < x2; lx++) {
int p, tc;
p = gdImageGetPixel(im->brush, srcx, srcy);
tc = gdImageGetTrueColorPixel(im->brush, srcx, srcy);
/* 2.0.9, Thomas Winzig: apply simple full transparency */
if (p != gdImageGetTransparent(im->brush)) {
gdImageSetPixel(im, lx, ly, tc);
}
srcx++;
}
srcy++;
}
}
} else {
for (ly = y1; ly < y2; ly++) {
srcx = 0;
for (lx = x1; lx < x2; lx++) {
int p;
p = gdImageGetPixel(im->brush, srcx, srcy);
/* Allow for non-square brushes! */
if (p != gdImageGetTransparent(im->brush)) {
/* Truecolor brush. Very slow on a palette destination. */
if (im->brush->trueColor) {
gdImageSetPixel(im, lx, ly, gdImageColorResolveAlpha(im, gdTrueColorGetRed(p),
gdTrueColorGetGreen(p),
gdTrueColorGetBlue(p),
gdTrueColorGetAlpha(p)));
} else {
gdImageSetPixel(im, lx, ly, im->brushColorMap[p]);
}
}
srcx++;
}
srcy++;
}
}
}
| 0 |
Chrome | 5576cbc1d3e214dfbb5d3ffcdbe82aa8ba0088fc | NOT_APPLICABLE | NOT_APPLICABLE | MidiResult GetInitializationResult() {
return client_->result_;
}
| 0 |
Chrome | f283cdf7c850f3db923a5303c7e01bd929d4117f | NOT_APPLICABLE | NOT_APPLICABLE | static bool IsVaapiSupportedJpeg(const JpegParseResult& jpeg) {
if (!VaapiWrapper::IsJpegDecodingSupportedForInternalFormat(
VaSurfaceFormatForJpeg(jpeg.frame_header))) {
DLOG(ERROR) << "The JPEG's subsampling format is unsupported";
return false;
}
if (jpeg.frame_header.visible_width == 0u) {
DLOG(ERROR) << "Visible width can't be zero";
return false;
}
if (jpeg.frame_header.visible_height == 0u) {
DLOG(ERROR) << "Visible height can't be zero";
return false;
}
gfx::Size min_jpeg_resolution;
if (!VaapiWrapper::GetJpegDecodeMinResolution(&min_jpeg_resolution)) {
DLOG(ERROR) << "Could not get the minimum resolution";
return false;
}
gfx::Size max_jpeg_resolution;
if (!VaapiWrapper::GetJpegDecodeMaxResolution(&max_jpeg_resolution)) {
DLOG(ERROR) << "Could not get the maximum resolution";
return false;
}
const int actual_jpeg_coded_width =
base::strict_cast<int>(jpeg.frame_header.coded_width);
const int actual_jpeg_coded_height =
base::strict_cast<int>(jpeg.frame_header.coded_height);
if (actual_jpeg_coded_width < min_jpeg_resolution.width() ||
actual_jpeg_coded_height < min_jpeg_resolution.height() ||
actual_jpeg_coded_width > max_jpeg_resolution.width() ||
actual_jpeg_coded_height > max_jpeg_resolution.height()) {
DLOG(ERROR) << "VAAPI doesn't support size " << actual_jpeg_coded_width
<< "x" << actual_jpeg_coded_height << ": not in range "
<< min_jpeg_resolution.ToString() << " - "
<< max_jpeg_resolution.ToString();
return false;
}
return true;
}
| 0 |
samba | 0454b95657846fcecf0f51b6f1194faac02518bd | NOT_APPLICABLE | NOT_APPLICABLE | bool ldb_dn_is_special(struct ldb_dn *dn)
{
if ( ! dn || dn->invalid) return false;
return dn->special;
}
| 0 |
bpf | c4eb1f403243fc7bbb7de644db8587c03de36da6 | NOT_APPLICABLE | NOT_APPLICABLE | static void free_htab_elem(struct bpf_htab *htab, struct htab_elem *l)
{
htab_put_fd_value(htab, l);
if (htab_is_prealloc(htab)) {
__pcpu_freelist_push(&htab->freelist, &l->fnode);
} else {
atomic_dec(&htab->count);
l->htab = htab;
call_rcu(&l->rcu, htab_elem_free_rcu);
}
} | 0 |
libxml2 | 92b9e8c8b3787068565a1820ba575d042f9eec66 | NOT_APPLICABLE | NOT_APPLICABLE | xmlSnprintfElementContent(char *buf, int size, xmlElementContentPtr content, int englob) {
int len;
if (content == NULL) return;
len = strlen(buf);
if (size - len < 50) {
if ((size - len > 4) && (buf[len - 1] != '.'))
strcat(buf, " ...");
return;
}
if (englob) strcat(buf, "(");
switch (content->type) {
case XML_ELEMENT_CONTENT_PCDATA:
strcat(buf, "#PCDATA");
break;
case XML_ELEMENT_CONTENT_ELEMENT: {
int qnameLen = xmlStrlen(content->name);
if (content->prefix != NULL)
qnameLen += xmlStrlen(content->prefix) + 1;
if (size - len < qnameLen + 10) {
strcat(buf, " ...");
return;
}
if (content->prefix != NULL) {
strcat(buf, (char *) content->prefix);
strcat(buf, ":");
}
if (content->name != NULL)
strcat(buf, (char *) content->name);
break;
}
case XML_ELEMENT_CONTENT_SEQ:
if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
(content->c1->type == XML_ELEMENT_CONTENT_SEQ))
xmlSnprintfElementContent(buf, size, content->c1, 1);
else
xmlSnprintfElementContent(buf, size, content->c1, 0);
len = strlen(buf);
if (size - len < 50) {
if ((size - len > 4) && (buf[len - 1] != '.'))
strcat(buf, " ...");
return;
}
strcat(buf, " , ");
if (((content->c2->type == XML_ELEMENT_CONTENT_OR) ||
(content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
(content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
xmlSnprintfElementContent(buf, size, content->c2, 1);
else
xmlSnprintfElementContent(buf, size, content->c2, 0);
break;
case XML_ELEMENT_CONTENT_OR:
if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
(content->c1->type == XML_ELEMENT_CONTENT_SEQ))
xmlSnprintfElementContent(buf, size, content->c1, 1);
else
xmlSnprintfElementContent(buf, size, content->c1, 0);
len = strlen(buf);
if (size - len < 50) {
if ((size - len > 4) && (buf[len - 1] != '.'))
strcat(buf, " ...");
return;
}
strcat(buf, " | ");
if (((content->c2->type == XML_ELEMENT_CONTENT_SEQ) ||
(content->c2->ocur != XML_ELEMENT_CONTENT_ONCE)) &&
(content->c2->type != XML_ELEMENT_CONTENT_ELEMENT))
xmlSnprintfElementContent(buf, size, content->c2, 1);
else
xmlSnprintfElementContent(buf, size, content->c2, 0);
break;
}
if (size - strlen(buf) <= 2) return;
if (englob)
strcat(buf, ")");
switch (content->ocur) {
case XML_ELEMENT_CONTENT_ONCE:
break;
case XML_ELEMENT_CONTENT_OPT:
strcat(buf, "?");
break;
case XML_ELEMENT_CONTENT_MULT:
strcat(buf, "*");
break;
case XML_ELEMENT_CONTENT_PLUS:
strcat(buf, "+");
break;
}
} | 0 |
cyrus-sasl | 9eff746c9daecbcc0041b09a5a51ba30738cdcbc | NOT_APPLICABLE | NOT_APPLICABLE | static int _sqlite3_escape_str(char *to, const char *from)
{
char s;
while ( (s = *from++) != '\0' ) {
if (s == '\'' || s == '\\') {
*to++ = '\\';
}
*to++ = s;
}
*to = '\0';
return 0;
} | 0 |
linux | 4efbc454ba68def5ef285b26ebfcfdb605b52755 | NOT_APPLICABLE | NOT_APPLICABLE | void scheduler_tick(void)
{
int cpu = smp_processor_id();
struct rq *rq = cpu_rq(cpu);
struct task_struct *curr = rq->curr;
sched_clock_tick();
raw_spin_lock(&rq->lock);
update_rq_clock(rq);
curr->sched_class->task_tick(rq, curr, 0);
update_cpu_load_active(rq);
raw_spin_unlock(&rq->lock);
perf_event_task_tick();
#ifdef CONFIG_SMP
rq->idle_balance = idle_cpu(cpu);
trigger_load_balance(rq);
#endif
rq_last_tick_reset(rq);
}
| 0 |
Chrome | 7614790c80996d32a28218f4d1605b0908e9ddf6 | NOT_APPLICABLE | NOT_APPLICABLE | void DOMMessageQueue::Observe(int type,
const NotificationSource& source,
const NotificationDetails& details) {
Details<std::string> dom_op_result(details);
message_queue_.push(*dom_op_result.ptr());
if (message_loop_runner_)
message_loop_runner_->Quit();
}
| 0 |
bluez | 8cdbd3b09f29da29374e2f83369df24228da0ad1 | NOT_APPLICABLE | NOT_APPLICABLE | static int hog_probe(struct btd_service *service)
{
struct btd_device *device = btd_service_get_device(service);
const char *path = device_get_path(device);
struct hog_device *dev;
DBG("path %s", path);
dev = hog_device_new(device);
if (!dev)
return -EINVAL;
btd_service_set_user_data(service, dev);
return 0;
} | 0 |
gdk-pixbuf | 0012e066ba37439d402ce46afbc1311530a4ec61 | NOT_APPLICABLE | NOT_APPLICABLE | gif_init (GifContext *context)
{
unsigned char buf[16];
char version[4];
if (!gif_read (context, buf, 6)) {
/* Unable to read magic number,
* gif_read() should have set error
*/
return -1;
}
if (strncmp ((char *) buf, "GIF", 3) != 0) {
/* Not a GIF file */
g_set_error_literal (context->error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
_("File does not appear to be a GIF file"));
return -2;
}
strncpy (version, (char *) buf + 3, 3);
version[3] = '\0';
if ((strcmp (version, "87a") != 0) && (strcmp (version, "89a") != 0)) {
/* bad version number, not '87a' or '89a' */
g_set_error (context->error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
_("Version %s of the GIF file format is not supported"),
version);
return -2;
}
/* read the screen descriptor */
if (!gif_read (context, buf, 7)) {
/* Failed to read screen descriptor, error set */
return -1;
}
context->width = LM_to_uint (buf[0], buf[1]);
context->height = LM_to_uint (buf[2], buf[3]);
/* The 4th byte is
* high bit: whether to use the background index
* next 3: color resolution
* next: whether colormap is sorted by priority of allocation
* last 3: size of colormap
*/
context->global_bit_pixel = 2 << (buf[4] & 0x07);
context->global_color_resolution = (((buf[4] & 0x70) >> 3) + 1);
context->has_global_cmap = (buf[4] & 0x80) != 0;
context->background_index = buf[5];
context->aspect_ratio = buf[6];
/* Use background of transparent black as default, though if
* one isn't set explicitly no one should ever use it.
*/
context->animation->bg_red = 0;
context->animation->bg_green = 0;
context->animation->bg_blue = 0;
context->animation->width = context->width;
context->animation->height = context->height;
if (context->size_func) {
gint width, height;
width = context->width;
height = context->height;
(*context->size_func) (&width, &height, context->user_data);
if (width == 0 || height == 0) {
g_set_error_literal (context->error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
_("Resulting GIF image has zero size"));
return -2;
}
}
if (context->has_global_cmap) {
gif_set_get_colormap (context);
} else {
context->state = GIF_GET_NEXT_STEP;
}
#ifdef DUMP_IMAGE_DETAILS
g_print (">Image width: %d height: %d global_cmap: %d background: %d\n",
context->width, context->height, context->has_global_cmap, context->background_index);
#endif
return 0;
} | 0 |
vim | 249e1b903a9c0460d618f6dcc59aeb8c03b24b20 | NOT_APPLICABLE | NOT_APPLICABLE | test_gui_tabmenu_event(dict_T *args UNUSED)
{
# ifdef FEAT_GUI_TABLINE
int tabnr;
int item;
if (!dict_has_key(args, "tabnr")
|| !dict_has_key(args, "item"))
return FALSE;
tabnr = (int)dict_get_number(args, "tabnr");
item = (int)dict_get_number(args, "item");
send_tabline_menu_event(tabnr, item);
# endif
return TRUE;
} | 0 |
linux | f856567b930dfcdbc3323261bf77240ccdde01f5 | NOT_APPLICABLE | NOT_APPLICABLE | ssize_t aac_get_serial_number(struct device *device, char *buf)
{
return aac_show_serial_number(device, &aac_serial_number, buf);
}
| 0 |
php-src | 35ceea928b12373a3b1e3eecdc32ed323223a40d | CVE-2014-0185 | CWE-264 | int fpm_unix_resolve_socket_premissions(struct fpm_worker_pool_s *wp) /* {{{ */
{
struct fpm_worker_pool_config_s *c = wp->config;
/* uninitialized */
wp->socket_uid = -1;
wp->socket_gid = -1;
wp->socket_mode = 0666;
if (!c) {
return 0;
}
if (c->listen_owner && *c->listen_owner) {
struct passwd *pwd;
pwd = getpwnam(c->listen_owner);
if (!pwd) {
zlog(ZLOG_SYSERROR, "[pool %s] cannot get uid for user '%s'", wp->config->name, c->listen_owner);
return -1;
}
wp->socket_uid = pwd->pw_uid;
wp->socket_gid = pwd->pw_gid;
}
if (c->listen_group && *c->listen_group) {
struct group *grp;
grp = getgrnam(c->listen_group);
if (!grp) {
zlog(ZLOG_SYSERROR, "[pool %s] cannot get gid for group '%s'", wp->config->name, c->listen_group);
return -1;
}
wp->socket_gid = grp->gr_gid;
}
if (c->listen_mode && *c->listen_mode) {
wp->socket_mode = strtoul(c->listen_mode, 0, 8);
}
return 0;
} | 1 |
Android | a30d7d90c4f718e46fb41a99b3d52800e1011b73 | NOT_APPLICABLE | NOT_APPLICABLE | virtual status_t dequeueBuffer(int *buf, sp<Fence>* fence, bool async,
uint32_t width, uint32_t height, PixelFormat format,
uint32_t usage) {
Parcel data, reply;
data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
data.writeInt32(static_cast<int32_t>(async));
data.writeUint32(width);
data.writeUint32(height);
data.writeInt32(static_cast<int32_t>(format));
data.writeUint32(usage);
status_t result = remote()->transact(DEQUEUE_BUFFER, data, &reply);
if (result != NO_ERROR) {
return result;
}
*buf = reply.readInt32();
bool nonNull = reply.readInt32();
if (nonNull) {
*fence = new Fence();
reply.read(**fence);
}
result = reply.readInt32();
return result;
}
| 0 |
libexpat | 11f8838bf99ea0a6f0b76f9760c43704d00c4ff6 | NOT_APPLICABLE | NOT_APPLICABLE | epilogProcessor(XML_Parser parser,
const char *s,
const char *end,
const char **nextPtr)
{
parser->m_processor = epilogProcessor;
parser->m_eventPtr = s;
for (;;) {
const char *next = NULL;
int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
parser->m_eventEndPtr = next;
switch (tok) {
/* report partial linebreak - it might be the last token */
case -XML_TOK_PROLOG_S:
if (parser->m_defaultHandler) {
reportDefault(parser, parser->m_encoding, s, next);
if (parser->m_parsingStatus.parsing == XML_FINISHED)
return XML_ERROR_ABORTED;
}
*nextPtr = next;
return XML_ERROR_NONE;
case XML_TOK_NONE:
*nextPtr = s;
return XML_ERROR_NONE;
case XML_TOK_PROLOG_S:
if (parser->m_defaultHandler)
reportDefault(parser, parser->m_encoding, s, next);
break;
case XML_TOK_PI:
if (!reportProcessingInstruction(parser, parser->m_encoding, s, next))
return XML_ERROR_NO_MEMORY;
break;
case XML_TOK_COMMENT:
if (!reportComment(parser, parser->m_encoding, s, next))
return XML_ERROR_NO_MEMORY;
break;
case XML_TOK_INVALID:
parser->m_eventPtr = next;
return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL:
if (!parser->m_parsingStatus.finalBuffer) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR:
if (!parser->m_parsingStatus.finalBuffer) {
*nextPtr = s;
return XML_ERROR_NONE;
}
return XML_ERROR_PARTIAL_CHAR;
default:
return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
}
parser->m_eventPtr = s = next;
switch (parser->m_parsingStatus.parsing) {
case XML_SUSPENDED:
*nextPtr = next;
return XML_ERROR_NONE;
case XML_FINISHED:
return XML_ERROR_ABORTED;
default: ;
}
}
}
| 0 |
gpac | faa75edde3dfeba1e2cf6ffa48e45a50f1042096 | NOT_APPLICABLE | NOT_APPLICABLE | static void lsr_read_lsr_enabled(GF_LASeRCodec *lsr, GF_Node *elt)
{
u32 err;
GF_LSR_READ_INT(lsr, err, 1, "enabled");
if (err) {
GF_FieldInfo info;
lsr->last_error = gf_node_get_attribute_by_tag(elt, TAG_LSR_ATT_enabled, 1, 0, &info);
*(SVG_Boolean*)info.far_ptr = 1;
}
} | 0 |
rpm | 8f4b3c3cab8922a2022b9e47c71f1ecf906077ef | NOT_APPLICABLE | NOT_APPLICABLE | static int hdrchkTagType(rpm_tag_t tag, rpm_tagtype_t type)
{
rpmTagType t = rpmTagGetTagType(tag);
if (t == type)
return 0;
/* Permit unknown tags for forward compatibility */
if (t == RPM_NULL_TYPE)
return 0;
/* Some string tags harmlessly disagree on the exact type */
if (rpmTagGetClass(tag) == RPM_STRING_CLASS &&
(rpmTagTypeGetClass(type) == RPM_STRING_CLASS))
return 0;
/* Known tag with mismatching type, bad bad bad. */
return 1;
} | 0 |
php-src | 70ddc853fd4757004ac488e6ee892897bb6f395a | NOT_APPLICABLE | NOT_APPLICABLE | PHP_FUNCTION(escapeshellarg)
{
char *argument;
int argument_len;
char *cmd = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &argument, &argument_len) == FAILURE) {
return;
}
if (argument) {
RETVAL_STR(php_escape_shell_arg(argument));
}
} | 0 |
LibRaw | d5715aa86a83c756e38fdbae0e034e5a07901d49 | NOT_APPLICABLE | NOT_APPLICABLE | void CLASS parse_mos (int offset)
{
char data[40];
int skip, from, i, c, neut[4], planes=0, frot=0;
static const char *mod[] =
{ "","DCB2","Volare","Cantare","CMost","Valeo 6","Valeo 11","Valeo 22",
"Valeo 11p","Valeo 17","","Aptus 17","Aptus 22","Aptus 75","Aptus 65",
"Aptus 54S","Aptus 65S","Aptus 75S","AFi 5","AFi 6","AFi 7",
"Aptus-II 7","","","Aptus-II 6","","","Aptus-II 10","Aptus-II 5",
"","","","","Aptus-II 10R","Aptus-II 8","","Aptus-II 12","","AFi-II 12" };
float romm_cam[3][3];
fseek (ifp, offset, SEEK_SET);
while (1) {
if (get4() != 0x504b5453) break;
get4();
fread (data, 1, 40, ifp);
skip = get4();
from = ftell(ifp);
if (!strcmp(data,"JPEG_preview_data")) {
thumb_offset = from;
thumb_length = skip;
}
if (!strcmp(data,"icc_camera_profile")) {
profile_offset = from;
profile_length = skip;
}
if (!strcmp(data,"ShootObj_back_type")) {
fscanf (ifp, "%d", &i);
if ((unsigned) i < sizeof mod / sizeof (*mod))
strcpy (model, mod[i]);
}
if (!strcmp(data,"icc_camera_to_tone_matrix")) {
for (i=0; i < 9; i++)
romm_cam[0][i] = int_to_float(get4());
romm_coeff (romm_cam);
}
if (!strcmp(data,"CaptProf_color_matrix")) {
for (i=0; i < 9; i++)
fscanf (ifp, "%f", &romm_cam[0][i]);
romm_coeff (romm_cam);
}
if (!strcmp(data,"CaptProf_number_of_planes"))
fscanf (ifp, "%d", &planes);
if (!strcmp(data,"CaptProf_raw_data_rotation"))
fscanf (ifp, "%d", &flip);
if (!strcmp(data,"CaptProf_mosaic_pattern"))
FORC4 {
fscanf (ifp, "%d", &i);
if (i == 1) frot = c ^ (c >> 1);
}
if (!strcmp(data,"ImgProf_rotation_angle")) {
fscanf (ifp, "%d", &i);
flip = i - flip;
}
if (!strcmp(data,"NeutObj_neutrals") && !cam_mul[0]) {
FORC4 fscanf (ifp, "%d", neut+c);
FORC3 cam_mul[c] = (float) neut[0] / neut[c+1];
}
if (!strcmp(data,"Rows_data"))
load_flags = get4();
parse_mos (from);
fseek (ifp, skip+from, SEEK_SET);
}
if (planes)
filters = (planes == 1) * 0x01010101 *
(uchar) "\x94\x61\x16\x49"[(flip/90 + frot) & 3];
} | 0 |
tensorflow | 08d7b00c0a5a20926363849f611729f53f3ec022 | NOT_APPLICABLE | NOT_APPLICABLE | Status ReadDiagIndex(InferenceContext* c, const Tensor* diag_index_tensor,
int32* lower_diag_index, int32* upper_diag_index) {
// This function assumes that the shape of diag_index_tensor is fully defined.
if (diag_index_tensor->dims() == 0) {
*lower_diag_index = diag_index_tensor->scalar<int32>()();
*upper_diag_index = *lower_diag_index;
} else {
int32_t num_elements = diag_index_tensor->dim_size(0);
if (num_elements == 1) {
*lower_diag_index = diag_index_tensor->vec<int32>()(0);
*upper_diag_index = *lower_diag_index;
} else if (num_elements == 2) {
*lower_diag_index = diag_index_tensor->vec<int32>()(0);
*upper_diag_index = diag_index_tensor->vec<int32>()(1);
} else {
return errors::InvalidArgument(
"diag_index must be a vector with one or two elements. It has ",
num_elements, " elements.");
}
}
return Status::OK();
} | 0 |
frr | 6d58272b4cf96f0daa846210dd2104877900f921 | NOT_APPLICABLE | NOT_APPLICABLE | peer_maximum_prefix_set_vty (struct vty *vty, const char *ip_str, afi_t afi,
safi_t safi, const char *num_str,
const char *threshold_str, int warning,
const char *restart_str)
{
int ret;
struct peer *peer;
u_int32_t max;
u_char threshold;
u_int16_t restart;
peer = peer_and_group_lookup_vty (vty, ip_str);
if (! peer)
return CMD_WARNING;
VTY_GET_INTEGER ("maxmum number", max, num_str);
if (threshold_str)
threshold = atoi (threshold_str);
else
threshold = MAXIMUM_PREFIX_THRESHOLD_DEFAULT;
if (restart_str)
restart = atoi (restart_str);
else
restart = 0;
ret = peer_maximum_prefix_set (peer, afi, safi, max, threshold, warning, restart);
return bgp_vty_return (vty, ret);
} | 0 |
oniguruma | 474e5dd6a245faf5f75922bc83f077e55881fa5b | NOT_APPLICABLE | NOT_APPLICABLE | onig_scan_unsigned_number(UChar** src, const UChar* end, OnigEncoding enc)
{
unsigned int num, val;
OnigCodePoint c;
UChar* p = *src;
PFETCH_READY;
num = 0;
while (! PEND) {
PFETCH(c);
if (IS_CODE_DIGIT_ASCII(enc, c)) {
val = (unsigned int )DIGITVAL(c);
if ((INT_MAX_LIMIT - val) / 10UL < num)
return -1; /* overflow */
num = num * 10 + val;
}
else {
PUNFETCH;
break;
}
}
*src = p;
return num;
} | 0 |
linux | 96b3d28bf4b00f62fc8386ff5d487d1830793a3d | NOT_APPLICABLE | NOT_APPLICABLE | static inline u64 wrap_min(u64 x, u64 y)
{
return (s64)(x - y) < 0 ? x : y;
} | 0 |
linux | 6ff7b060535e87c2ae14dd8548512abfdda528fb | NOT_APPLICABLE | NOT_APPLICABLE | int mdiobus_unregister_device(struct mdio_device *mdiodev)
{
if (mdiodev->bus->mdio_map[mdiodev->addr] != mdiodev)
return -EINVAL;
mdiodev->bus->mdio_map[mdiodev->addr] = NULL;
return 0;
}
| 0 |
squashfs-tools | e0485802ec72996c20026da320650d8362f555bd | NOT_APPLICABLE | NOT_APPLICABLE | int read_super_2(squashfs_operations **s_ops, void *s)
{
squashfs_super_block_3 *sBlk_3 = s;
if(sBlk_3->s_magic != SQUASHFS_MAGIC || sBlk_3->s_major != 2 ||
sBlk_3->s_minor > 1)
return -1;
sBlk.s.s_magic = sBlk_3->s_magic;
sBlk.s.inodes = sBlk_3->inodes;
sBlk.s.mkfs_time = sBlk_3->mkfs_time;
sBlk.s.block_size = sBlk_3->block_size;
sBlk.s.fragments = sBlk_3->fragments;
sBlk.s.block_log = sBlk_3->block_log;
sBlk.s.flags = sBlk_3->flags;
sBlk.s.s_major = sBlk_3->s_major;
sBlk.s.s_minor = sBlk_3->s_minor;
sBlk.s.root_inode = sBlk_3->root_inode;
sBlk.s.bytes_used = sBlk_3->bytes_used_2;
sBlk.s.inode_table_start = sBlk_3->inode_table_start;
sBlk.s.directory_table_start = sBlk_3->directory_table_start_2;
sBlk.s.fragment_table_start = sBlk_3->fragment_table_start_2;
sBlk.s.inode_table_start = sBlk_3->inode_table_start_2;
sBlk.no_uids = sBlk_3->no_uids;
sBlk.no_guids = sBlk_3->no_guids;
sBlk.uid_start = sBlk_3->uid_start_2;
sBlk.guid_start = sBlk_3->guid_start_2;
sBlk.s.xattr_id_table_start = SQUASHFS_INVALID_BLK;
*s_ops = &ops;
/*
* 2.x filesystems use gzip compression.
*/
comp = lookup_compressor("gzip");
if(sBlk_3->s_minor == 0)
needs_sorting = TRUE;
return TRUE;
} | 0 |
Chrome | acae973ac6297404fe3c9b389b69bf3c7e62cd19 | NOT_APPLICABLE | NOT_APPLICABLE | v8::Handle<v8::Value> V8DOMWrapper::convertEventListenerToV8Object(EventListener* listener)
{
if (!listener)
return v8::Null();
V8AbstractEventListener* v8listener = static_cast<V8AbstractEventListener*>(listener);
return v8listener->getListenerObject();
}
| 0 |
FFmpeg | c94f9e854228e0ea00e1de8769d8d3f7cab84a55 | NOT_APPLICABLE | NOT_APPLICABLE | void *av_realloc(void *ptr, size_t size)
{
#if CONFIG_MEMALIGN_HACK
int diff;
#endif
/* let's disallow possible ambiguous cases */
if (size > (max_alloc_size - 32))
return NULL;
#if CONFIG_MEMALIGN_HACK
if (!ptr)
return av_malloc(size);
diff = ((char *)ptr)[-1];
av_assert0(diff>0 && diff<=ALIGN);
ptr = realloc((char *)ptr - diff, size + diff);
if (ptr)
ptr = (char *)ptr + diff;
return ptr;
#elif HAVE_ALIGNED_MALLOC
return _aligned_realloc(ptr, size + !size, ALIGN);
#else
return realloc(ptr, size + !size);
#endif
}
| 0 |
Chrome | d27468a832d5316884bd02f459cbf493697fd7e1 | CVE-2015-1274 | CWE-254 | AccessibilityExpanded AXNodeObject::isExpanded() const {
if (getNode() && isHTMLSummaryElement(*getNode())) {
if (getNode()->parentNode() &&
isHTMLDetailsElement(getNode()->parentNode()))
return toElement(getNode()->parentNode())->hasAttribute(openAttr)
? ExpandedExpanded
: ExpandedCollapsed;
}
const AtomicString& expanded = getAttribute(aria_expandedAttr);
if (equalIgnoringCase(expanded, "true"))
return ExpandedExpanded;
if (equalIgnoringCase(expanded, "false"))
return ExpandedCollapsed;
return ExpandedUndefined;
}
| 1 |
Chrome | ac0a7cb3b0da035c2c2ca21abf2c5f899ec32735 | NOT_APPLICABLE | NOT_APPLICABLE | void WebUIBidiCheckerBrowserTestRTL::RunBidiCheckerOnPage(
const std::string& page_url) {
WebUIBidiCheckerBrowserTest::RunBidiCheckerOnPage(page_url, true);
}
| 0 |
Chrome | 25f9415f43d607d3d01f542f067e3cc471983e6b | NOT_APPLICABLE | NOT_APPLICABLE | void HTMLSelectElement::optionElementChildrenChanged()
{
setRecalcListItems();
setNeedsValidityCheck();
if (renderer()) {
if (AXObjectCache* cache = renderer()->document().existingAXObjectCache())
cache->childrenChanged(this);
}
}
| 0 |
linux | 07f12b26e21ab359261bf75cfcb424fdc7daeb6d | NOT_APPLICABLE | NOT_APPLICABLE | static int ipip6_tunnel_create(struct net_device *dev)
{
struct ip_tunnel *t = netdev_priv(dev);
struct net *net = dev_net(dev);
struct sit_net *sitn = net_generic(net, sit_net_id);
int err;
memcpy(dev->dev_addr, &t->parms.iph.saddr, 4);
memcpy(dev->broadcast, &t->parms.iph.daddr, 4);
if ((__force u16)t->parms.i_flags & SIT_ISATAP)
dev->priv_flags |= IFF_ISATAP;
dev->rtnl_link_ops = &sit_link_ops;
err = register_netdevice(dev);
if (err < 0)
goto out;
ipip6_tunnel_clone_6rd(dev, sitn);
dev_hold(dev);
ipip6_tunnel_link(sitn, t);
return 0;
out:
return err;
}
| 0 |
vim | 5921aeb5741fc6e84c870d68c7c35b93ad0c9f87 | NOT_APPLICABLE | NOT_APPLICABLE | f_getfsize(typval_T *argvars, typval_T *rettv)
{
char_u *fname;
stat_T st;
if (in_vim9script() && check_for_string_arg(argvars, 0) == FAIL)
return;
fname = tv_get_string(&argvars[0]);
if (mch_stat((char *)fname, &st) >= 0)
{
if (mch_isdir(fname))
rettv->vval.v_number = 0;
else
{
rettv->vval.v_number = (varnumber_T)st.st_size;
// non-perfect check for overflow
if ((off_T)rettv->vval.v_number != (off_T)st.st_size)
rettv->vval.v_number = -2;
}
}
else
rettv->vval.v_number = -1;
} | 0 |
Chrome | 4c19b042ea31bd393d2265656f94339d1c3d82ff | NOT_APPLICABLE | NOT_APPLICABLE | virtual ~RelayCreateOrOpen() {
if (file_handle_ != base::kInvalidPlatformFileValue)
base::FileUtilProxy::Close(message_loop_proxy_, file_handle_, NULL);
}
| 0 |
kvm-guest-drivers-windows | fbfa4d1083ea84c5429992ca3e996d7d4fbc8238 | NOT_APPLICABLE | NOT_APPLICABLE | static LPCSTR __inline GetIPCSCase(tTcpIpPacketParsingResult res)
{
static const char *const CSCaseName[4] = { "not tested", "(too short)", "OK", "Bad" };
return CSCaseName[res.ipCheckSum];
}
| 0 |
linux-2.6 | 8a47077a0b5aa2649751c46e7a27884e6686ccbf | NOT_APPLICABLE | NOT_APPLICABLE | static unsigned long cbq_undelay_prio(struct cbq_sched_data *q, int prio)
{
struct cbq_class *cl;
struct cbq_class *cl_prev = q->active[prio];
unsigned long now = jiffies;
unsigned long sched = now;
if (cl_prev == NULL)
return now;
do {
cl = cl_prev->next_alive;
if ((long)(now - cl->penalized) > 0) {
cl_prev->next_alive = cl->next_alive;
cl->next_alive = NULL;
cl->cpriority = cl->priority;
cl->delayed = 0;
cbq_activate_class(cl);
if (cl == q->active[prio]) {
q->active[prio] = cl_prev;
if (cl == q->active[prio]) {
q->active[prio] = NULL;
return 0;
}
}
cl = cl_prev->next_alive;
} else if ((long)(sched - cl->penalized) > 0)
sched = cl->penalized;
} while ((cl_prev = cl) != q->active[prio]);
return (long)(sched - now);
} | 0 |
radare2 | d1e8ac62c6d978d4662f69116e30230d43033c92 | NOT_APPLICABLE | NOT_APPLICABLE | void* MACH0_(mach0_free)(struct MACH0_(obj_t)* bin) {
if (!bin) {
return NULL;
}
free (bin->segs);
free (bin->sects);
free (bin->symtab);
free (bin->symstr);
free (bin->indirectsyms);
free (bin->imports_by_ord);
free (bin->dyld_info);
free (bin->toc);
free (bin->modtab);
free (bin->libs);
free (bin->func_start);
free (bin->signature);
r_buf_free (bin->b);
free (bin);
return NULL;
}
| 0 |
libarchive | 3ad08e01b4d253c66ae56414886089684155af22 | NOT_APPLICABLE | NOT_APPLICABLE | isJolietSVD(struct iso9660 *iso9660, const unsigned char *h)
{
const unsigned char *p;
ssize_t logical_block_size;
int32_t volume_block;
/* Check if current sector is a kind of Supplementary Volume
* Descriptor. */
if (!isSVD(iso9660, h))
return (0);
/* FIXME: do more validations according to joliet spec. */
/* check if this SVD contains joliet extension! */
p = h + SVD_escape_sequences_offset;
/* N.B. Joliet spec says p[1] == '\\', but.... */
if (p[0] == '%' && p[1] == '/') {
int level = 0;
if (p[2] == '@')
level = 1;
else if (p[2] == 'C')
level = 2;
else if (p[2] == 'E')
level = 3;
else /* not joliet */
return (0);
iso9660->seenJoliet = level;
} else /* not joliet */
return (0);
logical_block_size =
archive_le16dec(h + SVD_logical_block_size_offset);
volume_block = archive_le32dec(h + SVD_volume_space_size_offset);
iso9660->logical_block_size = logical_block_size;
iso9660->volume_block = volume_block;
iso9660->volume_size = logical_block_size * (uint64_t)volume_block;
/* Read Root Directory Record in Volume Descriptor. */
p = h + SVD_root_directory_record_offset;
iso9660->joliet.location = archive_le32dec(p + DR_extent_offset);
iso9660->joliet.size = archive_le32dec(p + DR_size_offset);
return (48);
}
| 0 |
ImageMagick6 | 072d7b10dbe74d1cf4ec0d008990c1a28c076f9e | NOT_APPLICABLE | NOT_APPLICABLE | static MagickPixelPacket **DestroyPixelThreadSet(const Image *images,
MagickPixelPacket **pixels)
{
ssize_t
i;
size_t
rows;
assert(pixels != (MagickPixelPacket **) NULL);
rows=MagickMax(GetImageListLength(images),
(size_t) GetMagickResourceLimit(ThreadResource));
for (i=0; i < (ssize_t) rows; i++)
if (pixels[i] != (MagickPixelPacket *) NULL)
pixels[i]=(MagickPixelPacket *) RelinquishMagickMemory(pixels[i]);
pixels=(MagickPixelPacket **) RelinquishMagickMemory(pixels);
return(pixels);
} | 0 |
UltraVNC | 36a31b37b98f70c1db0428f5ad83170d604fb352 | NOT_APPLICABLE | NOT_APPLICABLE | vncProperties::SavePassword2(HKEY key, char *buffer) //PGM
{ //PGM
RegSetValueEx(key, "Password2", 0, REG_BINARY, (LPBYTE) buffer, MAXPWLEN); //PGM
} //PGM
| 0 |
linux | f9dbdf97a5bd92b1a49cee3d591b55b11fd7a6d5 | NOT_APPLICABLE | NOT_APPLICABLE | * 1 on success
* 0 on failure
*/
static int iscsi_is_flashnode_conn_dev(struct device *dev, void *data) | 0 |
slurm | 92362a92fffe60187df61f99ab11c249d44120ee | NOT_APPLICABLE | NOT_APPLICABLE | _rpc_daemon_status(slurm_msg_t *msg)
{
slurm_msg_t resp_msg;
slurmd_status_t *resp = NULL;
resp = xmalloc(sizeof(slurmd_status_t));
resp->actual_cpus = conf->actual_cpus;
resp->actual_boards = conf->actual_boards;
resp->actual_sockets = conf->actual_sockets;
resp->actual_cores = conf->actual_cores;
resp->actual_threads = conf->actual_threads;
resp->actual_real_mem = conf->real_memory_size;
resp->actual_tmp_disk = conf->tmp_disk_space;
resp->booted = startup;
resp->hostname = xstrdup(conf->node_name);
resp->step_list = _get_step_list();
resp->last_slurmctld_msg = last_slurmctld_msg;
resp->pid = conf->pid;
resp->slurmd_debug = conf->debug_level;
resp->slurmd_logfile = xstrdup(conf->logfile);
resp->version = xstrdup(SLURM_VERSION_STRING);
slurm_msg_t_copy(&resp_msg, msg);
resp_msg.msg_type = RESPONSE_SLURMD_STATUS;
resp_msg.data = resp;
slurm_send_node_msg(msg->conn_fd, &resp_msg);
slurm_free_slurmd_status(resp);
return SLURM_SUCCESS;
}
| 0 |
xserver | 215f894965df5fb0bb45b107d84524e700d2073c | NOT_APPLICABLE | NOT_APPLICABLE | WindowXI2MaskIsset(DeviceIntPtr dev, WindowPtr win, xEvent *ev)
{
OtherInputMasks *inputMasks = wOtherInputMasks(win);
int evtype;
if (!inputMasks || xi2_get_type(ev) == 0)
return 0;
evtype = ((xGenericEvent *) ev)->evtype;
return xi2mask_isset(inputMasks->xi2mask, dev, evtype);
}
| 0 |
qemu | 4ffcdef4277a91af15a3c09f7d16af072c29f3f2 | NOT_APPLICABLE | NOT_APPLICABLE | int pt_setxattr(FsContext *ctx, const char *path, const char *name, void *value,
size_t size, int flags)
{
return local_setxattr_nofollow(ctx, path, name, value, size, flags);
}
| 0 |
ImageMagick | bd9f1e7d1bd2c8e2cf7895d133c5c5b5cd3526b6 | NOT_APPLICABLE | NOT_APPLICABLE | static Image *ReadPSDImage(const ImageInfo *image_info,ExceptionInfo *exception)
{
Image
*image;
MagickBooleanType
has_merged_image,
skip_layers;
MagickOffsetType
offset;
MagickSizeType
length;
MagickBooleanType
status;
PSDInfo
psd_info;
register ssize_t
i;
ssize_t
count;
unsigned char
*data;
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Read image header.
*/
image->endian=MSBEndian;
count=ReadBlob(image,4,(unsigned char *) psd_info.signature);
psd_info.version=ReadBlobMSBShort(image);
if ((count == 0) || (LocaleNCompare(psd_info.signature,"8BPS",4) != 0) ||
((psd_info.version != 1) && (psd_info.version != 2)))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
(void) ReadBlob(image,6,psd_info.reserved);
psd_info.channels=ReadBlobMSBShort(image);
if (psd_info.channels > MaxPSDChannels)
ThrowReaderException(CorruptImageError,"MaximumChannelsExceeded");
psd_info.rows=ReadBlobMSBLong(image);
psd_info.columns=ReadBlobMSBLong(image);
if ((psd_info.version == 1) && ((psd_info.rows > 30000) ||
(psd_info.columns > 30000)))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
psd_info.depth=ReadBlobMSBShort(image);
if ((psd_info.depth != 1) && (psd_info.depth != 8) && (psd_info.depth != 16))
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
psd_info.mode=ReadBlobMSBShort(image);
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Image is %.20g x %.20g with channels=%.20g, depth=%.20g, mode=%s",
(double) psd_info.columns,(double) psd_info.rows,(double)
psd_info.channels,(double) psd_info.depth,ModeToString((PSDImageType)
psd_info.mode));
/*
Initialize image.
*/
image->depth=psd_info.depth;
image->columns=psd_info.columns;
image->rows=psd_info.rows;
status=SetImageExtent(image,image->columns,image->rows,exception);
if (status == MagickFalse)
return(DestroyImageList(image));
if (SetImageBackgroundColor(image,exception) == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
if (psd_info.mode == LabMode)
SetImageColorspace(image,LabColorspace,exception);
if (psd_info.mode == CMYKMode)
{
SetImageColorspace(image,CMYKColorspace,exception);
image->alpha_trait=psd_info.channels > 4 ? BlendPixelTrait :
UndefinedPixelTrait;
}
else if ((psd_info.mode == BitmapMode) || (psd_info.mode == GrayscaleMode) ||
(psd_info.mode == DuotoneMode))
{
status=AcquireImageColormap(image,psd_info.depth != 16 ? 256 : 65536,
exception);
if (status == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" Image colormap allocated");
SetImageColorspace(image,GRAYColorspace,exception);
image->alpha_trait=psd_info.channels > 1 ? BlendPixelTrait :
UndefinedPixelTrait;
}
else
image->alpha_trait=psd_info.channels > 3 ? BlendPixelTrait :
UndefinedPixelTrait;
/*
Read PSD raster colormap only present for indexed and duotone images.
*/
length=ReadBlobMSBLong(image);
if (length != 0)
{
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" reading colormap");
if (psd_info.mode == DuotoneMode)
{
/*
Duotone image data; the format of this data is undocumented.
*/
data=(unsigned char *) AcquireQuantumMemory((size_t) length,
sizeof(*data));
if (data == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
(void) ReadBlob(image,(size_t) length,data);
data=(unsigned char *) RelinquishMagickMemory(data);
}
else
{
size_t
number_colors;
/*
Read PSD raster colormap.
*/
number_colors=length/3;
if (number_colors > 65536)
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
if (AcquireImageColormap(image,number_colors,exception) == MagickFalse)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
for (i=0; i < (ssize_t) image->colors; i++)
image->colormap[i].red=ScaleCharToQuantum((unsigned char)
ReadBlobByte(image));
for (i=0; i < (ssize_t) image->colors; i++)
image->colormap[i].green=ScaleCharToQuantum((unsigned char)
ReadBlobByte(image));
for (i=0; i < (ssize_t) image->colors; i++)
image->colormap[i].blue=ScaleCharToQuantum((unsigned char)
ReadBlobByte(image));
image->alpha_trait=UndefinedPixelTrait;
}
}
has_merged_image=MagickTrue;
length=ReadBlobMSBLong(image);
if (length != 0)
{
unsigned char
*blocks;
/*
Image resources block.
*/
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" reading image resource blocks - %.20g bytes",(double)
((MagickOffsetType) length));
blocks=(unsigned char *) AcquireQuantumMemory((size_t) length,
sizeof(*blocks));
if (blocks == (unsigned char *) NULL)
ThrowReaderException(ResourceLimitError,"MemoryAllocationFailed");
count=ReadBlob(image,(size_t) length,blocks);
if ((count != (ssize_t) length) ||
(LocaleNCompare((char *) blocks,"8BIM",4) != 0))
{
blocks=(unsigned char *) RelinquishMagickMemory(blocks);
ThrowReaderException(CorruptImageError,"ImproperImageHeader");
}
ParseImageResourceBlocks(image,blocks,(size_t) length,&has_merged_image,
exception);
blocks=(unsigned char *) RelinquishMagickMemory(blocks);
}
/*
Layer and mask block.
*/
length=GetPSDSize(&psd_info,image);
if (length == 8)
{
length=ReadBlobMSBLong(image);
length=ReadBlobMSBLong(image);
}
offset=TellBlob(image);
skip_layers=MagickFalse;
if ((image_info->number_scenes == 1) && (image_info->scene == 0) &&
(has_merged_image != MagickFalse))
{
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" read composite only");
skip_layers=MagickTrue;
}
if (length == 0)
{
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" image has no layers");
}
else
{
if (ReadPSDLayers(image,image_info,&psd_info,skip_layers,exception) !=
MagickTrue)
{
(void) CloseBlob(image);
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Skip the rest of the layer and mask information.
*/
SeekBlob(image,offset+length,SEEK_SET);
}
/*
If we are only "pinging" the image, then we're done - so return.
*/
if (image_info->ping != MagickFalse)
{
(void) CloseBlob(image);
return(GetFirstImageInList(image));
}
/*
Read the precombined layer, present for PSD < 4 compatibility.
*/
if (image->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
" reading the precombined layer");
if ((has_merged_image != MagickFalse) || (GetImageListLength(image) == 1))
has_merged_image=(MagickBooleanType) ReadPSDMergedImage(image_info,image,
&psd_info,exception);
if ((has_merged_image == MagickFalse) && (GetImageListLength(image) == 1) &&
(length != 0))
{
SeekBlob(image,offset,SEEK_SET);
status=ReadPSDLayers(image,image_info,&psd_info,MagickFalse,exception);
if (status != MagickTrue)
{
(void) CloseBlob(image);
return((Image *) NULL);
}
}
if ((has_merged_image == MagickFalse) && (GetImageListLength(image) > 1))
{
Image
*merged;
SetImageAlphaChannel(image,TransparentAlphaChannel,exception);
image->background_color.alpha=TransparentAlpha;
image->background_color.alpha_trait=BlendPixelTrait;
merged=MergeImageLayers(image,FlattenLayer,exception);
ReplaceImageInList(&image,merged);
}
(void) CloseBlob(image);
return(GetFirstImageInList(image));
} | 0 |
samba | 94295b7aa22d2544af5323bca70d3dcb97fd7c64 | NOT_APPLICABLE | NOT_APPLICABLE | static NTSTATUS cli_connect_nb_recv(struct tevent_req *req,
struct cli_state **pcli)
{
struct cli_connect_nb_state *state = tevent_req_data(
req, struct cli_connect_nb_state);
NTSTATUS status;
if (tevent_req_is_nterror(req, &status)) {
return status;
}
*pcli = talloc_move(NULL, &state->cli);
return NT_STATUS_OK;
} | 0 |
openbsd | 0654414afcce51a16d35d05060190a3ec4618d42 | NOT_APPLICABLE | NOT_APPLICABLE | X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param)
{
return param->flags;
}
| 0 |
openssl | 4b390b6c3f8df925dc92a3dd6b022baa9a2f4650 | NOT_APPLICABLE | NOT_APPLICABLE | static SUB_STATE_RETURN write_state_machine(SSL *s)
{
OSSL_STATEM *st = &s->statem;
int ret;
WRITE_TRAN(*transition) (SSL *s);
WORK_STATE(*pre_work) (SSL *s, WORK_STATE wst);
WORK_STATE(*post_work) (SSL *s, WORK_STATE wst);
int (*construct_message) (SSL *s);
void (*cb) (const SSL *ssl, int type, int val) = NULL;
cb = get_callback(s);
if (s->server) {
transition = ossl_statem_server_write_transition;
pre_work = ossl_statem_server_pre_work;
post_work = ossl_statem_server_post_work;
construct_message = ossl_statem_server_construct_message;
} else {
transition = ossl_statem_client_write_transition;
pre_work = ossl_statem_client_pre_work;
post_work = ossl_statem_client_post_work;
construct_message = ossl_statem_client_construct_message;
}
while (1) {
switch (st->write_state) {
case WRITE_STATE_TRANSITION:
if (cb != NULL) {
/* Notify callback of an impending state change */
if (s->server)
cb(s, SSL_CB_ACCEPT_LOOP, 1);
else
cb(s, SSL_CB_CONNECT_LOOP, 1);
}
switch (transition(s)) {
case WRITE_TRAN_CONTINUE:
st->write_state = WRITE_STATE_PRE_WORK;
st->write_state_work = WORK_MORE_A;
break;
case WRITE_TRAN_FINISHED:
return SUB_STATE_FINISHED;
break;
default:
return SUB_STATE_ERROR;
}
break;
case WRITE_STATE_PRE_WORK:
switch (st->write_state_work = pre_work(s, st->write_state_work)) {
default:
return SUB_STATE_ERROR;
case WORK_FINISHED_CONTINUE:
st->write_state = WRITE_STATE_SEND;
break;
case WORK_FINISHED_STOP:
return SUB_STATE_END_HANDSHAKE;
}
if (construct_message(s) == 0)
return SUB_STATE_ERROR;
/* Fall through */
case WRITE_STATE_SEND:
if (SSL_IS_DTLS(s) && st->use_timer) {
dtls1_start_timer(s);
}
ret = statem_do_write(s);
if (ret <= 0) {
return SUB_STATE_ERROR;
}
st->write_state = WRITE_STATE_POST_WORK;
st->write_state_work = WORK_MORE_A;
/* Fall through */
case WRITE_STATE_POST_WORK:
switch (st->write_state_work = post_work(s, st->write_state_work)) {
default:
return SUB_STATE_ERROR;
case WORK_FINISHED_CONTINUE:
st->write_state = WRITE_STATE_TRANSITION;
break;
case WORK_FINISHED_STOP:
return SUB_STATE_END_HANDSHAKE;
}
break;
default:
return SUB_STATE_ERROR;
}
}
}
| 0 |
linux | bf118a342f10dafe44b14451a1392c3254629a1f | NOT_APPLICABLE | NOT_APPLICABLE | static void nfs4_xdr_enc_getdeviceinfo(struct rpc_rqst *req,
struct xdr_stream *xdr,
struct nfs4_getdeviceinfo_args *args)
{
struct compound_hdr hdr = {
.minorversion = nfs4_xdr_minorversion(&args->seq_args),
};
encode_compound_hdr(xdr, req, &hdr);
encode_sequence(xdr, &args->seq_args, &hdr);
encode_getdeviceinfo(xdr, args, &hdr);
/* set up reply kvec. Subtract notification bitmap max size (2)
* so that notification bitmap is put in xdr_buf tail */
xdr_inline_pages(&req->rq_rcv_buf, (hdr.replen - 2) << 2,
args->pdev->pages, args->pdev->pgbase,
args->pdev->pglen);
encode_nops(&hdr);
}
| 0 |
Chrome | fad67a5b73639d7211b24fd9bdb242e82039b765 | NOT_APPLICABLE | NOT_APPLICABLE | void Resource::MarkClientFinished(ResourceClient* client) {
if (clients_.Contains(client)) {
finished_clients_.insert(client);
clients_.erase(client);
}
}
| 0 |
wildmidi | 660b513d99bced8783a4a5984ac2f742c74ebbdd | NOT_APPLICABLE | NOT_APPLICABLE | static int midi_setup_timesignature(struct _mdi *mdi, uint32_t setting) {
MIDI_EVENT_DEBUG(__FUNCTION__,0, setting);
_WM_CheckEventMemoryPool(mdi);
mdi->events[mdi->event_count].do_event = *_WM_do_meta_timesignature;
mdi->events[mdi->event_count].event_data.channel = 0;
mdi->events[mdi->event_count].event_data.data.value = setting;
mdi->events[mdi->event_count].samples_to_next = 0;
mdi->event_count++;
return (0);
}
| 0 |
server | 807945f2eb5fa22e6f233cc17b85a2e141efe2c8 | NOT_APPLICABLE | NOT_APPLICABLE | String *val_str(String*) { return &str_value; } | 0 |
bootstrap-dht | bbc0b7191e3f48461ca6e5b1b34bdf4b3f1e79a9 | NOT_APPLICABLE | NOT_APPLICABLE | void lazy_entry::pop()
{
if (m_size > 0) --m_size;
} | 0 |
samba | df487eb2d713e817660dd3b56bb26ba715fadfea | NOT_APPLICABLE | NOT_APPLICABLE | int ldb_msg_append_steal_value(struct ldb_message *msg,
const char *attr_name,
struct ldb_val *val,
int flags)
{
int ret;
struct ldb_message_element *el = NULL;
ret = ldb_msg_append_value_impl(msg, attr_name, val, flags, &el);
if (ret == LDB_SUCCESS) {
talloc_steal(el->values, val->data);
}
return ret;
} | 0 |
libarchive | 22531545514043e04633e1c015c7540b9de9dbe4 | NOT_APPLICABLE | NOT_APPLICABLE | filter_lookup(struct archive *_a, int n)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = a->filter_first;
if (n == -1)
return a->filter_last;
if (n < 0)
return NULL;
while (n > 0 && f != NULL) {
f = f->next_filter;
--n;
}
return f;
}
| 0 |
Chrome | 73edae623529f04c668268de49d00324b96166a2 | NOT_APPLICABLE | NOT_APPLICABLE | PassRefPtr<ClientRect> Range::getBoundingClientRect() const
{
return ClientRect::create(boundingRect());
}
| 0 |
Chrome | 4c8b008f055f79e622344627fed7f820375a4f01 | NOT_APPLICABLE | NOT_APPLICABLE | static inline String canonicalizedTitle(Document* document, const String& title)
{
unsigned length = title.length();
unsigned builderIndex = 0;
const CharacterType* characters = title.getCharacters<CharacterType>();
StringBuffer<CharacterType> buffer(length);
bool pendingWhitespace = false;
for (unsigned i = 0; i < length; ++i) {
UChar32 c = characters[i];
if (c <= 0x20 || c == 0x7F || (WTF::Unicode::category(c) & (WTF::Unicode::Separator_Line | WTF::Unicode::Separator_Paragraph))) {
if (builderIndex != 0)
pendingWhitespace = true;
} else {
if (pendingWhitespace) {
buffer[builderIndex++] = ' ';
pendingWhitespace = false;
}
buffer[builderIndex++] = c;
}
}
buffer.shrink(builderIndex);
return String::adopt(buffer);
}
| 0 |
linux | ac902c112d90a89e59916f751c2745f4dbdbb4bd | NOT_APPLICABLE | NOT_APPLICABLE | int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
{
return _snd_ctl_register_ioctl(fcn, &snd_control_ioctls);
}
| 0 |
linux | 51c19bf3d5cfaa66571e4b88ba2a6f6295311101 | NOT_APPLICABLE | NOT_APPLICABLE | static void hci_cmd_status_evt(struct hci_dev *hdev, struct sk_buff *skb,
u16 *opcode, u8 *status,
hci_req_complete_t *req_complete,
hci_req_complete_skb_t *req_complete_skb)
{
struct hci_ev_cmd_status *ev = (void *) skb->data;
skb_pull(skb, sizeof(*ev));
*opcode = __le16_to_cpu(ev->opcode);
*status = ev->status;
switch (*opcode) {
case HCI_OP_INQUIRY:
hci_cs_inquiry(hdev, ev->status);
break;
case HCI_OP_CREATE_CONN:
hci_cs_create_conn(hdev, ev->status);
break;
case HCI_OP_DISCONNECT:
hci_cs_disconnect(hdev, ev->status);
break;
case HCI_OP_ADD_SCO:
hci_cs_add_sco(hdev, ev->status);
break;
case HCI_OP_AUTH_REQUESTED:
hci_cs_auth_requested(hdev, ev->status);
break;
case HCI_OP_SET_CONN_ENCRYPT:
hci_cs_set_conn_encrypt(hdev, ev->status);
break;
case HCI_OP_REMOTE_NAME_REQ:
hci_cs_remote_name_req(hdev, ev->status);
break;
case HCI_OP_READ_REMOTE_FEATURES:
hci_cs_read_remote_features(hdev, ev->status);
break;
case HCI_OP_READ_REMOTE_EXT_FEATURES:
hci_cs_read_remote_ext_features(hdev, ev->status);
break;
case HCI_OP_SETUP_SYNC_CONN:
hci_cs_setup_sync_conn(hdev, ev->status);
break;
case HCI_OP_SNIFF_MODE:
hci_cs_sniff_mode(hdev, ev->status);
break;
case HCI_OP_EXIT_SNIFF_MODE:
hci_cs_exit_sniff_mode(hdev, ev->status);
break;
case HCI_OP_SWITCH_ROLE:
hci_cs_switch_role(hdev, ev->status);
break;
case HCI_OP_LE_CREATE_CONN:
hci_cs_le_create_conn(hdev, ev->status);
break;
case HCI_OP_LE_READ_REMOTE_FEATURES:
hci_cs_le_read_remote_features(hdev, ev->status);
break;
case HCI_OP_LE_START_ENC:
hci_cs_le_start_enc(hdev, ev->status);
break;
case HCI_OP_LE_EXT_CREATE_CONN:
hci_cs_le_ext_create_conn(hdev, ev->status);
break;
default:
BT_DBG("%s opcode 0x%4.4x", hdev->name, *opcode);
break;
}
if (*opcode != HCI_OP_NOP)
cancel_delayed_work(&hdev->cmd_timer);
if (ev->ncmd && !test_bit(HCI_RESET, &hdev->flags))
atomic_set(&hdev->cmd_cnt, 1);
/* Indicate request completion if the command failed. Also, if
* we're not waiting for a special event and we get a success
* command status we should try to flag the request as completed
* (since for this kind of commands there will not be a command
* complete event).
*/
if (ev->status ||
(hdev->sent_cmd && !bt_cb(hdev->sent_cmd)->hci.req_event))
hci_req_cmd_complete(hdev, *opcode, ev->status, req_complete,
req_complete_skb);
if (hci_dev_test_flag(hdev, HCI_CMD_PENDING)) {
bt_dev_err(hdev,
"unexpected event for opcode 0x%4.4x", *opcode);
return;
}
if (atomic_read(&hdev->cmd_cnt) && !skb_queue_empty(&hdev->cmd_q))
queue_work(hdev->workqueue, &hdev->cmd_work);
} | 0 |
Chrome | 69b4b9ef7455753b12c3efe4eec71647e6fb1da1 | NOT_APPLICABLE | NOT_APPLICABLE | std::string ReadSubresourceFromRenderer(Browser* browser,
const GURL& url,
bool asynchronous_xhr = true) {
static const char asynchronous_script[] = R"((url => {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, true);
xhr.onload = () => domAutomationController.send(xhr.responseText);
xhr.send();
}))";
static const char synchronous_script[] = R"((url => {
var xhr = new XMLHttpRequest();
xhr.open('GET', url, false);
xhr.send();
domAutomationController.send(xhr.responseText);
}))";
std::string result;
EXPECT_TRUE(ExecuteScriptAndExtractString(
browser->tab_strip_model()->GetActiveWebContents(),
base::StrCat({asynchronous_xhr ? asynchronous_script : synchronous_script,
"('", url.spec(), "')"}),
&result));
return result;
}
| 0 |
hhvm | e264f04ae825a5d97758130cf8eec99862517e7e | NOT_APPLICABLE | NOT_APPLICABLE | bool HHVM_FUNCTION(rsort,
VRefParam array,
int sort_flags /* = 0 */) {
bool use_zend_sort = RuntimeOption::EnableZendSorting;
return php_sort(array, sort_flags, false, use_zend_sort);
} | 0 |
php | 6aeee47b2cd47915ccfa3b41433a3f57aea24dd5 | NOT_APPLICABLE | NOT_APPLICABLE | PHP_FUNCTION(hex2bin)
{
zend_string *result, *data;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &data) == FAILURE) {
return;
}
if (ZSTR_LEN(data) % 2 != 0) {
php_error_docref(NULL, E_WARNING, "Hexadecimal input string must have an even length");
RETURN_FALSE;
}
result = php_hex2bin((unsigned char *)ZSTR_VAL(data), ZSTR_LEN(data));
if (!result) {
php_error_docref(NULL, E_WARNING, "Input string must be hexadecimal string");
RETURN_FALSE;
}
RETVAL_STR(result);
}
| 0 |
firejail | eecf35c2f8249489a1d3e512bb07f0d427183134 | NOT_APPLICABLE | NOT_APPLICABLE | static int monitor_application(pid_t app_pid) {
EUID_ASSERT();
monitored_pid = app_pid;
sigset_t oldmask, newmask;
sigemptyset(&oldmask);
sigemptyset(&newmask);
sigaddset(&newmask, SIGTERM);
sigaddset(&newmask, SIGINT);
sigprocmask(SIG_BLOCK, &newmask, &oldmask);
install_handler();
int options = 0;;
unsigned timeout = 0;
if (cfg.timeout) {
options = WNOHANG;
timeout = cfg.timeout;
}
int status = 0;
while (monitored_pid) {
usleep(20000);
char *msg;
if (asprintf(&msg, "monitoring pid %d\n", monitored_pid) == -1)
errExit("asprintf");
logmsg(msg);
if (arg_debug)
printf("%s\n", msg);
free(msg);
pid_t rv;
do {
sigprocmask(SIG_SETMASK, &oldmask, NULL);
rv = waitpid(-1, &status, options);
sigprocmask(SIG_BLOCK, &newmask, NULL);
if (rv == -1) { // we can get here if we have processes joining the sandbox (ECHILD)
sleep(1);
break;
}
if (options) {
if (--timeout == 0) {
kill(-1, SIGTERM);
sleep(1);
flush_stdin();
_exit(1);
}
else
sleep(1);
}
}
while(rv != monitored_pid);
if (arg_debug)
printf("Sandbox monitor: waitpid %d retval %d status %d\n", monitored_pid, rv, status);
DIR *dir;
if (!(dir = opendir("/proc"))) {
sleep(2);
if (!(dir = opendir("/proc"))) {
fprintf(stderr, "Error: cannot open /proc directory\n");
exit(1);
}
}
struct dirent *entry;
monitored_pid = 0;
while ((entry = readdir(dir)) != NULL) {
unsigned pid;
if (sscanf(entry->d_name, "%u", &pid) != 1)
continue;
if (pid == 1)
continue;
int found = 0;
if (strcmp(cfg.command_name, "dillo") == 0) {
char *pidname = pid_proc_comm(pid);
if (pidname && strcmp(pidname, "dpid") == 0)
found = 1;
free(pidname);
}
if (found)
break;
monitored_pid = pid;
break;
}
closedir(dir);
if (monitored_pid != 0 && arg_debug)
printf("Sandbox monitor: monitoring %d\n", monitored_pid);
}
return status;
}
| 0 |
Chrome | 2aec794f26098c7a361c27d7c8f57119631cca8a | NOT_APPLICABLE | NOT_APPLICABLE | void ServiceWorkerDevToolsAgentHost::WorkerReadyForInspection(
blink::mojom::DevToolsAgentAssociatedPtrInfo devtools_agent_ptr_info) {
DCHECK_EQ(WORKER_NOT_READY, state_);
state_ = WORKER_READY;
agent_ptr_.Bind(std::move(devtools_agent_ptr_info));
if (!sessions().empty()) {
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::BindOnce(&SetDevToolsAttachedOnIO,
context_weak_, version_id_, true));
}
for (DevToolsSession* session : sessions()) {
session->SetRenderer(worker_process_id_, nullptr);
session->AttachToAgent(agent_ptr_);
}
}
| 0 |
libexpat | d4f735b88d9932bd5039df2335eefdd0723dbe20 | CVE-2016-9063 | CWE-190 | XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
{
switch (ps_parsing) {
case XML_SUSPENDED:
errorCode = XML_ERROR_SUSPENDED;
return XML_STATUS_ERROR;
case XML_FINISHED:
errorCode = XML_ERROR_FINISHED;
return XML_STATUS_ERROR;
case XML_INITIALIZED:
if (parentParser == NULL && !startParsing(parser)) {
errorCode = XML_ERROR_NO_MEMORY;
return XML_STATUS_ERROR;
}
default:
ps_parsing = XML_PARSING;
}
if (len == 0) {
ps_finalBuffer = (XML_Bool)isFinal;
if (!isFinal)
return XML_STATUS_OK;
positionPtr = bufferPtr;
parseEndPtr = bufferEnd;
/* If data are left over from last buffer, and we now know that these
data are the final chunk of input, then we have to check them again
to detect errors based on that fact.
*/
errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
if (errorCode == XML_ERROR_NONE) {
switch (ps_parsing) {
case XML_SUSPENDED:
XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
positionPtr = bufferPtr;
return XML_STATUS_SUSPENDED;
case XML_INITIALIZED:
case XML_PARSING:
ps_parsing = XML_FINISHED;
/* fall through */
default:
return XML_STATUS_OK;
}
}
eventEndPtr = eventPtr;
processor = errorProcessor;
return XML_STATUS_ERROR;
}
#ifndef XML_CONTEXT_BYTES
else if (bufferPtr == bufferEnd) {
const char *end;
int nLeftOver;
enum XML_Status result;
parseEndByteIndex += len;
positionPtr = s;
ps_finalBuffer = (XML_Bool)isFinal;
errorCode = processor(parser, s, parseEndPtr = s + len, &end);
if (errorCode != XML_ERROR_NONE) {
eventEndPtr = eventPtr;
processor = errorProcessor;
return XML_STATUS_ERROR;
}
else {
switch (ps_parsing) {
case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED;
break;
case XML_INITIALIZED:
case XML_PARSING:
if (isFinal) {
ps_parsing = XML_FINISHED;
return XML_STATUS_OK;
}
/* fall through */
default:
result = XML_STATUS_OK;
}
}
XmlUpdatePosition(encoding, positionPtr, end, &position);
nLeftOver = s + len - end;
if (nLeftOver) {
if (buffer == NULL || nLeftOver > bufferLim - buffer) {
/* FIXME avoid integer overflow */
char *temp;
temp = (buffer == NULL
? (char *)MALLOC(len * 2)
: (char *)REALLOC(buffer, len * 2));
if (temp == NULL) {
errorCode = XML_ERROR_NO_MEMORY;
eventPtr = eventEndPtr = NULL;
processor = errorProcessor;
return XML_STATUS_ERROR;
}
buffer = temp;
bufferLim = buffer + len * 2;
}
memcpy(buffer, end, nLeftOver);
}
bufferPtr = buffer;
bufferEnd = buffer + nLeftOver;
positionPtr = bufferPtr;
parseEndPtr = bufferEnd;
eventPtr = bufferPtr;
eventEndPtr = bufferPtr;
return result;
}
#endif /* not defined XML_CONTEXT_BYTES */
else {
void *buff = XML_GetBuffer(parser, len);
if (buff == NULL)
return XML_STATUS_ERROR;
else {
memcpy(buff, s, len);
return XML_ParseBuffer(parser, len, isFinal);
}
}
} | 1 |
linux | 9b57da0630c9fd36ed7a20fc0f98dc82cc0777fa | NOT_APPLICABLE | NOT_APPLICABLE | static void __exit nf_defrag_fini(void)
{
nf_unregister_hooks(ipv6_defrag_ops, ARRAY_SIZE(ipv6_defrag_ops));
nf_ct_frag6_cleanup();
}
| 0 |
linux | 132c94e31b8bca8ea921f9f96a57d684fa4ae0a9 | NOT_APPLICABLE | NOT_APPLICABLE | struct vfsmount *collect_mounts(struct path *path)
{
struct mount *tree;
down_write(&namespace_sem);
tree = copy_tree(real_mount(path->mnt), path->dentry,
CL_COPY_ALL | CL_PRIVATE);
up_write(&namespace_sem);
if (IS_ERR(tree))
return NULL;
return &tree->mnt;
}
| 0 |
gst-plugins-ugly | d21017b52a585f145e8d62781bcc1c5fefc7ee37 | NOT_APPLICABLE | NOT_APPLICABLE | gst_asf_demux_get_guid (ASFGuid * guid, guint8 ** p_data, guint64 * p_size)
{
g_assert (*p_size >= 4 * sizeof (guint32));
guid->v1 = gst_asf_demux_get_uint32 (p_data, p_size);
guid->v2 = gst_asf_demux_get_uint32 (p_data, p_size);
guid->v3 = gst_asf_demux_get_uint32 (p_data, p_size);
guid->v4 = gst_asf_demux_get_uint32 (p_data, p_size);
}
| 0 |
sssd | fffdae81651b460f3d2c119c56d5caa09b4de42a | NOT_APPLICABLE | NOT_APPLICABLE | static void krb_reply(struct be_req *req, int dp_err, int result)
{
req->fn(req, dp_err, result, NULL);
} | 0 |
mruby | 778500563a9f7ceba996937dc886bd8cde29b42b | NOT_APPLICABLE | NOT_APPLICABLE | fiber_result(mrb_state *mrb, const mrb_value *a, mrb_int len)
{
if (len == 0) return mrb_nil_value();
if (len == 1) return a[0];
return mrb_ary_new_from_values(mrb, len, a);
}
| 0 |
irssi-proxy | 85bbc05b21678e80423815d2ef1dfe26208491ab | NOT_APPLICABLE | NOT_APPLICABLE | void server_connect_unref(SERVER_CONNECT_REC *conn)
{
g_return_if_fail(IS_SERVER_CONNECT(conn));
if (--conn->refcount > 0)
return;
if (conn->refcount < 0) {
g_warning("Connection '%s' refcount = %d",
conn->tag, conn->refcount);
}
CHAT_PROTOCOL(conn)->destroy_server_connect(conn);
if (conn->connect_handle != NULL)
net_disconnect(conn->connect_handle);
g_free_not_null(conn->proxy);
g_free_not_null(conn->proxy_string);
g_free_not_null(conn->proxy_string_after);
g_free_not_null(conn->proxy_password);
g_free_not_null(conn->tag);
g_free_not_null(conn->address);
g_free_not_null(conn->chatnet);
g_free_not_null(conn->own_ip4);
g_free_not_null(conn->own_ip6);
g_free_not_null(conn->password);
g_free_not_null(conn->nick);
g_free_not_null(conn->username);
g_free_not_null(conn->realname);
g_free_not_null(conn->ssl_cert);
g_free_not_null(conn->ssl_pkey);
g_free_not_null(conn->ssl_cafile);
g_free_not_null(conn->ssl_capath);
g_free_not_null(conn->channels);
g_free_not_null(conn->away_reason);
conn->type = 0;
g_free(conn);
}
| 0 |
ImageMagick | f391a5f4554fe47eb56d6277ac32d1f698572f0e | NOT_APPLICABLE | NOT_APPLICABLE | MagickPrivate void XComponentTerminus(void)
{
DestroyXResources();
} | 0 |
libvirt | 447f69dec47e1b0bd15ecd7cd49a9fd3b050fb87 | NOT_APPLICABLE | NOT_APPLICABLE | static int storageConnectIsEncrypted(virConnectPtr conn G_GNUC_UNUSED)
{
/* Not encrypted, but remote driver takes care of that */
return 0;
} | 0 |
netfilter | c392c159605956c7bd4a264ab4490e2b2704c0cd | NOT_APPLICABLE | NOT_APPLICABLE | ct_build_u8(const struct nf_conntrack *ct, int a, struct nethdr *n, int b)
{
void *ptr = put_header(n, b, sizeof(uint8_t));
memcpy(ptr, nfct_get_attr(ct, a), sizeof(uint8_t));
}
| 0 |
linux | c8c2a057fdc7de1cd16f4baa51425b932a42eb39 | NOT_APPLICABLE | NOT_APPLICABLE | static void mlx5_fpga_conn_post_send(struct mlx5_fpga_conn *conn,
struct mlx5_fpga_dma_buf *buf)
{
struct mlx5_wqe_ctrl_seg *ctrl;
struct mlx5_wqe_data_seg *data;
unsigned int ix, sgi;
int size = 1;
ix = conn->qp.sq.pc & (conn->qp.sq.size - 1);
ctrl = mlx5_wq_cyc_get_wqe(&conn->qp.wq.sq, ix);
data = (void *)(ctrl + 1);
for (sgi = 0; sgi < ARRAY_SIZE(buf->sg); sgi++) {
if (!buf->sg[sgi].data)
break;
data->byte_count = cpu_to_be32(buf->sg[sgi].size);
data->lkey = cpu_to_be32(conn->fdev->conn_res.mkey.key);
data->addr = cpu_to_be64(buf->sg[sgi].dma_addr);
data++;
size++;
}
ctrl->imm = 0;
ctrl->fm_ce_se = MLX5_WQE_CTRL_CQ_UPDATE;
ctrl->opmod_idx_opcode = cpu_to_be32(((conn->qp.sq.pc & 0xffff) << 8) |
MLX5_OPCODE_SEND);
ctrl->qpn_ds = cpu_to_be32(size | (conn->qp.mqp.qpn << 8));
conn->qp.sq.pc++;
conn->qp.sq.bufs[ix] = buf;
mlx5_fpga_conn_notify_hw(conn, ctrl);
} | 0 |
znc | a4a5aeeb17d32937d8c7d743dae9a4cc755ce773 | NOT_APPLICABLE | NOT_APPLICABLE | void CWebSession::UpdateLastActive() { time(&m_tmLastActive); } | 0 |
samba | 94295b7aa22d2544af5323bca70d3dcb97fd7c64 | NOT_APPLICABLE | NOT_APPLICABLE | static void cli_session_setup_gensec_local_next(struct tevent_req *req)
{
struct cli_session_setup_gensec_state *state =
tevent_req_data(req,
struct cli_session_setup_gensec_state);
struct tevent_req *subreq = NULL;
if (state->local_ready) {
tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
return;
}
subreq = gensec_update_send(state, state->ev,
state->auth_generic->gensec_security,
state->blob_in);
if (tevent_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq, cli_session_setup_gensec_local_done, req);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.