processed_func string | target int64 | flaw_line string | flaw_line_index int64 | commit_url string | language class label |
|---|---|---|---|---|---|
PyObject_Calloc(size_t nelem, size_t elsize)
{
/* see PyMem_RawMalloc() */
if (elsize != 0 && nelem > (size_t)PY_SSIZE_T_MAX / elsize)
return NULL;
return _PyObject.calloc(_PyObject.ctx, nelem, elsize);
} | 1 | 0,1,2,3,4,5,6 | -1 | https://github.com/python/typed_ast/commit/156afcb26c198e162504a57caddfe0acd9ed7dce | 0CCPP |
internals.Socket.prototype._authenticate = function () {
const config = this._listener._settings.auth;
if (!config) {
return;
}
if (config.timeout) {
this.auth._timeout = setTimeout(() => this.disconnect(), config.timeout);
}
const cookies = this._ws.upgradeReq.headers.cookie;
if (!cookies) {
return;
}
this._listener._connection.states.parse(cookies, (ignoreErr, state, failed) => {
const auth = state[config.cookie];
if (auth) {
this.auth._error = this._setCredentials(auth.credentials, auth.artifacts);
}
});
}; | 1 | 12 | -1 | https://github.com/hapijs/nes/commit/249ba1755ed6977fbc208463c87364bf884ad655 | 3JavaScript |
public Subscription(string planCode)
{
PlanCode = planCode;
Quantity = 1;
} | 0 | null | -1 | https://github.com/recurly/recurly-client-dotnet/commit/9eef460c0084afd5c24d66220c8b7a381cf9a1f1 | 1CS |
var resizeTypeChanged = function() {
var dialog = this.getDialog(),
resizetype = this.getValue(),
maxSizeBox = dialog.getContentElement('general', 'maxSizeBox').getElement(),
sizeBox = dialog.getContentElement('general', 'sizeBox').getElement();
if (resizetype == 'noresize') {
maxSizeBox.hide();
sizeBox.hide();
} else if (resizetype == "custom") {
maxSizeBox.hide();
sizeBox.show();
} else {
maxSizeBox.show();
sizeBox.hide();
}
}; | 0 | null | -1 | https://github.com/w8tcha/CKEditor-oEmbed-Plugin/commit/10f6169e39510bbf5af913886037044458b9dc9b | 3JavaScript |
pci_get_cfgdata32(struct pci_vdev *dev, int offset)
{
assert(offset <= (PCI_REGMAX - 3) && (offset & 3) == 0);
return (*(uint32_t *)(dev->cfgdata + offset));
} | 1 | 2 | -1 | https://github.com/projectacrn/acrn-hypervisor/commit/2b3dedfb9ba13f15887f22b935d373f36c9a59fa | 0CCPP |
JsVar *jspGetVarNamedField(JsVar *object, JsVar *nameVar, bool returnName) {
JsVar *child = 0;
if (jsvHasChildren(object))
child = jsvFindChildFromVar(object, nameVar, false);
if (!child) {
if (jsvIsArrayBuffer(object) && jsvIsInt(nameVar)) {
child = jsvMakeIntoVariableName(jsvNewFromInteger(jsvGetInteger(nameVar)), object);
if (child)
child->flags = (child->flags & ~JSV_VARTYPEMASK) | JSV_ARRAYBUFFERNAME;
} else if (jsvIsString(object) && jsvIsInt(nameVar)) {
JsVarInt idx = jsvGetInteger(nameVar);
if (idx>=0 && idx<(JsVarInt)jsvGetStringLength(object)) {
char ch = jsvGetCharInString(object, (size_t)idx);
child = jsvNewStringOfLength(1, &ch);
} else if (returnName)
child = jsvCreateNewChild(object, nameVar, 0);
} else {
char name[JSLEX_MAX_TOKEN_LENGTH];
jsvGetString(nameVar, name, JSLEX_MAX_TOKEN_LENGTH);
child = jspGetNamedFieldInParents(object, name, returnName);
if (!child && jsvIsFunction(object) && jsvIsStringEqual(nameVar, JSPARSE_PROTOTYPE_VAR)) {
JsVar *value = jsvNewObject();
child = jsvAddNamedChild(object, value, JSPARSE_PROTOTYPE_VAR);
jsvUnLock(value);
}
}
}
if (returnName) return child;
else return jsvSkipNameAndUnLock(child);
} | 0 | null | -1 | https://github.com/espruino/Espruino/commit/bf4416ab9129ee3afd56739ea4e3cd0da5484b6b | 0CCPP |
public void svgImage(UImageSvg image, double x, double y) {
if (hidden == false) {
final Element elt = (Element) document.createElement("image");
elt.setAttribute("width", format(image.getWidth()));
elt.setAttribute("height", format(image.getHeight()));
elt.setAttribute("x", format(x));
elt.setAttribute("y", format(y));
String svg = manageScale(image);
final String svgHeader = "<svg height=\"" + (int) (image.getHeight() * scale) + "\" width=\""
+ (int) (image.getWidth() * scale) + "\" xmlns=\"http://www.w3.org/2000/svg\" >";
svg = svgHeader + svg.substring(5);
final String s = toBase64(svg);
elt.setAttribute("xlink:href", "data:image/svg+xml;base64," + s);
getG().appendChild(elt);
}
ensureVisible(x, y);
ensureVisible(x + image.getData("width"), y + image.getData("height"));
} | 1 | 8,9 | -1 | https://github.com/plantuml/plantuml/commit/93e5964e5f35914f3f7b89de620c596795550083 | 2Java |
mxCellRenderer.prototype.destroy=function(u){D.apply(this,arguments);null!=u.secondLabel&&(u.secondLabel.destroy(),u.secondLabel=null)};mxCellRenderer.prototype.getShapesForState=function(u){return[u.shape,u.text,u.secondLabel,u.control]};var G=mxGraphView.prototype.resetValidationState;mxGraphView.prototype.resetValidationState=function(){G.apply(this,arguments);this.enumerationState=0};var P=mxGraphView.prototype.stateValidated;mxGraphView.prototype.stateValidated=function(u){null!=u.shape&&this.redrawEnumerationState(u);
return P.apply(this,arguments)};mxGraphView.prototype.createEnumerationValue=function(u){u=decodeURIComponent(mxUtils.getValue(u.style,"enumerateValue",""));""==u&&(u=++this.enumerationState);return'<div style="padding:2px;border:1px solid gray;background:yellow;border-radius:2px;">'+mxUtils.htmlEntities(u)+"</div>"};mxGraphView.prototype.redrawEnumerationState=function(u){var E="1"==mxUtils.getValue(u.style,"enumerate",0);E&&null==u.secondLabel?(u.secondLabel=new mxText("",new mxRectangle,mxConstants.ALIGN_LEFT, | 1 | 0,1 | -1 | https://github.com/jgraph/drawio/commit/4deecee18191f67e242422abf3ca304e19e49687 | 3JavaScript |
static void jpegErrorExit(j_common_ptr cinfo)
{
jpegErrorManager *myerr = (jpegErrorManager *)cinfo->err;
throw LIBRAW_EXCEPTION_DECODE_JPEG;
} | 0 | null | -1 | https://github.com/LibRaw/LibRaw/commit/e47384546b43d0fd536e933249047bc397a4d88b | 0CCPP |
public static CharSequence createOptimized(String value) {
return io.netty.handler.codec.http.HttpHeaders.newEntity(value);
} | 1 | 1 | -1 | https://github.com/eclipse-vertx/vert.x/commit/1bb6445226c39a95e7d07ce3caaf56828e8aab72 | 2Java |
fixHeight : function() {
var w, h;
if (cratio) {
w = width.val();
h = Math.round(w/ratio);
resize.updateView(w, h);
height.val(h);
}
} | 1 | 0,1,2,3,4,5,6,7,8 | -1 | https://github.com/semplon/GeniXCMS/commit/d885eb20006099262c0278932b9f8aca3c1ac97f | 3JavaScript |
EditorUi.prototype.updateCssForMarker=function(a,b,f,d,g){a.style.verticalAlign="top";a.style.height="21px";a.style.width="21px";a.innerHTML="";"flexArrow"==f?a.className=null!=d&&d!=mxConstants.NONE?"geSprite geSprite-"+b+"blocktrans":"geSprite geSprite-noarrow":(f=this.getImageForMarker(d,g),null!=f?(d=document.createElement("img"),d.style.position="absolute",d.style.marginTop="0.5px",d.setAttribute("src",f),a.className="","end"==b&&mxUtils.setPrefixedStyle(d.style,"transform","scaleX(-1)"),Editor.isDarkMode()&&
(d.style.filter="invert(100%)"),a.appendChild(d)):(a.className="geSprite geSprite-noarrow",a.innerHTML=mxUtils.htmlEntities(mxResources.get("none")),a.style.backgroundImage="none",a.style.verticalAlign="top",a.style.marginTop="4px",a.style.fontSize="10px",a.style.filter="none",a.style.color=this.defaultStrokeColor,a.nextSibling.style.marginTop="0px"))}; | 1 | 0 | -1 | https://github.com/jgraph/drawio/commit/3d3f819d7a04da7d53b37cc0ca4269c157ba2825 | 3JavaScript |
static int xar_get_numeric_from_xml_element(xmlTextReaderPtr reader, long * value)
{
const xmlChar * numstr;
if (xmlTextReaderRead(reader) == 1 && xmlTextReaderNodeType(reader) == XML_READER_TYPE_TEXT) {
numstr = xmlTextReaderConstValue(reader);
if (numstr) {
*value = atol((const char *)numstr);
if (*value < 0) {
cli_dbgmsg("cli_scanxar: XML element value %li\n", *value);
return CL_EFORMAT;
}
return CL_SUCCESS;
}
}
cli_dbgmsg("cli_scanxar: No text for XML element\n");
return CL_EFORMAT;
} | 1 | 0,6,7 | -1 | https://github.com/Cisco-Talos/clamav/commit/d96a6b8bcc7439fa7e3876207aa0a8e79c8451b6 | 0CCPP |
snmp_ber_decode_null(unsigned char *buf, uint32_t *buff_len)
{
buf++;
(*buff_len)--;
buf++;
(*buff_len)--;
return buf;
} | 1 | 0,2,3,4,5,6 | -1 | https://github.com/contiki-ng/contiki-ng/commit/12c824386ab60de757de5001974d73b32e19ad71 | 0CCPP |
int lock_flags) __releases(RCU)
{
struct inode *inode = VFS_I(ip);
struct xfs_mount *mp = ip->i_mount;
int error;
spin_lock(&ip->i_flags_lock);
if (ip->i_ino != ino) {
trace_xfs_iget_skip(ip);
XFS_STATS_INC(mp, xs_ig_frecycle);
error = -EAGAIN;
goto out_error;
}
if (ip->i_flags & (XFS_INEW|XFS_IRECLAIM)) {
trace_xfs_iget_skip(ip);
XFS_STATS_INC(mp, xs_ig_frecycle);
error = -EAGAIN;
goto out_error;
}
error = xfs_iget_check_free_state(ip, flags);
if (error)
goto out_error;
if (ip->i_flags & XFS_IRECLAIMABLE) {
trace_xfs_iget_reclaim(ip);
if (flags & XFS_IGET_INCORE) {
error = -EAGAIN;
goto out_error;
}
ip->i_flags |= XFS_IRECLAIM;
spin_unlock(&ip->i_flags_lock);
rcu_read_unlock();
error = xfs_reinit_inode(mp, inode);
if (error) {
bool wake;
rcu_read_lock();
spin_lock(&ip->i_flags_lock);
wake = !!__xfs_iflags_test(ip, XFS_INEW);
ip->i_flags &= ~(XFS_INEW | XFS_IRECLAIM);
if (wake)
wake_up_bit(&ip->i_flags, __XFS_INEW_BIT);
ASSERT(ip->i_flags & XFS_IRECLAIMABLE);
trace_xfs_iget_reclaim_fail(ip);
goto out_error;
}
spin_lock(&pag->pag_ici_lock);
spin_lock(&ip->i_flags_lock);
ip->i_flags &= ~XFS_IRECLAIM_RESET_FLAGS;
ip->i_flags |= XFS_INEW;
xfs_inode_clear_reclaim_tag(pag, ip->i_ino);
inode->i_state = I_NEW;
ASSERT(!rwsem_is_locked(&inode->i_rwsem));
init_rwsem(&inode->i_rwsem);
spin_unlock(&ip->i_flags_lock);
spin_unlock(&pag->pag_ici_lock);
} else {
if (!igrab(inode)) {
trace_xfs_iget_skip(ip);
error = -EAGAIN;
goto out_error;
}
spin_unlock(&ip->i_flags_lock);
rcu_read_unlock();
trace_xfs_iget_hit(ip);
}
if (lock_flags != 0)
xfs_ilock(ip, lock_flags);
if (!(flags & XFS_IGET_INCORE))
xfs_iflags_clear(ip, XFS_ISTALE | XFS_IDONTCACHE);
XFS_STATS_INC(mp, xs_ig_found);
return 0;
out_error:
spin_unlock(&ip->i_flags_lock);
rcu_read_unlock();
return error;
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/afca6c5b2595fc44383919fba740c194b0b76aff | 0CCPP |
App.prototype.updateButtonContainer = function()
{
appUpdateButtonContainer.apply(this, arguments);
if (this.shareButton != null)
{
var elt = this.shareButton;
elt.style.cssText = 'display:inline-block;position:relative;box-sizing:border-box;margin-right:4px;cursor:pointer;';
elt.className = 'geToolbarButton';
elt.innerHTML = '';
elt.style.backgroundImage = 'url(' + Editor.shareImage + ')';
elt.style.backgroundPosition = 'center center';
elt.style.backgroundRepeat = 'no-repeat';
elt.style.backgroundSize = '24px 24px';
elt.style.height = '24px';
elt.style.width = '24px';
if (urlParams['sketch'] == '1')
{
this.shareButton.style.display = 'none';
}
}
if (this.buttonContainer != null)
{
this.buttonContainer.style.marginTop = '-2px';
this.buttonContainer.style.paddingTop = '4px';
}
}; | 1 | 8 | -1 | https://github.com/jgraph/drawio/commit/3d3f819d7a04da7d53b37cc0ca4269c157ba2825 | 3JavaScript |
MONGO_EXPORT int bson_append_binary( bson *b, const char *name, char type, const char *str, int len ) {
if ( type == BSON_BIN_BINARY_OLD ) {
int subtwolen = len + 4;
if ( bson_append_estart( b, BSON_BINDATA, name, 4+1+4+len ) == BSON_ERROR )
return BSON_ERROR;
bson_append32( b, &subtwolen );
bson_append_byte( b, type );
bson_append32( b, &len );
bson_append( b, str, len );
}
else {
if ( bson_append_estart( b, BSON_BINDATA, name, 4+1+len ) == BSON_ERROR )
return BSON_ERROR;
bson_append32( b, &len );
bson_append_byte( b, type );
bson_append( b, str, len );
}
return BSON_OK;
} | 1 | 0,5,7,13 | -1 | https://github.com/10gen-archive/mongo-c-driver-legacy/commit/1a1f5e26a4309480d88598913f9eebf9e9cba8ca | 0CCPP |
struct tcp_conn_t *tcp_conn_accept(struct tcp_sock_t *sock)
{
struct tcp_conn_t *conn = calloc(1, sizeof *conn);
if (conn == NULL) {
ERR("Calloc for connection struct failed");
goto error;
}
conn->sd = accept(sock->sd, NULL, NULL);
if (conn->sd < 0) {
ERR("accept failed");
goto error;
}
return conn;
error:
if (conn != NULL)
free(conn);
return NULL;
} | 1 | 0,7 | -1 | https://github.com/tillkamppeter/ippusbxd/commit/46844402bca7a38fc224483ba6f0a93c4613203f | 0CCPP |
printnonterminals(grammar *g, FILE *fp)
{
dfa *d;
int i;
fprintf(fp, "/*\n");
d = g->g_dfa;
for (i = g->g_ndfas; --i >= 0; d++)
fprintf(fp, "#define %s %d\n", d->d_name, d->d_type);
} | 1 | 0,1,2,3,4,5,6,7,8 | -1 | https://github.com/python/typed_ast/commit/156afcb26c198e162504a57caddfe0acd9ed7dce | 0CCPP |
int read_super_4(squashfs_operations **s_ops)
{
struct squashfs_super_block sBlk_4;
int res = read_fs_bytes(fd, SQUASHFS_START,
sizeof(struct squashfs_super_block), &sBlk_4);
if(res == FALSE)
return res;
swap = sBlk_4.s_magic != SQUASHFS_MAGIC;
SQUASHFS_INSWAP_SUPER_BLOCK(&sBlk_4);
if(sBlk_4.s_magic == SQUASHFS_MAGIC && sBlk_4.s_major == 4 &&
sBlk_4.s_minor == 0) {
*s_ops = &ops;
memcpy(&sBlk, &sBlk_4, sizeof(sBlk_4));
comp = lookup_compressor_id(sBlk.s.compression);
return TRUE;
}
return -1;
} | 0 | null | -1 | https://github.com/plougher/squashfs-tools/commit/e0485802ec72996c20026da320650d8362f555bd | 0CCPP |
vips_tracked_malloc( size_t size )
{
void *buf;
vips_tracked_init();
size += 16;
if( !(buf = g_try_malloc( size )) ) {
#ifdef DEBUG
g_assert_not_reached();
#endif
vips_error( "vips_tracked",
_( "out of memory --- size == %dMB" ),
(int) (size / (1024.0 * 1024.0)) );
g_warning( _( "out of memory --- size == %dMB" ),
(int) (size / (1024.0 * 1024.0)) );
return( NULL );
}
g_mutex_lock( vips_tracked_mutex );
*((size_t *)buf) = size;
buf = (void *) ((char *)buf + 16);
vips_tracked_mem += size;
if( vips_tracked_mem > vips_tracked_mem_highwater )
vips_tracked_mem_highwater = vips_tracked_mem;
vips_tracked_allocs += 1;
#ifdef DEBUG_VERBOSE
printf( "vips_tracked_malloc: %p, %zd bytes\n", buf, size );
#endif
g_mutex_unlock( vips_tracked_mutex );
VIPS_GATE_MALLOC( size );
return( buf );
} | 1 | 5 | -1 | https://github.com/libvips/libvips/commit/00622428bda8d7521db8d74260b519fa41d69d0a | 0CCPP |
void cil_destroy_condblock(struct cil_condblock *cb)
{
if (cb == NULL) {
return;
}
cil_symtab_array_destroy(cb->symtab);
free(cb);
} | 0 | null | -1 | https://github.com/SELinuxProject/selinux/commit/340f0eb7f3673e8aacaf0a96cbfcd4d12a405521 | 0CCPP |
static noinline int join_transaction(struct btrfs_fs_info *fs_info,
unsigned int type)
{
struct btrfs_transaction *cur_trans;
spin_lock(&fs_info->trans_lock);
loop:
if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
spin_unlock(&fs_info->trans_lock);
return -EROFS;
}
cur_trans = fs_info->running_transaction;
if (cur_trans) {
if (TRANS_ABORTED(cur_trans)) {
spin_unlock(&fs_info->trans_lock);
return cur_trans->aborted;
}
if (btrfs_blocked_trans_types[cur_trans->state] & type) {
spin_unlock(&fs_info->trans_lock);
return -EBUSY;
}
refcount_inc(&cur_trans->use_count);
atomic_inc(&cur_trans->num_writers);
extwriter_counter_inc(cur_trans, type);
spin_unlock(&fs_info->trans_lock);
return 0;
}
spin_unlock(&fs_info->trans_lock);
if (type == TRANS_ATTACH)
return -ENOENT;
BUG_ON(type == TRANS_JOIN_NOLOCK);
cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS);
if (!cur_trans)
return -ENOMEM;
spin_lock(&fs_info->trans_lock);
if (fs_info->running_transaction) {
kfree(cur_trans);
goto loop;
} else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
spin_unlock(&fs_info->trans_lock);
kfree(cur_trans);
return -EROFS;
}
cur_trans->fs_info = fs_info;
atomic_set(&cur_trans->pending_ordered, 0);
init_waitqueue_head(&cur_trans->pending_wait);
atomic_set(&cur_trans->num_writers, 1);
extwriter_counter_init(cur_trans, type);
init_waitqueue_head(&cur_trans->writer_wait);
init_waitqueue_head(&cur_trans->commit_wait);
cur_trans->state = TRANS_STATE_RUNNING;
refcount_set(&cur_trans->use_count, 2);
cur_trans->flags = 0;
cur_trans->start_time = ktime_get_seconds();
memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs));
cur_trans->delayed_refs.href_root = RB_ROOT_CACHED;
cur_trans->delayed_refs.dirty_extent_root = RB_ROOT;
atomic_set(&cur_trans->delayed_refs.num_entries, 0);
smp_mb();
if (!list_empty(&fs_info->tree_mod_seq_list))
WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n");
if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n");
atomic64_set(&fs_info->tree_mod_seq, 0);
spin_lock_init(&cur_trans->delayed_refs.lock);
INIT_LIST_HEAD(&cur_trans->pending_snapshots);
INIT_LIST_HEAD(&cur_trans->dev_update_list);
INIT_LIST_HEAD(&cur_trans->switch_commits);
INIT_LIST_HEAD(&cur_trans->dirty_bgs);
INIT_LIST_HEAD(&cur_trans->io_bgs);
INIT_LIST_HEAD(&cur_trans->dropped_roots);
mutex_init(&cur_trans->cache_write_mutex);
spin_lock_init(&cur_trans->dirty_bgs_lock);
INIT_LIST_HEAD(&cur_trans->deleted_bgs);
spin_lock_init(&cur_trans->dropped_roots_lock);
INIT_LIST_HEAD(&cur_trans->releasing_ebs);
spin_lock_init(&cur_trans->releasing_ebs_lock);
atomic64_set(&cur_trans->chunk_bytes_reserved, 0);
init_waitqueue_head(&cur_trans->chunk_reserve_wait);
list_add_tail(&cur_trans->list, &fs_info->trans_list);
extent_io_tree_init(fs_info, &cur_trans->dirty_pages,
IO_TREE_TRANS_DIRTY_PAGES, fs_info->btree_inode);
extent_io_tree_init(fs_info, &cur_trans->pinned_extents,
IO_TREE_FS_PINNED_EXTENTS, NULL);
fs_info->generation++;
cur_trans->transid = fs_info->generation;
fs_info->running_transaction = cur_trans;
cur_trans->aborted = 0;
spin_unlock(&fs_info->trans_lock);
return 0;
} | 1 | 76,77 | -1 | https://github.com/torvalds/linux/commit/1cb3db1cf383a3c7dbda1aa0ce748b0958759947 | 0CCPP |
int ff_mov_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MOVMuxContext *mov = s->priv_data;
AVIOContext *pb = s->pb;
MOVTrack *trk = &mov->tracks[pkt->stream_index];
AVCodecParameters *par = trk->par;
unsigned int samples_in_chunk = 0;
int size = pkt->size, ret = 0;
uint8_t *reformatted_data = NULL;
ret = check_pkt(s, pkt);
if (ret < 0)
return ret;
if (mov->flags & FF_MOV_FLAG_FRAGMENT) {
int ret;
if (mov->moov_written || mov->flags & FF_MOV_FLAG_EMPTY_MOOV) {
if (mov->frag_interleave && mov->fragments > 0) {
if (trk->entry - trk->entries_flushed >= mov->frag_interleave) {
if ((ret = mov_flush_fragment_interleaving(s, trk)) < 0)
return ret;
}
}
if (!trk->mdat_buf) {
if ((ret = avio_open_dyn_buf(&trk->mdat_buf)) < 0)
return ret;
}
pb = trk->mdat_buf;
} else {
if (!mov->mdat_buf) {
if ((ret = avio_open_dyn_buf(&mov->mdat_buf)) < 0)
return ret;
}
pb = mov->mdat_buf;
}
}
if (par->codec_id == AV_CODEC_ID_AMR_NB) {
static const uint16_t packed_size[16] =
{13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 1};
int len = 0;
while (len < size && samples_in_chunk < 100) {
len += packed_size[(pkt->data[len] >> 3) & 0x0F];
samples_in_chunk++;
}
if (samples_in_chunk > 1) {
av_log(s, AV_LOG_ERROR, "fatal error, input is not a single packet, implement a AVParser for it\n");
return -1;
}
} else if (par->codec_id == AV_CODEC_ID_ADPCM_MS ||
par->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
samples_in_chunk = trk->par->frame_size;
} else if (trk->sample_size)
samples_in_chunk = size / trk->sample_size;
else
samples_in_chunk = 1;
if (trk->vos_len == 0 && par->extradata_size > 0 &&
!TAG_IS_AVCI(trk->tag) &&
(par->codec_id != AV_CODEC_ID_DNXHD)) {
trk->vos_len = par->extradata_size;
trk->vos_data = av_malloc(trk->vos_len);
if (!trk->vos_data) {
ret = AVERROR(ENOMEM);
goto err;
}
memcpy(trk->vos_data, par->extradata, trk->vos_len);
}
if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
(AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
if (!s->streams[pkt->stream_index]->nb_frames) {
av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
"use the audio bitstream filter 'aac_adtstoasc' to fix it "
"('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
return -1;
}
av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
}
if (par->codec_id == AV_CODEC_ID_H264 && trk->vos_len > 0 && *(uint8_t *)trk->vos_data != 1 && !TAG_IS_AVCI(trk->tag)) {
if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) {
ff_avc_parse_nal_units_buf(pkt->data, &reformatted_data,
&size);
avio_write(pb, reformatted_data, size);
} else {
if (trk->cenc.aes_ctr) {
size = ff_mov_cenc_avc_parse_nal_units(&trk->cenc, pb, pkt->data, size);
if (size < 0) {
ret = size;
goto err;
}
} else {
size = ff_avc_parse_nal_units(pb, pkt->data, pkt->size);
}
}
} else if (par->codec_id == AV_CODEC_ID_HEVC && trk->vos_len > 6 &&
(AV_RB24(trk->vos_data) == 1 || AV_RB32(trk->vos_data) == 1)) {
if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) {
ff_hevc_annexb2mp4_buf(pkt->data, &reformatted_data, &size, 0, NULL);
avio_write(pb, reformatted_data, size);
} else {
size = ff_hevc_annexb2mp4(pb, pkt->data, pkt->size, 0, NULL);
}
#if CONFIG_AC3_PARSER
} else if (par->codec_id == AV_CODEC_ID_EAC3) {
size = handle_eac3(mov, pkt, trk);
if (size < 0)
return size;
else if (!size)
goto end;
avio_write(pb, pkt->data, size);
#endif
} else {
if (trk->cenc.aes_ctr) {
if (par->codec_id == AV_CODEC_ID_H264 && par->extradata_size > 4) {
int nal_size_length = (par->extradata[4] & 0x3) + 1;
ret = ff_mov_cenc_avc_write_nal_units(s, &trk->cenc, nal_size_length, pb, pkt->data, size);
} else {
ret = ff_mov_cenc_write_packet(&trk->cenc, pb, pkt->data, size);
}
if (ret) {
goto err;
}
} else {
avio_write(pb, pkt->data, size);
}
}
if ((par->codec_id == AV_CODEC_ID_DNXHD ||
par->codec_id == AV_CODEC_ID_AC3) && !trk->vos_len) {
trk->vos_len = size;
trk->vos_data = av_malloc(size);
if (!trk->vos_data) {
ret = AVERROR(ENOMEM);
goto err;
}
memcpy(trk->vos_data, pkt->data, size);
}
if (trk->entry >= trk->cluster_capacity) {
unsigned new_capacity = 2 * (trk->entry + MOV_INDEX_CLUSTER_SIZE);
if (av_reallocp_array(&trk->cluster, new_capacity,
sizeof(*trk->cluster))) {
ret = AVERROR(ENOMEM);
goto err;
}
trk->cluster_capacity = new_capacity;
}
trk->cluster[trk->entry].pos = avio_tell(pb) - size;
trk->cluster[trk->entry].samples_in_chunk = samples_in_chunk;
trk->cluster[trk->entry].chunkNum = 0;
trk->cluster[trk->entry].size = size;
trk->cluster[trk->entry].entries = samples_in_chunk;
trk->cluster[trk->entry].dts = pkt->dts;
trk->cluster[trk->entry].pts = pkt->pts;
if (!trk->entry && trk->start_dts != AV_NOPTS_VALUE) {
if (!trk->frag_discont) {
trk->cluster[trk->entry].dts = trk->start_dts + trk->track_duration;
if ((mov->flags & FF_MOV_FLAG_DASH && !(mov->flags & FF_MOV_FLAG_GLOBAL_SIDX)) ||
mov->mode == MODE_ISM)
pkt->pts = pkt->dts + trk->end_pts - trk->cluster[trk->entry].dts;
} else {
trk->frag_start = pkt->dts - trk->start_dts;
trk->end_pts = AV_NOPTS_VALUE;
trk->frag_discont = 0;
}
}
if (!trk->entry && trk->start_dts == AV_NOPTS_VALUE && !mov->use_editlist &&
s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO) {
trk->cluster[trk->entry].dts = trk->start_dts = 0;
}
if (trk->start_dts == AV_NOPTS_VALUE) {
trk->start_dts = pkt->dts;
if (trk->frag_discont) {
if (mov->use_editlist) {
trk->frag_start = pkt->pts;
trk->start_dts = pkt->dts - pkt->pts;
} else {
trk->frag_start = pkt->dts;
trk->start_dts = 0;
}
trk->frag_discont = 0;
} else if (pkt->dts && mov->moov_written)
av_log(s, AV_LOG_WARNING,
"Track %d starts with a nonzero dts %"PRId64", while the moov "
"already has been written. Set the delay_moov flag to handle "
"this case.\n",
pkt->stream_index, pkt->dts);
}
trk->track_duration = pkt->dts - trk->start_dts + pkt->duration;
trk->last_sample_is_subtitle_end = 0;
if (pkt->pts == AV_NOPTS_VALUE) {
av_log(s, AV_LOG_WARNING, "pts has no value\n");
pkt->pts = pkt->dts;
}
if (pkt->dts != pkt->pts)
trk->flags |= MOV_TRACK_CTTS;
trk->cluster[trk->entry].cts = pkt->pts - pkt->dts;
trk->cluster[trk->entry].flags = 0;
if (trk->start_cts == AV_NOPTS_VALUE)
trk->start_cts = pkt->pts - pkt->dts;
if (trk->end_pts == AV_NOPTS_VALUE)
trk->end_pts = trk->cluster[trk->entry].dts +
trk->cluster[trk->entry].cts + pkt->duration;
else
trk->end_pts = FFMAX(trk->end_pts, trk->cluster[trk->entry].dts +
trk->cluster[trk->entry].cts +
pkt->duration);
if (par->codec_id == AV_CODEC_ID_VC1) {
mov_parse_vc1_frame(pkt, trk);
} else if (pkt->flags & AV_PKT_FLAG_KEY) {
if (mov->mode == MODE_MOV && par->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
trk->entry > 0) {
mov_parse_mpeg2_frame(pkt, &trk->cluster[trk->entry].flags);
if (trk->cluster[trk->entry].flags & MOV_PARTIAL_SYNC_SAMPLE)
trk->flags |= MOV_TRACK_STPS;
} else {
trk->cluster[trk->entry].flags = MOV_SYNC_SAMPLE;
}
if (trk->cluster[trk->entry].flags & MOV_SYNC_SAMPLE)
trk->has_keyframes++;
}
if (pkt->flags & AV_PKT_FLAG_DISPOSABLE) {
trk->cluster[trk->entry].flags |= MOV_DISPOSABLE_SAMPLE;
trk->has_disposable++;
}
trk->entry++;
trk->sample_count += samples_in_chunk;
mov->mdat_size += size;
if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams)
ff_mov_add_hinted_packet(s, pkt, trk->hint_track, trk->entry,
reformatted_data, size);
end:
err:
av_free(reformatted_data);
return ret;
} | 1 | null | -1 | https://github.com/FFmpeg/FFmpeg/commit/3a2d21bc5f97aa0161db3ae731fc2732be6108b8 | 0CCPP |
function isBasic (b) {
return 'string' === typeof b || 'number' === typeof b
} | 0 | null | -1 | https://github.com/dominictarr/libnested/commit/c1129865d75fbe52b5a4f755ad3110ca5420f2e1 | 3JavaScript |
function AnsiUp() {
this.VERSION = "4.0.3";
this.setup_palettes();
this._use_classes = false;
this._escape_for_html = true;
this.bold = false;
this.fg = this.bg = null;
this._buffer = '';
this._url_whitelist = { 'http': 1, 'https': 1 };
} | 1 | 1,4 | -1 | https://github.com/drudru/ansi_up/commit/c8c726ed1db979bae4f257b7fa41775155ba2e27 | 3JavaScript |
def certificate_get_all_by_project(context, project_id):
return (
model_query(context, models.Certificate, read_deleted="no")
.filter_by(project_id=project_id)
.all()
)
| 0 | null | -1 | https://github.com/openstack/nova.git/commit/1f644d210557b1254f7c7b39424b09a45329ade7 | 4Python |
public TList readListBegin() throws TException {
return new TList(readByte(), readI32());
} | 1 | 1 | -1 | https://github.com/facebook/fbthrift/commit/71c97ffdcb61cccf1f8267774e873e21ebd3ebd3 | 2Java |
static void aesni_xts_enc8(void *ctx, u128 *dst, const u128 *src, le128 *iv)
{
aesni_xts_crypt8(ctx, (u8 *)dst, (const u8 *)src, true, (u8 *)iv);
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/5d26a105b5a73e5635eae0629b42fa0a90e07b7b | 0CCPP |
static int ip_vs_info_open(struct inode *inode, struct file *file)
{
return seq_open_net(inode, file, &ip_vs_info_seq_ops,
sizeof(struct ip_vs_iter));
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/2d8a041b7bfe1097af21441cb77d6af95f4f4680 | 0CCPP |
static void ttm_put_pages(struct page **pages, unsigned npages, int flags,
enum ttm_caching_state cstate)
{
struct ttm_page_pool *pool = ttm_get_pool(flags, false, cstate);
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
struct ttm_page_pool *huge = ttm_get_pool(flags, true, cstate);
#endif
unsigned long irq_flags;
unsigned i;
if (pool == NULL) {
i = 0;
while (i < npages) {
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
struct page *p = pages[i];
#endif
unsigned order = 0, j;
if (!pages[i]) {
++i;
continue;
}
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
if (!(flags & TTM_PAGE_FLAG_DMA32) &&
(npages - i) >= HPAGE_PMD_NR) {
for (j = 1; j < HPAGE_PMD_NR; ++j)
if (p++ != pages[i + j])
break;
if (j == HPAGE_PMD_NR)
order = HPAGE_PMD_ORDER;
}
#endif
if (page_count(pages[i]) != 1)
pr_err("Erroneous page count. Leaking pages.\n");
__free_pages(pages[i], order);
j = 1 << order;
while (j) {
pages[i++] = NULL;
--j;
}
}
return;
}
i = 0;
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
if (huge) {
unsigned max_size, n2free;
spin_lock_irqsave(&huge->lock, irq_flags);
while ((npages - i) >= HPAGE_PMD_NR) {
struct page *p = pages[i];
unsigned j;
if (!p)
break;
for (j = 1; j < HPAGE_PMD_NR; ++j)
if (p++ != pages[i + j])
break;
if (j != HPAGE_PMD_NR)
break;
list_add_tail(&pages[i]->lru, &huge->list);
for (j = 0; j < HPAGE_PMD_NR; ++j)
pages[i++] = NULL;
huge->npages++;
}
max_size = _manager->options.max_size;
max_size /= HPAGE_PMD_NR;
if (huge->npages > max_size)
n2free = huge->npages - max_size;
else
n2free = 0;
spin_unlock_irqrestore(&huge->lock, irq_flags);
if (n2free)
ttm_page_pool_free(huge, n2free, false);
}
#endif
spin_lock_irqsave(&pool->lock, irq_flags);
while (i < npages) {
if (pages[i]) {
if (page_count(pages[i]) != 1)
pr_err("Erroneous page count. Leaking pages.\n");
list_add_tail(&pages[i]->lru, &pool->list);
pages[i] = NULL;
pool->npages++;
}
++i;
}
npages = 0;
if (pool->npages > _manager->options.max_size) {
npages = pool->npages - _manager->options.max_size;
if (npages < NUM_PAGES_TO_ALLOC)
npages = NUM_PAGES_TO_ALLOC;
}
spin_unlock_irqrestore(&pool->lock, irq_flags);
if (npages)
ttm_page_pool_free(pool, npages, false);
} | 1 | 24,52 | -1 | https://github.com/torvalds/linux/commit/453393369dc9806d2455151e329c599684762428 | 0CCPP |
unsigned lodepng_palette_add(LodePNGColorMode* info,
unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
unsigned char* data;
if(!info->palette)
{
data = (unsigned char*)realloc(info->palette, 1024);
if(!data) return 83;
else info->palette = data;
}
info->palette[4 * info->palettesize + 0] = r;
info->palette[4 * info->palettesize + 1] = g;
info->palette[4 * info->palettesize + 2] = b;
info->palette[4 * info->palettesize + 3] = a;
info->palettesize++;
return 0;
} | 0 | null | -1 | https://github.com/FreeRDP/FreeRDP/commit/9fee4ae076b1ec97b97efb79ece08d1dab4df29a | 0CCPP |
const FieldID& activeUnionMemberId(const void* object, ptrdiff_t offset) {
return *reinterpret_cast<const FieldID*>(
offset + static_cast<const char*>(object));
} | 1 | 0,1,2 | -1 | https://github.com/facebook/fbthrift/commit/bfda1efa547dce11a38592820916db01b05b9339 | 0CCPP |
void Compute(OpKernelContext* ctx) override {
const Tensor& input = ctx->input(0);
const Tensor& input_min_tensor = ctx->input(1);
const Tensor& input_max_tensor = ctx->input(2);
int num_slices = 1;
if (axis_ > -1) {
num_slices = input.dim_size(axis_);
}
Tensor* output = nullptr;
OP_REQUIRES_OK(ctx, ctx->allocate_output(0, input.shape(), &output));
Tensor float_output =
need_cast_ ? tensorflow::Tensor(DT_FLOAT, input.shape()) : *output;
if (num_slices == 1) {
const float min_range = input_min_tensor.flat<float>()(0);
const float max_range = input_max_tensor.flat<float>()(0);
DequantizeTensor(ctx, input, min_range, max_range, &float_output);
} else {
OP_REQUIRES(ctx, mode_ != QUANTIZE_MODE_MIN_FIRST,
errors::Unimplemented("MIN_FIRST mode is not implemented for "
"Dequantize with axis != -1."));
int64 pre_dim = 1, post_dim = 1;
for (int i = 0; i < axis_; ++i) {
pre_dim *= float_output.dim_size(i);
}
for (int i = axis_ + 1; i < float_output.dims(); ++i) {
post_dim *= float_output.dim_size(i);
}
auto input_tensor = input.template bit_casted_shaped<T, 3>(
{pre_dim, num_slices, post_dim});
auto output_tensor =
float_output.flat_inner_outer_dims<float, 3>(axis_ - 1);
auto min_ranges = input_min_tensor.vec<float>();
auto max_ranges = input_max_tensor.vec<float>();
for (int i = 0; i < num_slices; ++i) {
DequantizeSlice(ctx->eigen_device<Device>(), ctx,
input_tensor.template chip<1>(i), min_ranges(i),
max_ranges(i), output_tensor.template chip<1>(i));
}
}
if (need_cast_) {
S* out_ptr = output->flat<S>().data();
float* in_ptr = float_output.flat<float>().data();
for (int64 i = 0; i < float_output.NumElements(); ++i) {
out_ptr[i] = static_cast<S>(in_ptr[i]);
}
}
} | 1 | null | -1 | https://github.com/tensorflow/tensorflow/commit/5899741d0421391ca878da47907b1452f06aaf1b | 0CCPP |
clear:function(a){"object"!==typeof a&&"function"!==typeof a||delete a[mxObjectIdentity.FIELD_NAME]}};function mxDictionary(){this.clear()}mxDictionary.prototype.map=null;mxDictionary.prototype.clear=function(){this.map={}};mxDictionary.prototype.get=function(a){a=mxObjectIdentity.get(a);return this.map[a]};mxDictionary.prototype.put=function(a,b){a=mxObjectIdentity.get(a);var c=this.map[a];this.map[a]=b;return c}; | 0 | null | -1 | https://github.com/jgraph/drawio/commit/c63f3a04450f30798df47f9badbc74eb8a69fbdf | 3JavaScript |
size_t compile_tree(struct filter_op **fop)
{
int i = 1;
struct filter_op *array = NULL;
struct unfold_elm *ue;
BUG_IF(tree_root == NULL);
fprintf(stdout, " Unfolding the meta-tree ");
fflush(stdout);
unfold_blk(&tree_root);
fprintf(stdout, " done.\n\n");
labels_to_offsets();
TAILQ_FOREACH(ue, &unfolded_tree, next) {
if (ue->label == 0) {
SAFE_REALLOC(array, i * sizeof(struct filter_op));
memcpy(&array[i - 1], &ue->fop, sizeof(struct filter_op));
i++;
}
}
SAFE_REALLOC(array, i * sizeof(struct filter_op));
array[i - 1].opcode = FOP_EXIT;
*fop = array;
return (i);
} | 1 | 5 | -1 | https://github.com/LocutusOfBorg/ettercap/commit/626dc56686f15f2dda13c48f78c2a666cb6d8506 | 0CCPP |
App.prototype.fileCreated=function(b,f,l,d,u){var t=window.location.pathname;null!=f&&0<f.length&&(t+="?libs="+f);null!=u&&0<u.length&&(t+="?clibs="+u);t=this.getUrl(t);b.getMode()!=App.MODE_DEVICE&&(t+="#"+b.getHash());if(this.spinner.spin(document.body,mxResources.get("inserting"))){var D=b.getData();D=0<D.length?this.editor.extractGraphModel(mxUtils.parseXml(D).documentElement,!0):null;var c=window.location.protocol+"//"+window.location.hostname+t,e=D,g=null;null!=D&&/\.svg$/i.test(b.getTitle())&&
(g=this.createTemporaryGraph(this.editor.graph.getStylesheet()),document.body.appendChild(g.container),e=this.decodeNodeIntoGraph(e,g));b.setData(this.createFileData(D,g,b,c));null!=g&&g.container.parentNode.removeChild(g.container);var k=mxUtils.bind(this,function(){this.spinner.stop()}),m=mxUtils.bind(this,function(){k();var q=this.getCurrentFile();null==l&&null!=q&&(l=!q.isModified()&&null==q.getMode());var v=mxUtils.bind(this,function(){window.openFile=null;this.fileLoaded(b);l&&b.addAllSavedStatus();
null!=f&&this.sidebar.showEntries(f);if(null!=u){for(var A=[],z=u.split(";"),L=0;L<z.length;L++)A.push(decodeURIComponent(z[L]));this.loadLibraries(A)}}),x=mxUtils.bind(this,function(){l||null==q||!q.isModified()?v():this.confirm(mxResources.get("allChangesLost"),null,v,mxResources.get("cancel"),mxResources.get("discardChanges"))});null!=d&&d();null==l||l?x():(b.constructor==LocalFile&&(window.openFile=new OpenFile(function(){window.openFile=null}),window.openFile.setData(b.getData(),b.getTitle(),
null==b.getMode())),null!=d&&d(),window.openWindow(t,null,x))});b.constructor==LocalFile?m():b.saveFile(b.getTitle(),!1,mxUtils.bind(this,function(){m()}),mxUtils.bind(this,function(q){k();null!=q&&"AbortError"==q.name||this.handleError(q)}))}}; | 1 | 2,3 | -1 | https://github.com/jgraph/drawio/commit/4deecee18191f67e242422abf3ca304e19e49687 | 3JavaScript |
static OPJ_BOOL opj_j2k_compare_qcc(opj_j2k_t *p_j2k,
OPJ_UINT32 p_first_comp_no, OPJ_UINT32 p_second_comp_no)
{
return opj_j2k_compare_SQcd_SQcc(p_j2k, p_j2k->m_current_tile_number,
p_first_comp_no, p_second_comp_no);
} | 0 | null | -1 | https://github.com/uclouvain/openjpeg/commit/c535531f03369623b9b833ef41952c62257b507e | 0CCPP |
function onEOF() {
ending = true;
self.emit('eof');
self.emit('end');
} | 1 | 0,1,2,3,4 | -1 | https://github.com/mscdex/ssh2/commit/f763271f41320e71d5cbee02ea5bc6a2ded3ca21 | 3JavaScript |
static PyObject* ast2obj_int(long b)
{
return PyLong_FromLong(b);
} | 0 | null | -1 | https://github.com/python/typed_ast/commit/156afcb26c198e162504a57caddfe0acd9ed7dce | 0CCPP |
void LosslessScan::ParseMCU(struct Line **prev,struct Line **top)
{
#if ACCUSOFT_CODE
UBYTE i;
for(i = 0;i < m_ucCount;i++) {
class HuffmanDecoder *dc = m_pDCDecoder[i];
struct Line *line = top[i];
struct Line *pline= prev[i];
UBYTE ym = m_ucMCUHeight[i];
class PredictorBase *mcupred = m_pPredict[i];
LONG *lp = line->m_pData + m_ulX[i];
LONG *pp = (pline)?(pline->m_pData + m_ulX[i]):(NULL);
do {
class PredictorBase *pred = mcupred;
UBYTE xm = m_ucMCUWidth[i];
do {
LONG v;
UBYTE symbol = dc->Get(&m_Stream);
if (symbol == 0) {
v = 0;
} else if (symbol == 16) {
v = -32768;
} else {
LONG thre = 1L << (symbol - 1);
LONG diff = m_Stream.Get(symbol);
if (diff < thre) {
diff += (-1L << symbol) + 1;
}
v = diff;
}
lp[0] = pred->DecodeSample(v,lp,pp);
} while(--xm && (lp++,pp++,pred = pred->MoveRight(),true));
} while(--ym && (pp = line->m_pData + m_ulX[i],line = (line->m_pNext)?(line->m_pNext):(line),
lp = line->m_pData + m_ulX[i],mcupred = mcupred->MoveDown(),true));
}
#else
NOREF(prev);
NOREF(top);
#endif
} | 1 | null | -1 | https://github.com/thorfdbg/libjpeg/commit/ef4a29a62ab48b8dc235f4af52cfd6319eda9a6a | 0CCPP |
def sm_volume_delete(context, volume_id):
session = get_session()
with session.begin():
_sm_volume_get_query(context, volume_id, session=session).delete()
| 0 | null | -1 | https://github.com/openstack/nova.git/commit/1f644d210557b1254f7c7b39424b09a45329ade7 | 4Python |
_PyObject_Alloc(int use_calloc, void *ctx, size_t nelem, size_t elsize)
{
size_t nbytes;
block *bp;
poolp pool;
poolp next;
uint size;
_Py_AllocatedBlocks++;
assert(nelem <= PY_SSIZE_T_MAX / elsize);
nbytes = nelem * elsize;
#ifdef WITH_VALGRIND
if (UNLIKELY(running_on_valgrind == -1))
running_on_valgrind = RUNNING_ON_VALGRIND;
if (UNLIKELY(running_on_valgrind))
goto redirect;
#endif
if (nelem == 0 || elsize == 0)
goto redirect;
if ((nbytes - 1) < SMALL_REQUEST_THRESHOLD) {
LOCK();
/*
* Most frequent paths first
*/
size = (uint)(nbytes - 1) >> ALIGNMENT_SHIFT;
pool = usedpools[size + size];
if (pool != pool->nextpool) {
/*
* There is a used pool for this size class.
* Pick up the head block of its free list.
*/
++pool->ref.count;
bp = pool->freeblock;
assert(bp != NULL);
if ((pool->freeblock = *(block **)bp) != NULL) {
UNLOCK();
if (use_calloc)
memset(bp, 0, nbytes);
return (void *)bp;
}
/*
* Reached the end of the free list, try to extend it.
*/
if (pool->nextoffset <= pool->maxnextoffset) {
/* There is room for another block. */
pool->freeblock = (block*)pool +
pool->nextoffset;
pool->nextoffset += INDEX2SIZE(size);
*(block **)(pool->freeblock) = NULL;
UNLOCK();
if (use_calloc)
memset(bp, 0, nbytes);
return (void *)bp;
}
/* Pool is full, unlink from used pools. */
next = pool->nextpool;
pool = pool->prevpool;
next->prevpool = pool;
pool->nextpool = next;
UNLOCK();
if (use_calloc)
memset(bp, 0, nbytes);
return (void *)bp;
}
/* There isn't a pool of the right size class immediately
* available: use a free pool.
*/
if (usable_arenas == NULL) {
/* No arena has a free pool: allocate a new arena. */
#ifdef WITH_MEMORY_LIMITS
if (narenas_currently_allocated >= MAX_ARENAS) {
UNLOCK();
goto redirect;
}
#endif
usable_arenas = new_arena();
if (usable_arenas == NULL) {
UNLOCK();
goto redirect;
}
usable_arenas->nextarena =
usable_arenas->prevarena = NULL;
}
assert(usable_arenas->address != 0);
/* Try to get a cached free pool. */
pool = usable_arenas->freepools;
if (pool != NULL) {
/* Unlink from cached pools. */
usable_arenas->freepools = pool->nextpool;
/* This arena already had the smallest nfreepools
* value, so decreasing nfreepools doesn't change
* that, and we don't need to rearrange the
* usable_arenas list. However, if the arena has
* become wholly allocated, we need to remove its
* arena_object from usable_arenas.
*/
--usable_arenas->nfreepools;
if (usable_arenas->nfreepools == 0) {
/* Wholly allocated: remove. */
assert(usable_arenas->freepools == NULL);
assert(usable_arenas->nextarena == NULL ||
usable_arenas->nextarena->prevarena ==
usable_arenas);
usable_arenas = usable_arenas->nextarena;
if (usable_arenas != NULL) {
usable_arenas->prevarena = NULL;
assert(usable_arenas->address != 0);
}
}
else {
/* nfreepools > 0: it must be that freepools
* isn't NULL, or that we haven't yet carved
* off all the arena's pools for the first
* time.
*/
assert(usable_arenas->freepools != NULL ||
usable_arenas->pool_address <=
(block*)usable_arenas->address +
ARENA_SIZE - POOL_SIZE);
}
init_pool:
/* Frontlink to used pools. */
next = usedpools[size + size]; /*
pool->nextpool = next;
pool->prevpool = next;
next->nextpool = pool;
next->prevpool = pool;
pool->ref.count = 1;
if (pool->szidx == size) {
/* Luckily, this pool last contained blocks
* of the same size class, so its header
* and free list are already initialized.
*/
bp = pool->freeblock;
assert(bp != NULL);
pool->freeblock = *(block **)bp;
UNLOCK();
if (use_calloc)
memset(bp, 0, nbytes);
return (void *)bp;
}
/*
* Initialize the pool header, set up the free list to
* contain just the second block, and return the first
* block.
*/
pool->szidx = size;
size = INDEX2SIZE(size);
bp = (block *)pool + POOL_OVERHEAD;
pool->nextoffset = POOL_OVERHEAD + (size << 1);
pool->maxnextoffset = POOL_SIZE - size;
pool->freeblock = bp + size;
*(block **)(pool->freeblock) = NULL;
UNLOCK();
if (use_calloc)
memset(bp, 0, nbytes);
return (void *)bp;
}
/* Carve off a new pool. */
assert(usable_arenas->nfreepools > 0);
assert(usable_arenas->freepools == NULL);
pool = (poolp)usable_arenas->pool_address;
assert((block*)pool <= (block*)usable_arenas->address +
ARENA_SIZE - POOL_SIZE);
pool->arenaindex = (uint)(usable_arenas - arenas);
assert(&arenas[pool->arenaindex] == usable_arenas);
pool->szidx = DUMMY_SIZE_IDX;
usable_arenas->pool_address += POOL_SIZE;
--usable_arenas->nfreepools;
if (usable_arenas->nfreepools == 0) {
assert(usable_arenas->nextarena == NULL ||
usable_arenas->nextarena->prevarena ==
usable_arenas);
/* Unlink the arena: it is completely allocated. */
usable_arenas = usable_arenas->nextarena;
if (usable_arenas != NULL) {
usable_arenas->prevarena = NULL;
assert(usable_arenas->address != 0);
}
}
goto init_pool;
}
/* The small block allocator ends here. */
redirect:
/* Redirect the original request to the underlying (libc) allocator.
* We jump here on bigger requests, on error in the code above (as a
* last chance to serve the request) or when the max memory limit
* has been reached.
*/
{
void *result;
if (use_calloc)
result = PyMem_RawCalloc(nelem, elsize);
else
result = PyMem_RawMalloc(nbytes);
if (!result)
_Py_AllocatedBlocks--;
return result;
}
} | 1 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198 | -1 | https://github.com/python/typed_ast/commit/156afcb26c198e162504a57caddfe0acd9ed7dce | 0CCPP |
N.message?N.message:mxResources.get("disconnected")));mxEvent.consume(E)}));G.setAttribute("title",F);B.style.paddingRight="4px";B.appendChild(G)}}}};var q=App.prototype.updateButtonContainer;App.prototype.updateButtonContainer=function(){q.apply(this,arguments);if(null!=this.shareButton){var B=this.shareButton;B.style.cssText="display:inline-block;position:relative;box-sizing:border-box;margin-right:4px;cursor:pointer;";B.className="geToolbarButton";B.innerHTML="";B.style.backgroundImage="url("+
Editor.shareImage+")";B.style.backgroundPosition="center center";B.style.backgroundRepeat="no-repeat";B.style.backgroundSize="24px 24px";B.style.height="24px";B.style.width="24px";"1"==urlParams.sketch&&(this.shareButton.style.display="none")}null!=this.buttonContainer&&(this.buttonContainer.style.marginTop="-2px",this.buttonContainer.style.paddingTop="4px")};EditorUi.prototype.addEmbedButtons=function(){if(null!=this.buttonContainer&&"1"!=urlParams.embedInline){var B=document.createElement("div"); | 1 | 0,1 | -1 | https://github.com/jgraph/drawio/commit/4deecee18191f67e242422abf3ca304e19e49687 | 3JavaScript |
encodeURIComponent(K):"")+"&extras="+encodeURIComponent(JSON.stringify(y))+(0<v?"&dpi="+v:"")+"&bg="+(null!=k?k:"none")+"&w="+M+"&h="+n+"&border="+q+"&xml="+encodeURIComponent(z))})}else"png"==g?c.exportImage(m,null==k||"none"==k,!0,!1,!1,q,!0,!1,null,x,v):c.exportImage(m,!1,!0,!1,!1,q,!0,!1,"jpeg",x);else mxUtils.alert(mxResources.get("drawingTooLarge"))}});EditorUi.prototype.getDiagramTextContent=function(){this.editor.graph.setEnabled(!1);var c=this.editor.graph,e="";if(null!=this.pages)for(var g=
0;g<this.pages.length;g++){var k=c;this.currentPage!=this.pages[g]&&(k=this.createTemporaryGraph(c.getStylesheet()),this.updatePageRoot(this.pages[g]),k.model.setRoot(this.pages[g].root));e+=this.pages[g].getName()+" "+k.getIndexableText()+" "}else e=c.getIndexableText();this.editor.graph.setEnabled(!0);return e};EditorUi.prototype.showRemotelyStoredLibrary=function(c){var e={},g=document.createElement("div");g.style.whiteSpace="nowrap";var k=document.createElement("h3");mxUtils.write(k,mxUtils.htmlEntities(c)); | 1 | 0 | -1 | https://github.com/jgraph/drawio/commit/4deecee18191f67e242422abf3ca304e19e49687 | 3JavaScript |
static long __media_device_enum_links(struct media_device *mdev,
struct media_links_enum *links)
{
struct media_entity *entity;
entity = find_entity(mdev, links->entity);
if (entity == NULL)
return -EINVAL;
if (links->pads) {
unsigned int p;
for (p = 0; p < entity->num_pads; p++) {
struct media_pad_desc pad;
media_device_kpad_to_upad(&entity->pads[p], &pad);
if (copy_to_user(&links->pads[p], &pad, sizeof(pad)))
return -EFAULT;
}
}
if (links->links) {
struct media_link_desc __user *ulink;
unsigned int l;
for (l = 0, ulink = links->links; l < entity->num_links; l++) {
struct media_link_desc link;
if (entity->links[l].source->entity != entity)
continue;
media_device_kpad_to_upad(entity->links[l].source,
&link.source);
media_device_kpad_to_upad(entity->links[l].sink,
&link.sink);
link.flags = entity->links[l].flags;
if (copy_to_user(ulink, &link, sizeof(*ulink)))
return -EFAULT;
ulink++;
}
}
return 0;
} | 1 | null | -1 | https://github.com/torvalds/linux/commit/c88e739b1fad662240e99ecbd0bdaac871717987 | 0CCPP |
static int vp7_calculate_mb_offset(int mb_x, int mb_y, int mb_width,
int xoffset, int yoffset, int boundary,
int *edge_x, int *edge_y)
{
int vwidth = mb_width + 1;
int new = (mb_y + yoffset) * vwidth + mb_x + xoffset;
if (new < boundary || new % vwidth == vwidth - 1)
return 0;
*edge_y = new / vwidth;
*edge_x = new % vwidth;
return 1;
} | 0 | null | -1 | https://github.com/FFmpeg/FFmpeg/commit/6b5d3fb26fb4be48e4966e4b1d97c2165538d4ef | 0CCPP |
def analyse_text(text):
return EvoqueLexer.analyse_text(text)
| 0 | null | -1 | https://github.com/pygments/pygments.git/commit/2e7e8c4a7b318f4032493773732754e418279a14 | 4Python |
init_usm(void)
{
struct snmp_secmod_def *def;
char *type;
DEBUGMSGTL(("init_usm", "unit_usm: %" NETSNMP_PRIo "u %" NETSNMP_PRIo "u\n",
usmNoPrivProtocol[0], usmNoPrivProtocol[1]));
sc_init();
def = SNMP_MALLOC_STRUCT(snmp_secmod_def);
if (def == NULL)
return;
def->encode_reverse = usm_secmod_rgenerate_out_msg;
def->encode_forward = usm_secmod_generate_out_msg;
def->decode = usm_secmod_process_in_msg;
def->pdu_free_state_ref = usm_free_usmStateReference;
def->session_setup = usm_session_init;
def->handle_report = usm_handle_report;
def->probe_engineid = usm_discover_engineid;
def->post_probe_engineid = usm_create_user_from_session_hook;
if (register_sec_mod(USM_SEC_MODEL_NUMBER, "usm", def) != SNMPERR_SUCCESS) {
SNMP_FREE(def);
snmp_log(LOG_ERR, "could not register usm sec mod\n");
return;
}
snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_POST_PREMIB_READ_CONFIG,
init_usm_post_config, NULL);
snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_SHUTDOWN,
deinit_usm_post_config, NULL);
snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_SHUTDOWN,
free_engineID, NULL);
register_config_handler("snmp", "defAuthType", snmpv3_authtype_conf,
NULL, "MD5|SHA|SHA-512|SHA-384|SHA-256|SHA-224");
register_config_handler("snmp", "defPrivType", snmpv3_privtype_conf,
NULL,
"DES"
#ifdef HAVE_AES
"|AES|AES-128"
#ifdef NETSNMP_DRAFT_BLUMENTHAL_AES_04
"|AES-192|AES-256"
#endif
#else
" (AES support not available)"
#endif
);
snmp_register_callback(SNMP_CALLBACK_LIBRARY,
SNMP_CALLBACK_SHUTDOWN,
free_enginetime_on_shutdown, NULL);
type = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_APPTYPE);
register_config_handler(type, "userSetAuthPass", usm_set_password,
NULL, NULL);
register_config_handler(type, "userSetPrivPass", usm_set_password,
NULL, NULL);
register_config_handler(type, "userSetAuthKey", usm_set_password, NULL,
NULL);
register_config_handler(type, "userSetPrivKey", usm_set_password, NULL,
NULL);
register_config_handler(type, "userSetAuthLocalKey", usm_set_password,
NULL, NULL);
register_config_handler(type, "userSetPrivLocalKey", usm_set_password,
NULL, NULL);
} | 1 | null | -1 | https://github.com/net-snmp/net-snmp/commit/5f881d3bf24599b90d67a45cae7a3eb099cd71c9 | 0CCPP |
void mp_decode_to_lua_array(lua_State *L, mp_cur *c, size_t len) {
assert(len <= UINT_MAX);
int index = 1;
lua_newtable(L);
while(len--) {
lua_pushnumber(L,index++);
mp_decode_to_lua_type(L,c);
if (c->err) return;
lua_settable(L,-3);
}
} | 1 | null | -1 | https://github.com/redis/redis/commit/5ccb6f7a791bf3490357b00a898885759d98bab0 | 0CCPP |
def _is_javascript_scheme(s):
if _is_image_dataurl(s):
return None
return _is_possibly_malicious_scheme(s)
| 1 | 1,2,3 | -1 | https://github.com/lxml/lxml.git/commit/f2330237440df7e8f39c3ad1b1aa8852be3b27c0 | 4Python |
public static Object readObject(XStream xStream, InputStream is) {
try(InputStreamReader isr = new InputStreamReader(is, ENCODING);) {
return xStream.fromXML(isr);
} catch (Exception e) {
throw new OLATRuntimeException(XStreamHelper.class,
"could not read Object from inputstream: " + is, e);
}
} | 1 | 1 | -1 | https://github.com/OpenOLAT/OpenOLAT/commit/3f219ac457afde82e3be57bc614352ab92c05684 | 2Java |
long ZEXPORT inflateMark(strm)
z_streamp strm;
{
struct inflate_state FAR *state;
if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
state = (struct inflate_state FAR *)strm->state;
return ((long)(state->back) << 16) +
(state->mode == COPY ? state->length :
(state->mode == MATCH ? state->was - state->length : 0));
} | 1 | 4,6 | -1 | https://github.com/madler/zlib/commit/e54e1299404101a5a9d0cf5e45512b543967f958 | 0CCPP |
static unsigned long kvm_vm_ioctl_get_nr_mmu_pages(struct kvm *kvm)
{
return kvm->arch.n_max_mmu_pages;
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/fee060cd52d69c114b62d1a2948ea9648b5131f9 | 0CCPP |
elFinder.prototype.history = function(fm) {
var self = this,
/**
* Update history on "open" event?
*
* @type Boolean
*/
update = true,
/**
* Directories hashes storage
*
* @type Array
*/
history = [],
/**
* Current directory index in history
*
* @type Number
*/
current,
/**
* Clear history
*
* @return void
*/
reset = function() {
history = [fm.cwd().hash];
current = 0;
update = true;
},
/**
* Browser native history object
*/
nativeHistory = (fm.options.useBrowserHistory && window.history && window.history.pushState)? window.history : null,
/**
* Open prev/next folder
*
* @Boolen open next folder?
* @return jQuery.Deferred
*/
go = function(fwd) {
if ((fwd && self.canForward()) || (!fwd && self.canBack())) {
update = false;
return fm.exec('open', history[fwd ? ++current : --current]).fail(reset);
}
return $.Deferred().reject();
};
/**
* Return true if there is previous visited directories
*
* @return Boolen
*/
this.canBack = function() {
return current > 0;
}
/**
* Return true if can go forward
*
* @return Boolen
*/
this.canForward = function() {
return current < history.length - 1;
}
/**
* Go back
*
* @return void
*/
this.back = go;
/**
* Go forward
*
* @return void
*/
this.forward = function() {
return go(true);
}
// bind to elfinder events
fm.open(function(e) {
var l = history.length,
cwd = fm.cwd().hash;
if (update) {
current >= 0 && l > current + 1 && history.splice(current+1);
history[history.length-1] != cwd && history.push(cwd);
current = history.length - 1;
}
update = true;
if (nativeHistory) {
if (! nativeHistory.state) {
nativeHistory.replaceState({thash: cwd}, null, location.pathname + location.search + '#elf_' + cwd);
} else {
nativeHistory.state.thash != cwd && nativeHistory.pushState({thash: cwd}, null, location.pathname + location.search + '#elf_' + cwd);
}
}
})
.reload(reset);
} | 1 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96 | -1 | https://github.com/semplon/GeniXCMS/commit/d885eb20006099262c0278932b9f8aca3c1ac97f | 3JavaScript |
static int do_setxattr(struct btrfs_trans_handle *trans,
struct inode *inode, const char *name,
const void *value, size_t size, int flags)
{
struct btrfs_dir_item *di;
struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_path *path;
size_t name_len = strlen(name);
int ret = 0;
if (name_len + size > BTRFS_MAX_XATTR_SIZE(root))
return -ENOSPC;
path = btrfs_alloc_path();
if (!path)
return -ENOMEM;
if (flags & XATTR_REPLACE) {
di = btrfs_lookup_xattr(trans, root, path, btrfs_ino(inode), name,
name_len, -1);
if (IS_ERR(di)) {
ret = PTR_ERR(di);
goto out;
} else if (!di) {
ret = -ENODATA;
goto out;
}
ret = btrfs_delete_one_dir_name(trans, root, path, di);
if (ret)
goto out;
btrfs_release_path(path);
if (!value)
goto out;
} else {
di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(inode),
name, name_len, 0);
if (IS_ERR(di)) {
ret = PTR_ERR(di);
goto out;
}
if (!di && !value)
goto out;
btrfs_release_path(path);
}
again:
ret = btrfs_insert_xattr_item(trans, root, path, btrfs_ino(inode),
name, name_len, value, size);
/*
* If we're setting an xattr to a new value but the new value is say
* exactly BTRFS_MAX_XATTR_SIZE, we could end up with EOVERFLOW getting
* back from split_leaf. This is because it thinks we'll be extending
* the existing item size, but we're asking for enough space to add the
* item itself. So if we get EOVERFLOW just set ret to EEXIST and let
* the rest of the function figure it out.
*/
if (ret == -EOVERFLOW)
ret = -EEXIST;
if (ret == -EEXIST) {
if (flags & XATTR_CREATE)
goto out;
btrfs_release_path(path);
di = btrfs_lookup_xattr(trans, root, path, btrfs_ino(inode),
name, name_len, -1);
if (IS_ERR(di)) {
ret = PTR_ERR(di);
goto out;
} else if (!di) {
/* Shouldn't happen but just in case... */
btrfs_release_path(path);
goto again;
}
ret = btrfs_delete_one_dir_name(trans, root, path, di);
if (ret)
goto out;
if (value) {
btrfs_release_path(path);
goto again;
}
}
out:
btrfs_free_path(path);
return ret;
} | 1 | 4,15,16,17,18,19,20,24,25,26,28,29,30,31,32,33,34,37,38,39,41,42,43,44,45,46,47,48,49,50,51,52,54,55,56,57,58,59,60,61,62,63,64,65,66,68,69,70,71,72,73,74 | -1 | https://github.com/torvalds/linux/commit/5f5bc6b1e2d5a6f827bc860ef2dc5b6f365d1339 | 0CCPP |
static void n_tty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
char *fp, int count)
{
n_tty_receive_buf_common(tty, cp, fp, count, 0);
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/4291086b1f081b869c6d79e5b7441633dc3ace00 | 0CCPP |
int hfi1_set_uevent_bits(struct hfi1_pportdata *ppd, const int evtbit)
{
struct hfi1_ctxtdata *uctxt;
struct hfi1_devdata *dd = ppd->dd;
unsigned ctxt;
int ret = 0;
unsigned long flags;
if (!dd->events) {
ret = -EINVAL;
goto done;
}
spin_lock_irqsave(&dd->uctxt_lock, flags);
for (ctxt = dd->first_user_ctxt; ctxt < dd->num_rcv_contexts;
ctxt++) {
uctxt = dd->rcd[ctxt];
if (uctxt) {
unsigned long *evs = dd->events +
(uctxt->ctxt - dd->first_user_ctxt) *
HFI1_MAX_SHARED_CTXTS;
int i;
set_bit(evtbit, evs);
for (i = 1; i < uctxt->subctxt_cnt; i++)
set_bit(evtbit, evs + i);
}
}
spin_unlock_irqrestore(&dd->uctxt_lock, flags);
done:
return ret;
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/e6bd18f57aad1a2d1ef40e646d03ed0f2515c9e3 | 0CCPP |
static void send_search(struct ifsock *ifs, char *type)
{
ssize_t num;
char buf[MAX_PKT_SIZE];
struct sockaddr dest;
memset(buf, 0, sizeof(buf));
compose_search(type, buf, sizeof(buf));
compose_addr((struct sockaddr_in *)&dest, MC_SSDP_GROUP, MC_SSDP_PORT);
logit(LOG_DEBUG, "Sending M-SEARCH ...");
num = sendto(ifs->out, buf, strlen(buf), 0, &dest, sizeof(struct sockaddr_in));
if (num < 0)
logit(LOG_WARNING, "Failed sending SSDP M-SEARCH");
} | 0 | null | -1 | https://github.com/troglobit/ssdp-responder/commit/ce04b1f29a137198182f60bbb628d5ceb8171765 | 0CCPP |
static BOOL update_read_icon_info(wStream* s, ICON_INFO* iconInfo)
{
BYTE* newBitMask;
if (Stream_GetRemainingLength(s) < 8)
return FALSE;
Stream_Read_UINT16(s, iconInfo->cacheEntry);
Stream_Read_UINT8(s, iconInfo->cacheId);
Stream_Read_UINT8(s, iconInfo->bpp);
if ((iconInfo->bpp < 1) || (iconInfo->bpp > 32))
{
WLog_ERR(TAG, "invalid bpp value %" PRIu32 "", iconInfo->bpp);
return FALSE;
}
Stream_Read_UINT16(s, iconInfo->width);
Stream_Read_UINT16(s, iconInfo->height);
switch (iconInfo->bpp)
{
case 1:
case 4:
case 8:
if (Stream_GetRemainingLength(s) < 2)
return FALSE;
Stream_Read_UINT16(s, iconInfo->cbColorTable);
break;
default:
iconInfo->cbColorTable = 0;
break;
}
if (Stream_GetRemainingLength(s) < 4)
return FALSE;
Stream_Read_UINT16(s, iconInfo->cbBitsMask);
Stream_Read_UINT16(s, iconInfo->cbBitsColor);
if (Stream_GetRemainingLength(s) < iconInfo->cbBitsMask + iconInfo->cbBitsColor)
return FALSE;
newBitMask = (BYTE*)realloc(iconInfo->bitsMask, iconInfo->cbBitsMask);
if (!newBitMask)
{
free(iconInfo->bitsMask);
iconInfo->bitsMask = NULL;
return FALSE;
}
iconInfo->bitsMask = newBitMask;
Stream_Read(s, iconInfo->bitsMask, iconInfo->cbBitsMask);
if (iconInfo->colorTable == NULL)
{
if (iconInfo->cbColorTable)
{
iconInfo->colorTable = (BYTE*)malloc(iconInfo->cbColorTable);
if (!iconInfo->colorTable)
return FALSE;
}
}
else if (iconInfo->cbColorTable)
{
BYTE* new_tab;
new_tab = (BYTE*)realloc(iconInfo->colorTable, iconInfo->cbColorTable);
if (!new_tab)
{
free(iconInfo->colorTable);
iconInfo->colorTable = NULL;
return FALSE;
}
iconInfo->colorTable = new_tab;
}
else
{
free(iconInfo->colorTable);
iconInfo->colorTable = NULL;
}
if (iconInfo->colorTable)
Stream_Read(s, iconInfo->colorTable, iconInfo->cbColorTable);
newBitMask = (BYTE*)realloc(iconInfo->bitsColor, iconInfo->cbBitsColor);
if (!newBitMask)
{
free(iconInfo->bitsColor);
iconInfo->bitsColor = NULL;
return FALSE;
}
iconInfo->bitsColor = newBitMask;
Stream_Read(s, iconInfo->bitsColor, iconInfo->cbBitsColor);
return TRUE;
} | 1 | 32,33 | -1 | https://github.com/FreeRDP/FreeRDP/commit/6b2bc41935e53b0034fe5948aeeab4f32e80f30f | 0CCPP |
ca_reload(struct iked *env)
{
struct ca_store *store = env->sc_priv;
uint8_t md[EVP_MAX_MD_SIZE];
char file[PATH_MAX];
struct iovec iov[2];
struct dirent *entry;
STACK_OF(X509_OBJECT) *h;
X509_OBJECT *xo;
X509 *x509;
DIR *dir;
int i, len, iovcnt = 0;
if ((dir = opendir(IKED_CA_DIR)) == NULL)
return (-1);
while ((entry = readdir(dir)) != NULL) {
if ((entry->d_type != DT_REG) &&
(entry->d_type != DT_LNK))
continue;
if (snprintf(file, sizeof(file), "%s%s",
IKED_CA_DIR, entry->d_name) < 0)
continue;
if (!X509_load_cert_file(store->ca_calookup, file,
X509_FILETYPE_PEM)) {
log_warn("%s: failed to load ca file %s", __func__,
entry->d_name);
ca_sslerror(__func__);
continue;
}
log_debug("%s: loaded ca file %s", __func__, entry->d_name);
}
closedir(dir);
if ((dir = opendir(IKED_CRL_DIR)) == NULL)
return (-1);
while ((entry = readdir(dir)) != NULL) {
if ((entry->d_type != DT_REG) &&
(entry->d_type != DT_LNK))
continue;
if (snprintf(file, sizeof(file), "%s%s",
IKED_CRL_DIR, entry->d_name) < 0)
continue;
if (!X509_load_crl_file(store->ca_calookup, file,
X509_FILETYPE_PEM)) {
log_warn("%s: failed to load crl file %s", __func__,
entry->d_name);
ca_sslerror(__func__);
continue;
}
X509_STORE_set_flags(store->ca_cas, X509_V_FLAG_CRL_CHECK);
log_debug("%s: loaded crl file %s", __func__, entry->d_name);
}
closedir(dir);
ibuf_release(env->sc_certreq);
if ((env->sc_certreq = ibuf_new(NULL, 0)) == NULL)
return (-1);
h = store->ca_cas->objs;
for (i = 0; i < sk_X509_OBJECT_num(h); i++) {
xo = sk_X509_OBJECT_value(h, i);
if (xo->type != X509_LU_X509)
continue;
x509 = xo->data.x509;
len = sizeof(md);
ca_subjectpubkey_digest(x509, md, &len);
log_debug("%s: %s", __func__, x509->name);
if (ibuf_add(env->sc_certreq, md, len) != 0) {
ibuf_release(env->sc_certreq);
env->sc_certreq = NULL;
return (-1);
}
}
if (ibuf_length(env->sc_certreq)) {
env->sc_certreqtype = IKEV2_CERT_X509_CERT;
iov[0].iov_base = &env->sc_certreqtype;
iov[0].iov_len = sizeof(env->sc_certreqtype);
iovcnt++;
iov[1].iov_base = ibuf_data(env->sc_certreq);
iov[1].iov_len = ibuf_length(env->sc_certreq);
iovcnt++;
log_debug("%s: loaded %zu ca certificate%s", __func__,
ibuf_length(env->sc_certreq) / SHA_DIGEST_LENGTH,
ibuf_length(env->sc_certreq) == SHA_DIGEST_LENGTH ?
"" : "s");
(void)proc_composev(&env->sc_ps, PROC_IKEV2, IMSG_CERTREQ,
iov, iovcnt);
}
if ((dir = opendir(IKED_CERT_DIR)) == NULL)
return (-1);
while ((entry = readdir(dir)) != NULL) {
if ((entry->d_type != DT_REG) &&
(entry->d_type != DT_LNK))
continue;
if (snprintf(file, sizeof(file), "%s%s",
IKED_CERT_DIR, entry->d_name) < 0)
continue;
if (!X509_load_cert_file(store->ca_certlookup, file,
X509_FILETYPE_PEM)) {
log_warn("%s: failed to load cert file %s", __func__,
entry->d_name);
ca_sslerror(__func__);
continue;
}
log_debug("%s: loaded cert file %s", __func__, entry->d_name);
}
closedir(dir);
h = store->ca_certs->objs;
for (i = 0; i < sk_X509_OBJECT_num(h); i++) {
xo = sk_X509_OBJECT_value(h, i);
if (xo->type != X509_LU_X509)
continue;
x509 = xo->data.x509;
(void)ca_validate_cert(env, NULL, x509, 0);
}
if (!env->sc_certreqtype)
env->sc_certreqtype = store->ca_pubkey.id_type;
log_debug("%s: local cert type %s", __func__,
print_map(env->sc_certreqtype, ikev2_cert_map));
iov[0].iov_base = &env->sc_certreqtype;
iov[0].iov_len = sizeof(env->sc_certreqtype);
if (iovcnt == 0)
iovcnt++;
(void)proc_composev(&env->sc_ps, PROC_IKEV2, IMSG_CERTREQ, iov, iovcnt);
return (0);
} | 0 | null | -1 | https://github.com/openbsd/src/commit/7afb2d41c6d373cf965285840b85c45011357115 | 0CCPP |
__next(struct seq_file *m, loff_t *pos)
{
long n = *pos - 1;
if (n >= max_stack_trace.nr_entries || stack_dump_trace[n] == ULONG_MAX)
return NULL;
m->private = (void *)n;
return &m->private;
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/6a76f8c0ab19f215af2a3442870eeb5f0e81998d | 0CCPP |
hfs_dinode_copy(HFS_INFO * a_hfs, const HFS_ENTRY * a_hfs_entry,
TSK_FS_FILE * a_fs_file)
{
const hfs_file_folder *a_entry =
(hfs_file_folder *) & (a_hfs_entry->cat);
const hfs_file_fold_std *std;
TSK_FS_META *a_fs_meta = a_fs_file->meta;
TSK_FS_INFO *fs;
uint16_t hfsmode;
TSK_INUM_T iStd;
if (a_entry == NULL) {
error_detected(TSK_ERR_FS_ARG,
"hfs_dinode_copy: a_entry = a_hfs_entry->cat is NULL");
return 1;
}
fs = (TSK_FS_INFO *) & a_hfs->fs_info;
iStd = tsk_getu32(fs->endian, a_entry->file.std.cnid);
if (iStd != a_hfs_entry->inum) {
if (tsk_verbose)
tsk_fprintf(stderr,
"WARNING: hfs_dinode_copy: HFS_ENTRY with conflicting values for inum (or cnid).\n");
}
if (a_fs_meta == NULL) {
tsk_error_set_errno(TSK_ERR_FS_ARG);
tsk_error_set_errstr("hfs_dinode_copy: a_fs_meta is NULL");
return 1;
}
std = &(a_entry->file.std);
if (tsk_verbose)
tsk_fprintf(stderr,
"hfs_dinode_copy: called for file/folder %" PRIu32 "\n",
tsk_getu32(fs->endian, std->cnid));
if (a_fs_meta->content_len < HFS_FILE_CONTENT_LEN) {
if ((a_fs_meta =
tsk_fs_meta_realloc(a_fs_meta,
HFS_FILE_CONTENT_LEN)) == NULL) {
return 1;
}
}
a_fs_meta->attr_state = TSK_FS_META_ATTR_EMPTY;
if (a_fs_meta->attr) {
tsk_fs_attrlist_markunused(a_fs_meta->attr);
}
hfsmode = tsk_getu16(fs->endian, std->perm.mode);
if (tsk_getu16(fs->endian, std->rec_type) == HFS_FOLDER_RECORD) {
if ((hfsmode & HFS_IN_IFMT) == 0)
a_fs_meta->type = TSK_FS_META_TYPE_DIR;
a_fs_meta->size = 0;
memset(a_fs_meta->content_ptr, 0, HFS_FILE_CONTENT_LEN);
}
else if (tsk_getu16(fs->endian, std->rec_type) == HFS_FILE_RECORD) {
hfs_fork *fork;
if ((hfsmode & HFS_IN_IFMT) == 0)
a_fs_meta->type = TSK_FS_META_TYPE_REG;
a_fs_meta->size =
tsk_getu64(fs->endian, a_entry->file.data.logic_sz);
fork = (hfs_fork *) a_fs_meta->content_ptr;
memcpy(fork, &(a_entry->file.data), sizeof(hfs_fork));
memcpy(&fork[1], &(a_entry->file.resource), sizeof(hfs_fork));
}
else {
if (tsk_verbose)
tsk_fprintf(stderr,
"hfs_dinode_copy error: catalog entry is neither file nor folder\n");
return 1;
}
if ((hfsmode & HFS_IN_IFMT) == 0) {
a_fs_meta->mode = 0;
a_fs_meta->uid = 99;
a_fs_meta->gid = 99;
}
else {
a_fs_meta->mode = hfs_mode_to_tsk_mode(hfsmode);
a_fs_meta->type = hfs_mode_to_tsk_meta_type(hfsmode);
a_fs_meta->uid = tsk_getu32(fs->endian, std->perm.owner);
a_fs_meta->gid = tsk_getu32(fs->endian, std->perm.group);
}
if (tsk_getu32(fs->endian, std->perm.special.nlink))
a_fs_meta->nlink = tsk_getu32(fs->endian, std->perm.special.nlink);
else
a_fs_meta->nlink = 1;
a_fs_meta->mtime =
hfs_convert_2_unix_time(tsk_getu32(fs->endian, std->cmtime));
a_fs_meta->atime =
hfs_convert_2_unix_time(tsk_getu32(fs->endian, std->atime));
a_fs_meta->crtime =
hfs_convert_2_unix_time(tsk_getu32(fs->endian, std->crtime));
a_fs_meta->ctime =
hfs_convert_2_unix_time(tsk_getu32(fs->endian, std->amtime));
a_fs_meta->time2.hfs.bkup_time =
hfs_convert_2_unix_time(tsk_getu32(fs->endian, std->bkup_date));
a_fs_meta->mtime_nano = a_fs_meta->atime_nano = a_fs_meta->ctime_nano =
a_fs_meta->crtime_nano = 0;
a_fs_meta->time2.hfs.bkup_time_nano = 0;
a_fs_meta->addr = tsk_getu32(fs->endian, std->cnid);
a_fs_meta->flags = TSK_FS_META_FLAG_ALLOC | TSK_FS_META_FLAG_USED;
if (std->perm.o_flags & HFS_PERM_OFLAG_COMPRESSED)
a_fs_meta->flags |= TSK_FS_META_FLAG_COMP;
if (a_fs_file->name != NULL) {
a_fs_file->name->meta_addr = a_fs_meta->addr;
}
if ((a_fs_meta->type == TSK_FS_META_TYPE_LNK) &&
(a_fs_meta->size >= 0) && (a_fs_meta->size < HFS_MAXPATHLEN)) {
ssize_t bytes_read;
a_fs_meta->link = tsk_malloc((size_t) a_fs_meta->size + 1);
if (a_fs_meta->link == NULL)
return 1;
bytes_read = tsk_fs_file_read(a_fs_file, (TSK_OFF_T) 0,
a_fs_meta->link, (size_t) a_fs_meta->size,
TSK_FS_FILE_READ_FLAG_NONE);
a_fs_meta->link[a_fs_meta->size] = '\0';
if (bytes_read != a_fs_meta->size) {
if (tsk_verbose)
tsk_fprintf(stderr,
"hfs_dinode_copy: failed to read contents of symbolic link; "
"expected %u bytes but tsk_fs_file_read() returned %u\n",
a_fs_meta->size, bytes_read);
free(a_fs_meta->link);
a_fs_meta->link = NULL;
return 1;
}
}
return 0;
} | 0 | null | -1 | https://github.com/sleuthkit/sleuthkit/commit/8242588f4354339d9cb1ad82622e7c16c55391c9 | 0CCPP |
static PixelChannels **AcquirePixelThreadSet(const Image *image)
{
PixelChannels
**pixels;
register ssize_t
i;
size_t
number_threads;
number_threads=(size_t) GetMagickResourceLimit(ThreadResource);
pixels=(PixelChannels **) AcquireQuantumMemory(number_threads,
sizeof(*pixels));
if (pixels == (PixelChannels **) NULL)
return((PixelChannels **) NULL);
(void) memset(pixels,0,number_threads*sizeof(*pixels));
for (i=0; i < (ssize_t) number_threads; i++)
{
register ssize_t
j;
pixels[i]=(PixelChannels *) AcquireQuantumMemory(image->columns,
sizeof(**pixels));
if (pixels[i] == (PixelChannels *) NULL)
return(DestroyPixelThreadSet(pixels));
for (j=0; j < (ssize_t) image->columns; j++)
{
register ssize_t
k;
for (k=0; k < MaxPixelChannels; k++)
pixels[i][j].channel[k]=0.0;
}
}
return(pixels);
} | 1 | 0,18,19,22 | -1 | https://github.com/ImageMagick/ImageMagick/commit/a906fe9298bf89e01d5272023db687935068849a | 0CCPP |
mxShapeCisco19Rect.prototype.getConstraints=function(a,d,e){a=[];a.push(new mxConnectionConstraint(new mxPoint(.825,.5),!1));a.push(new mxConnectionConstraint(new mxPoint(.175,.5),!1));a.push(new mxConnectionConstraint(new mxPoint(.5,.16),!1));a.push(new mxConnectionConstraint(new mxPoint(.5,.84),!1));a.push(new mxConnectionConstraint(new mxPoint(.66,.17),!1));a.push(new mxConnectionConstraint(new mxPoint(.66,.83),!1));a.push(new mxConnectionConstraint(new mxPoint(.34,.17),!1));a.push(new mxConnectionConstraint(new mxPoint(.34,
.83),!1));a.push(new mxConnectionConstraint(new mxPoint(.75,.33),!1));a.push(new mxConnectionConstraint(new mxPoint(.75,.67),!1));a.push(new mxConnectionConstraint(new mxPoint(.25,.33),!1));a.push(new mxConnectionConstraint(new mxPoint(.25,.67),!1));return a};function mxShapeCiscoSafeCompositeIcon(a,d,e,b){mxShape.call(this);this.bounds=a;this.fill=d;this.stroke=e;this.strokewidth=null!=b?b:1}mxUtils.extend(mxShapeCiscoSafeCompositeIcon,mxShape);mxShapeCiscoSafeCompositeIcon.prototype.cst={SHAPE_COMPOSITE_ICON:"mxgraph.cisco_safe.compositeIcon"}; | 0 | null | -1 | https://github.com/jgraph/drawio/commit/c63f3a04450f30798df47f9badbc74eb8a69fbdf | 3JavaScript |
void rtnl_set_sk_err(struct net *net, u32 group, int error)
{
struct sock *rtnl = net->rtnl;
netlink_set_err(rtnl, 0, group, error);
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/5f8e44741f9f216e33736ea4ec65ca9ac03036e6 | 0CCPP |
static int futex_wait(u32 __user *uaddr, int fshared,
u32 val, ktime_t *abs_time, u32 bitset, int clockrt)
{
struct hrtimer_sleeper timeout, *to = NULL;
struct restart_block *restart;
struct futex_hash_bucket *hb;
struct futex_q q;
int ret;
if (!bitset)
return -EINVAL;
q.pi_state = NULL;
q.bitset = bitset;
q.rt_waiter = NULL;
q.requeue_pi_key = NULL;
if (abs_time) {
to = &timeout;
hrtimer_init_on_stack(&to->timer, clockrt ? CLOCK_REALTIME :
CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
hrtimer_init_sleeper(to, current);
hrtimer_set_expires_range_ns(&to->timer, *abs_time,
current->timer_slack_ns);
}
retry:
/* Prepare to wait on uaddr. */
ret = futex_wait_setup(uaddr, val, fshared, &q, &hb);
if (ret)
goto out;
futex_wait_queue_me(hb, &q, to);
ret = 0;
if (!unqueue_me(&q))
goto out_put_key;
ret = -ETIMEDOUT;
if (to && !to->task)
goto out_put_key;
if (!signal_pending(current)) {
put_futex_key(fshared, &q.key);
goto retry;
}
ret = -ERESTARTSYS;
if (!abs_time)
goto out_put_key;
restart = ¤t_thread_info()->restart_block;
restart->fn = futex_wait_restart;
restart->futex.uaddr = (u32 *)uaddr;
restart->futex.val = val;
restart->futex.time = abs_time->tv64;
restart->futex.bitset = bitset;
restart->futex.flags = FLAGS_HAS_TIMEOUT;
if (fshared)
restart->futex.flags |= FLAGS_SHARED;
if (clockrt)
restart->futex.flags |= FLAGS_CLOCKRT;
ret = -ERESTART_RESTARTBLOCK;
out_put_key:
put_futex_key(fshared, &q.key);
out:
if (to) {
hrtimer_cancel(&to->timer);
destroy_hrtimer_on_stack(&to->timer);
}
return ret;
} | 1 | 23,30,33,34,35,37,40,53,54 | -1 | https://github.com/torvalds/linux/commit/7ada876a8703f23befbb20a7465a702ee39b1704 | 0CCPP |
static void mif_cmpt_destroy(mif_cmpt_t *cmpt)
{
if (cmpt->data) {
jas_free(cmpt->data);
}
jas_free(cmpt);
} | 0 | null | -1 | https://github.com/jasper-software/jasper/commit/d42b2388f7f8e0332c846675133acea151fc557a | 0CCPP |
Status InferenceContext::Subtract(DimensionHandle first,
DimensionOrConstant second,
DimensionHandle* out) {
const int64_t first_value = Value(first);
const int64_t second_value = Value(second);
if (second_value == 0) {
*out = first;
} else if (first_value == kUnknownDim || second_value == kUnknownDim) {
*out = UnknownDim();
} else {
if (first_value < second_value) {
return errors::InvalidArgument(
"Negative dimension size caused by subtracting ", second_value,
" from ", first_value);
}
*out = MakeDim(first_value - second_value);
}
return Status::OK();
} | 0 | null | -1 | https://github.com/tensorflow/tensorflow/commit/cb164786dc891ea11d3a900e90367c339305dc7b | 0CCPP |
PHP_FUNCTION(locale_get_display_region)
{
get_icu_disp_value_src_php( LOC_REGION_TAG , INTERNAL_FUNCTION_PARAM_PASSTHRU );
} | 1 | 0 | -1 | https://github.com/php/php-src/commit/97eff7eb57fc2320c267a949cffd622c38712484 | 0CCPP |
def received(self, data):
if self.completed:
return 0
datalen = len(data)
br = self.body_rcv
if br is None:
s = self.header_plus + data
index = find_double_newline(s)
if index >= 0:
header_plus = s[:index]
consumed = len(data) - (len(s) - index)
header_plus = header_plus.lstrip()
if not header_plus:
self.empty = True
self.completed = True
else:
try:
self.parse_header(header_plus)
except ParsingError as e:
self.error = BadRequest(e.args[0])
self.completed = True
else:
if self.body_rcv is None:
self.completed = True
if self.content_length > 0:
max_body = self.adj.max_request_body_size
if self.content_length >= max_body:
self.error = RequestEntityTooLarge(
"exceeds max_body of %s" % max_body
)
self.completed = True
self.headers_finished = True
return consumed
else:
self.header_bytes_received += datalen
max_header = self.adj.max_request_header_size
if self.header_bytes_received >= max_header:
self.parse_header(b"GET / HTTP/1.0\n")
self.error = RequestHeaderFieldsTooLarge(
"exceeds max_header of %s" % max_header
)
self.completed = True
self.header_plus = s
return datalen
else:
consumed = br.received(data)
self.body_bytes_received += consumed
max_body = self.adj.max_request_body_size
if self.body_bytes_received >= max_body:
self.error = RequestEntityTooLarge("exceeds max_body of %s" % max_body)
self.completed = True
elif br.error:
self.error = br.error
self.completed = True
elif br.completed:
self.completed = True
if self.chunked:
self.headers["CONTENT_LENGTH"] = str(br.__len__())
return consumed
| 1 | null | -1 | https://github.com/Pylons/waitress.git/commit/8eba394ad75deaf9e5cd15b78a3d16b12e6b0eba | 4Python |
struct hd_struct *disk_get_part(struct gendisk *disk, int partno)
{
struct hd_struct *part = NULL;
struct disk_part_tbl *ptbl;
if (unlikely(partno < 0))
return NULL;
rcu_read_lock();
ptbl = rcu_dereference(disk->part_tbl);
if (likely(partno < ptbl->len)) {
part = rcu_dereference(ptbl->part[partno]);
if (part)
get_device(part_to_dev(part));
}
rcu_read_unlock();
return part;
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/77da160530dd1dc94f6ae15a981f24e5f0021e84 | 0CCPP |
pci_get_cfgdata16(struct pci_vdev *dev, int offset)
{
assert(offset <= (PCI_REGMAX - 1) && (offset & 1) == 0);
return (*(uint16_t *)(dev->cfgdata + offset));
} | 1 | 2 | -1 | https://github.com/projectacrn/acrn-hypervisor/commit/2b3dedfb9ba13f15887f22b935d373f36c9a59fa | 0CCPP |
error_t enc28j60UpdateMacAddrFilter(NetInterface *interface)
{
uint_t i;
uint_t k;
uint32_t crc;
uint8_t hashTable[8];
MacFilterEntry *entry;
TRACE_DEBUG("Updating MAC filter...\r\n");
osMemset(hashTable, 0, sizeof(hashTable));
for(i = 0; i < MAC_ADDR_FILTER_SIZE; i++)
{
entry = &interface->macAddrFilter[i];
if(entry->refCount > 0)
{
crc = enc28j60CalcCrc(&entry->addr, sizeof(MacAddr));
k = (crc >> 23) & 0x3F;
hashTable[k / 8] |= (1 << (k % 8));
}
}
enc28j60WriteReg(interface, ENC28J60_REG_EHT0, hashTable[0]);
enc28j60WriteReg(interface, ENC28J60_REG_EHT1, hashTable[1]);
enc28j60WriteReg(interface, ENC28J60_REG_EHT2, hashTable[2]);
enc28j60WriteReg(interface, ENC28J60_REG_EHT3, hashTable[3]);
enc28j60WriteReg(interface, ENC28J60_REG_EHT4, hashTable[4]);
enc28j60WriteReg(interface, ENC28J60_REG_EHT5, hashTable[5]);
enc28j60WriteReg(interface, ENC28J60_REG_EHT6, hashTable[6]);
enc28j60WriteReg(interface, ENC28J60_REG_EHT7, hashTable[7]);
TRACE_DEBUG(" EHT0 = %02" PRIX8 "\r\n", enc28j60ReadReg(interface, ENC28J60_REG_EHT0));
TRACE_DEBUG(" EHT1 = %02" PRIX8 "\r\n", enc28j60ReadReg(interface, ENC28J60_REG_EHT1));
TRACE_DEBUG(" EHT2 = %02" PRIX8 "\r\n", enc28j60ReadReg(interface, ENC28J60_REG_EHT2));
TRACE_DEBUG(" EHT3 = %02" PRIX8 "\r\n", enc28j60ReadReg(interface, ENC28J60_REG_EHT3));
TRACE_DEBUG(" EHT0 = %02" PRIX8 "\r\n", enc28j60ReadReg(interface, ENC28J60_REG_EHT4));
TRACE_DEBUG(" EHT1 = %02" PRIX8 "\r\n", enc28j60ReadReg(interface, ENC28J60_REG_EHT5));
TRACE_DEBUG(" EHT2 = %02" PRIX8 "\r\n", enc28j60ReadReg(interface, ENC28J60_REG_EHT6));
TRACE_DEBUG(" EHT3 = %02" PRIX8 "\r\n", enc28j60ReadReg(interface, ENC28J60_REG_EHT7));
return NO_ERROR;
} | 1 | 19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34 | -1 | https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366 | 0CCPP |
findSibling = function(subtree, dir) {
var node = subtree.children(':first'),
info, compare;
compare = fm.naturalCompare;
while (node.length) {
info = fm.file(fm.navId2Hash(node.children('[id]').attr('id')));
if ((info = fm.file(fm.navId2Hash(node.children('[id]').attr('id'))))
&& compare(dir.name, info.name) < 0) {
return node;
}
node = node.next();
}
return $('');
}, | 1 | 7 | -1 | https://github.com/semplon/GeniXCMS/commit/d885eb20006099262c0278932b9f8aca3c1ac97f | 3JavaScript |
static long _btrfs_ioctl_set_received_subvol(struct file *file,
struct btrfs_ioctl_received_subvol_args *sa)
{
struct inode *inode = file_inode(file);
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
struct btrfs_root *root = BTRFS_I(inode)->root;
struct btrfs_root_item *root_item = &root->root_item;
struct btrfs_trans_handle *trans;
struct timespec64 ct = current_time(inode);
int ret = 0;
int received_uuid_changed;
if (!inode_owner_or_capable(inode))
return -EPERM;
ret = mnt_want_write_file(file);
if (ret < 0)
return ret;
down_write(&fs_info->subvol_sem);
if (btrfs_ino(BTRFS_I(inode)) != BTRFS_FIRST_FREE_OBJECTID) {
ret = -EINVAL;
goto out;
}
if (btrfs_root_readonly(root)) {
ret = -EROFS;
goto out;
}
trans = btrfs_start_transaction(root, 3);
if (IS_ERR(trans)) {
ret = PTR_ERR(trans);
trans = NULL;
goto out;
}
sa->rtransid = trans->transid;
sa->rtime.sec = ct.tv_sec;
sa->rtime.nsec = ct.tv_nsec;
received_uuid_changed = memcmp(root_item->received_uuid, sa->uuid,
BTRFS_UUID_SIZE);
if (received_uuid_changed &&
!btrfs_is_empty_uuid(root_item->received_uuid)) {
ret = btrfs_uuid_tree_remove(trans, root_item->received_uuid,
BTRFS_UUID_KEY_RECEIVED_SUBVOL,
root->root_key.objectid);
if (ret && ret != -ENOENT) {
btrfs_abort_transaction(trans, ret);
btrfs_end_transaction(trans);
goto out;
}
}
memcpy(root_item->received_uuid, sa->uuid, BTRFS_UUID_SIZE);
btrfs_set_root_stransid(root_item, sa->stransid);
btrfs_set_root_rtransid(root_item, sa->rtransid);
btrfs_set_stack_timespec_sec(&root_item->stime, sa->stime.sec);
btrfs_set_stack_timespec_nsec(&root_item->stime, sa->stime.nsec);
btrfs_set_stack_timespec_sec(&root_item->rtime, sa->rtime.sec);
btrfs_set_stack_timespec_nsec(&root_item->rtime, sa->rtime.nsec);
ret = btrfs_update_root(trans, fs_info->tree_root,
&root->root_key, &root->root_item);
if (ret < 0) {
btrfs_end_transaction(trans);
goto out;
}
if (received_uuid_changed && !btrfs_is_empty_uuid(sa->uuid)) {
ret = btrfs_uuid_tree_add(trans, sa->uuid,
BTRFS_UUID_KEY_RECEIVED_SUBVOL,
root->root_key.objectid);
if (ret < 0 && ret != -EEXIST) {
btrfs_abort_transaction(trans, ret);
btrfs_end_transaction(trans);
goto out;
}
}
ret = btrfs_commit_transaction(trans);
out:
up_write(&fs_info->subvol_sem);
mnt_drop_write_file(file);
return ret;
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/09ba3bc9dd150457c506e4661380a6183af651c1 | 0CCPP |
static char *parse_timestamp(unsigned long long timestamp) {
static char s[15];
unsigned long long rem;
unsigned int days, hours, mins, secs;
days = timestamp / TSTP_DAY;
rem = timestamp % TSTP_DAY;
hours = rem / TSTP_HOUR;
rem %= TSTP_HOUR;
mins = rem / TSTP_MIN;
rem %= TSTP_MIN;
secs = rem / TSTP_SEC;
snprintf(s, 14, "%3dd %02d:%02d:%02d", days, hours, mins, secs);
return s;
} | 0 | null | -1 | https://github.com/aircrack-ng/aircrack-ng/commit/ff70494dd389ba570dbdbf36f217c28d4381c6b5 | 0CCPP |
public static Plan Get(string planCode)
{
var plan = new Plan();
var statusCode = Client.Instance.PerformRequest(Client.HttpRequestMethod.Get,
Plan.UrlPrefix + Uri.EscapeUriString(planCode),
plan.ReadXml);
return statusCode == HttpStatusCode.NotFound ? null : plan;
} | 1 | 4 | -1 | https://github.com/recurly/recurly-client-dotnet/commit/9eef460c0084afd5c24d66220c8b7a381cf9a1f1 | 1CS |
TEST_F(AsStringGraphTest, FloatScientific) {
TF_ASSERT_OK(Init(DT_FLOAT, "", /*width=*cision=*/-1,
true));
AddInputFromArray<float>(TensorShape({4}), {-42, 0, 3.14159, 42});
TF_ASSERT_OK(RunOpKernel());
Tensor expected(allocator(), DT_STRING, TensorShape({4}));
test::FillValues<tstring>(&expected, {"-4.200000e+01", "0.000000e+00",
"3.141590e+00", "4.200000e+01"});
test::ExpectTensorEqual<tstring>(expected, *GetOutput(0));
} | 0 | null | -1 | https://github.com/tensorflow/tensorflow/commit/33be22c65d86256e6826666662e40dbdfe70ee83 | 0CCPP |
conf_is_ht20(struct ieee80211_conf *conf)
{
return conf->chandef.width == NL80211_CHAN_WIDTH_20;
} | 0 | null | -1 | https://github.com/torvalds/linux/commit/bddc0c411a45d3718ac535a070f349be8eca8d48 | 0CCPP |
def next(self):
if self._nextIndex > 0:
self._last_item = self.item
return super().next()
| 0 | null | -1 | https://github.com/zopefoundation/Zope.git/commit/1d897910139e2c0b11984fc9b78c1da1365bec21 | 4Python |
uniqueName : function(prefix, phash) {
var i = 0, ext = '', p, name;
prefix = this.i18n(prefix);
phash = phash || this.cwd().hash;
if ((p = prefix.indexOf('.txt')) != -1) {
ext = '.txt';
prefix = prefix.substr(0, p);
}
name = prefix+ext;
if (!this.fileByName(name, phash)) {
return name;
}
while (i < 10000) {
name = prefix + ' ' + (++i) + ext;
if (!this.fileByName(name, phash)) {
return name;
}
}
return prefix + Math.random() + ext;
}, | 1 | 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 | -1 | https://github.com/semplon/GeniXCMS/commit/d885eb20006099262c0278932b9f8aca3c1ac97f | 3JavaScript |
static int asn1_encode(sc_context_t *ctx, const struct sc_asn1_entry *asn1,
u8 **ptr, size_t *size, int depth)
{
int r, idx = 0;
u8 *obj = NULL, *buf = NULL, *tmp;
size_t total = 0, objsize;
for (idx = 0; asn1[idx].name != NULL; idx++) {
r = asn1_encode_entry(ctx, &asn1[idx], &obj, &objsize, depth);
if (r) {
if (obj)
free(obj);
if (buf)
free(buf);
return r;
}
if (!objsize)
continue;
tmp = (u8 *) realloc(buf, total + objsize);
if (!tmp) {
if (obj)
free(obj);
if (buf)
free(buf);
return SC_ERROR_OUT_OF_MEMORY;
}
buf = tmp;
memcpy(buf + total, obj, objsize);
free(obj);
obj = NULL;
total += objsize;
}
*ptr = buf;
*size = total;
return 0;
} | 0 | null | -1 | https://github.com/OpenSC/OpenSC/commit/412a6142c27a5973c61ba540e33cdc22d5608e68 | 0CCPP |
document.createElement("tr");ja.className="gePropHeader";var Ba=document.createElement("th");Ba.className="gePropHeaderCell";var Da=document.createElement("img");Da.src=Sidebar.prototype.expandedImage;Da.style.verticalAlign="middle";Ba.appendChild(Da);mxUtils.write(Ba,mxResources.get("property"));ja.style.cursor="pointer";var qa=function(){var za=va.querySelectorAll(".gePropNonHeaderRow");if(Z.editorUi.propertiesCollapsed){Da.src=Sidebar.prototype.collapsedImage;var ta="none";for(var ka=t.childNodes.length-
1;0<=ka;ka--)try{var oa=t.childNodes[ka],sa=oa.nodeName.toUpperCase();"INPUT"!=sa&&"SELECT"!=sa||t.removeChild(oa)}catch(ya){}}else Da.src=Sidebar.prototype.expandedImage,ta="";for(ka=0;ka<za.length;ka++)za[ka].style.display=ta};mxEvent.addListener(ja,"click",function(){Z.editorUi.propertiesCollapsed=!Z.editorUi.propertiesCollapsed;qa()});ja.appendChild(Ba);Ba=document.createElement("th");Ba.className="gePropHeaderCell";Ba.innerHTML=mxResources.get("value");ja.appendChild(Ba);va.appendChild(ja);var Ca= | 0 | null | -1 | https://github.com/jgraph/drawio/commit/c287bef9101d024b1fd59d55ecd530f25000f9d8 | 3JavaScript |
static void read_module(RBuffer *b, ut64 addr, struct minidump_module *module) {
st64 o_addr = r_buf_seek (b, 0, R_BUF_CUR);
r_buf_seek (b, addr, R_BUF_SET);
module->base_of_image = r_buf_read_le64 (b);
module->size_of_image = r_buf_read_le32 (b);
module->check_sum = r_buf_read_le32 (b);
module->time_date_stamp = r_buf_read_le32 (b);
module->module_name_rva = r_buf_read_le32 (b);
module->version_info.dw_signature = r_buf_read_le32 (b);
module->version_info.dw_struc_version = r_buf_read_le32 (b);
module->version_info.dw_file_version_ms = r_buf_read_le32 (b);
module->version_info.dw_file_version_ls = r_buf_read_le32 (b);
module->version_info.dw_product_version_ms = r_buf_read_le32 (b);
module->version_info.dw_product_version_ls = r_buf_read_le32 (b);
module->version_info.dw_file_flags_mask = r_buf_read_le32 (b);
module->version_info.dw_file_flags = r_buf_read_le32 (b);
module->version_info.dw_file_os = r_buf_read_le32 (b);
module->version_info.dw_file_type = r_buf_read_le32 (b);
module->version_info.dw_file_subtype = r_buf_read_le32 (b);
module->version_info.dw_file_date_ms = r_buf_read_le32 (b);
module->version_info.dw_file_date_ls = r_buf_read_le32 (b);
module->cv_record.data_size = r_buf_read_le32 (b);
module->cv_record.rva = r_buf_read_le32 (b);
module->misc_record.data_size = r_buf_read_le32 (b);
module->misc_record.rva = r_buf_read_le32 (b);
module->reserved_0 = r_buf_read_le64 (b);
module->reserved_1 = r_buf_read_le64 (b);
r_buf_seek (b, o_addr, R_BUF_SET);
} | 1 | 0,2 | -1 | https://github.com/radareorg/radare2/commit/27fe8031782d3a06c3998eaa94354867864f9f1b | 0CCPP |
declare function getSetCookie(cookieName: string, value?: string, options?: any): string;
const r: { [elmName: string]: (props?: any, ...children) => RElm } = ReactDOMFactories; | 1 | 0 | -1 | https://github.com/debiki/talkyard/commit/b0310df019887f3464895529c773bc7d85ddcf34 | 5TypeScript |
protected virtual void OnFilteringUrl(FilterUrlEventArgs e)
{
FilterUrl?.Invoke(this, e);
} | 0 | null | -1 | https://github.com/mganss/HtmlSanitizer/commit/a3a7602a44d4155d51ec0fbbedc2a49e9c7e2eb8 | 1CS |
delay: function( time, type ) {
time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
type = type || "fx";
return this.queue( type, function( next, hooks ) {
var timeout = setTimeout( next, time );
hooks.stop = function() {
clearTimeout( timeout );
};
});
}, | 0 | null | -1 | https://github.com/semplon/GeniXCMS/commit/d885eb20006099262c0278932b9f8aca3c1ac97f | 3JavaScript |
void APar_ExtractTrackDetails(char *uint32_buffer,
FILE *isofile,
Trackage *track,
TrackInfo *track_info) {
uint64_t _offset = 0;
APar_TrackLevelInfo(track, "tkhd");
if (APar_read8(isofile, parsedAtoms[track->track_atom].AtomicStart + 8) ==
0) {
if (APar_read8(isofile, parsedAtoms[track->track_atom].AtomicStart + 11) &
1) {
track_info->track_enabled = true;
}
track_info->creation_time =
APar_read32(uint32_buffer,
isofile,
parsedAtoms[track->track_atom].AtomicStart + 12);
track_info->modified_time =
APar_read32(uint32_buffer,
isofile,
parsedAtoms[track->track_atom].AtomicStart + 16);
track_info->duration =
APar_read32(uint32_buffer,
isofile,
parsedAtoms[track->track_atom].AtomicStart + 28);
} else {
track_info->creation_time =
APar_read64(uint32_buffer,
isofile,
parsedAtoms[track->track_atom].AtomicStart + 12);
track_info->modified_time =
APar_read64(uint32_buffer,
isofile,
parsedAtoms[track->track_atom].AtomicStart + 20);
track_info->duration =
APar_read64(uint32_buffer,
isofile,
parsedAtoms[track->track_atom].AtomicStart + 36);
}
APar_TrackLevelInfo(track, "mdhd");
memset(uint32_buffer, 0, 5);
uint16_t packed_language = APar_read16(
uint32_buffer, isofile, parsedAtoms[track->track_atom].AtomicStart + 28);
memset(track_info->unpacked_lang, 0, 4);
APar_UnpackLanguage(
track_info->unpacked_lang,
packed_language);
APar_TrackLevelInfo(track, "hdlr");
memset(uint32_buffer, 0, 5);
track_info->track_type = APar_read32(
uint32_buffer, isofile, parsedAtoms[track->track_atom].AtomicStart + 16);
if (track_info->track_type == 0x736F756E) {
track_info->type_of_track = AUDIO_TRACK;
} else if (track_info->track_type == 0x76696465) {
track_info->type_of_track = VIDEO_TRACK;
}
if (parsedAtoms[track->track_atom].AtomicLength > 34) {
memset(track_info->track_hdlr_name, 0, sizeof(track_info->track_hdlr_name));
APar_readX(track_info->track_hdlr_name,
isofile,
parsedAtoms[track->track_atom].AtomicStart + 32,
std::min((uint64_t)sizeof(track_info->track_hdlr_name),
parsedAtoms[track->track_atom].AtomicLength - 32));
}
APar_TrackLevelInfo(track, "stsd");
memset(uint32_buffer, 0, 5);
track_info->track_codec = APar_read32(
uint32_buffer, isofile, parsedAtoms[track->track_atom].AtomicStart + 20);
if (track_info->type_of_track & VIDEO_TRACK) {
track_info->video_width =
APar_read16(uint32_buffer,
isofile,
parsedAtoms[track->track_atom + 1].AtomicStart + 32);
track_info->video_height =
APar_read16(uint32_buffer,
isofile,
parsedAtoms[track->track_atom + 1].AtomicStart + 34);
track_info->macroblocks =
(track_info->video_width / 16) * (track_info->video_height / 16);
if (track_info->track_codec == 0x61766331 ||
track_info->track_codec == 0x64726D69) {
track_info->contains_esds = false;
APar_TrackLevelInfo(track, "avcC");
track_info->avc_version =
APar_read8(isofile, parsedAtoms[track->track_atom].AtomicStart + 8);
if (track_info->avc_version == 1) {
track_info->profile =
APar_read8(isofile, parsedAtoms[track->track_atom].AtomicStart + 9);
track_info->level = APar_read8(
isofile, parsedAtoms[track->track_atom].AtomicStart + 11);
}
} else if (track_info->track_codec == 0x73323633) {
APar_TrackLevelInfo(track, "d263");
if (memcmp(parsedAtoms[track->track_atom].AtomicName, "d263", 4) == 0) {
APar_Extract_d263_Info(
uint32_buffer, isofile, track->track_atom, track_info);
}
} else {
APar_TrackLevelInfo(track, "esds");
if (memcmp(parsedAtoms[track->track_atom].AtomicName, "esds", 4) == 0) {
APar_Extract_esds_Info(
uint32_buffer,
isofile,
track->track_atom - 1,
track_info);
} else if (track_info->track_codec == 0x73323633) {
track_info->type_of_track = VIDEO_TRACK;
} else if (track_info->track_codec == 0x73616D72 ||
track_info->track_codec == 0x73617762 ||
track_info->track_codec == 0x73617770 ||
track_info->track_codec ==
0x73766D72) {
track_info->type_of_track = AUDIO_TRACK;
} else {
track_info->type_of_track = OTHER_TRACK;
}
}
} else if (track_info->type_of_track & AUDIO_TRACK) {
if (track_info->track_codec == 0x73616D72 ||
track_info->track_codec == 0x73617762 ||
track_info->track_codec == 0x73617770 ||
track_info->track_codec ==
0x73766D72) {
APar_Extract_AMR_Info(
uint32_buffer, isofile, track->track_atom + 2, track_info);
} else if (track_info->track_codec == 0x73657663) {
APar_TrackLevelInfo(track, "devc");
if (memcmp(parsedAtoms[track->track_atom].AtomicName, "devc", 4) == 0) {
APar_Extract_devc_Info(isofile, track->track_atom, track_info);
}
} else if (track_info->track_codec == 0x73716370) {
APar_TrackLevelInfo(track, "dqcp");
if (memcmp(parsedAtoms[track->track_atom].AtomicName, "dqcp", 4) == 0) {
APar_Extract_devc_Info(isofile,
track->track_atom,
track_info);
}
} else if (track_info->track_codec == 0x73736D76) {
APar_TrackLevelInfo(track, "dsmv");
if (memcmp(parsedAtoms[track->track_atom].AtomicName, "dsmv", 4) == 0) {
APar_Extract_devc_Info(isofile,
track->track_atom,
track_info);
}
} else {
APar_Extract_esds_Info(
uint32_buffer, isofile, track->track_atom, track_info);
}
}
if ((track_info->type_of_track & AUDIO_TRACK ||
track_info->type_of_track & VIDEO_TRACK) &&
track_info->avg_bitrate == 0) {
if (track_info->track_codec == 0x616C6163) {
track_info->channels =
APar_read16(uint32_buffer,
isofile,
parsedAtoms[track->track_atom + 1].AtomicStart + 24);
}
}
APar_TrackLevelInfo(track, "stsz");
if (memcmp(parsedAtoms[track->track_atom].AtomicName, "stsz", 4) == 0) {
track_info->sample_aggregate =
calcuate_sample_size(uint32_buffer, isofile, track->track_atom);
}
if (track_info->track_codec >= 0x64726D00 &&
track_info->track_codec <= 0x64726DFF) {
track_info->type_of_track += DRM_PROTECTED_TRACK;
APar_TrackLevelInfo(track, "frma");
memset(uint32_buffer, 0, 5);
track_info->protected_codec = APar_read32(
uint32_buffer, isofile, parsedAtoms[track->track_atom].AtomicStart + 8);
}
if (track_info->contains_esds) {
APar_TrackLevelInfo(track, "esds");
_offset = APar_FindValueInAtom(
uint32_buffer, isofile, track->track_atom, 24, 0x01B2);
if (_offset > 0 && _offset < parsedAtoms[track->track_atom].AtomicLength) {
_offset += 2;
memset(track_info->encoder_name,
0,
parsedAtoms[track->track_atom].AtomicLength - _offset);
APar_readX(track_info->encoder_name,
isofile,
parsedAtoms[track->track_atom].AtomicStart + _offset,
parsedAtoms[track->track_atom].AtomicLength - _offset);
}
}
return;
} | 0 | null | -1 | https://github.com/wez/atomicparsley/commit/d72ccf06c98259d7261e0f3ac4fd8717778782c1 | 0CCPP |
STATIC void GC_init_lib_bounds(void)
{
if (GC_libpthread_start != 0) return;
GC_init();
if (!GC_text_mapping("libpthread-",
&GC_libpthread_start, &GC_libpthread_end)) {
WARN("Failed to find libpthread.so text mapping: Expect crash\n", 0);
GC_libpthread_start = (ptr_t)1;
}
if (!GC_text_mapping("ld-", &GC_libld_start, &GC_libld_end)) {
WARN("Failed to find ld.so text mapping: Expect crash\n", 0);
}
} | 0 | null | -1 | https://github.com/ivmai/bdwgc/commit/be9df82919960214ee4b9d3313523bff44fd99e1 | 0CCPP |
dhcpv4_print(netdissect_options *ndo,
const u_char *cp, u_int length, int indent)
{
u_int i, t;
const u_char *tlv, *value;
uint8_t type, optlen;
i = 0;
while (i < length) {
tlv = cp + i;
type = (uint8_t)tlv[0];
optlen = (uint8_t)tlv[1];
value = tlv + 2;
ND_PRINT((ndo, "\n"));
for (t = indent; t > 0; t--)
ND_PRINT((ndo, "\t"));
ND_PRINT((ndo, "%s", tok2str(dh4opt_str, "Unknown", type)));
ND_PRINT((ndo," (%u)", optlen + 2 ));
switch (type) {
case DH4OPT_DNS_SERVERS:
case DH4OPT_NTP_SERVERS: {
if (optlen < 4 || optlen % 4 != 0) {
return -1;
}
for (t = 0; t < optlen; t += 4)
ND_PRINT((ndo, " %s", ipaddr_string(ndo, value + t)));
}
break;
case DH4OPT_DOMAIN_SEARCH: {
const u_char *tp = value;
while (tp < value + optlen) {
ND_PRINT((ndo, " "));
if ((tp = ns_nprint(ndo, tp, value + optlen)) == NULL)
return -1;
}
}
break;
}
i += 2 + optlen;
}
return 0;
} | 1 | null | -1 | https://github.com/the-tcpdump-group/tcpdump/commit/c2f6833dddecf2d5fb89c9c898eee9981da342ed | 0CCPP |
http.createRequest = function(options) {
options = options || {};
var request = _createHeader();
request.version = options.version || 'HTTP/1.1';
request.method = options.method || null;
request.path = options.path || null;
request.body = options.body || null;
request.bodyDeflated = false;
request.flashApi = null;
var headers = options.headers || [];
if(!forge.util.isArray(headers)) {
headers = [headers];
}
for(var i = 0; i < headers.length; ++i) {
for(var name in headers[i]) {
request.appendField(name, headers[i][name]);
}
}
request.addCookie = function(cookie) {
var value = '';
var field = request.getField('Cookie');
if(field !== null) {
value = field + '; ';
}
var now = _getUtcTime(new Date());
value += cookie.name + '=' + cookie.value;
request.setField('Cookie', value);
};
request.toString = function() {
if(request.getField('User-Agent') === null) {
request.setField('User-Agent', 'forge.http 1.0');
}
if(request.getField('Accept') === null) {
request.setField('Accept', '*/*');
}
if(request.getField('Connection') === null) {
request.setField('Connection', 'keep-alive');
request.setField('Keep-Alive', '115');
}
if(request.flashApi !== null &&
request.getField('Accept-Encoding') === null) {
request.setField('Accept-Encoding', 'deflate');
}
if(request.flashApi !== null && request.body !== null &&
request.getField('Content-Encoding') === null &&
!request.bodyDeflated && request.body.length > 100) {
request.body = forge.util.deflate(request.flashApi, request.body);
request.bodyDeflated = true;
request.setField('Content-Encoding', 'deflate');
request.setField('Content-Length', request.body.length);
} else if(request.body !== null) {
request.setField('Content-Length', request.body.length);
}
var rval =
request.method.toUpperCase() + ' ' + request.path + ' ' +
request.version + '\r\n';
for(var name in request.fields) {
var fields = request.fields[name];
for(var i = 0; i < fields.length; ++i) {
rval += name + ': ' + fields[i] + '\r\n';
}
}
rval += '\r\n';
return rval;
};
return request;
}; | 0 | null | -1 | https://github.com/digitalbazaar/forge/commit/db8016c805371e72b06d8e2edfe0ace0df934a5e | 3JavaScript |
private void OnWalletUpdate(SteamUser.WalletInfoCallback callback) {
if (callback == null) {
throw new ArgumentNullException(nameof(callback));
}
WalletBalance = callback.LongBalance;
WalletCurrency = callback.Currency;
} | 0 | null | -1 | https://github.com/JustArchiNET/ArchiSteamFarm/commit/4cd581ec041912cf199c5512fe6d1dcaec0594c0 | 1CS |
static LUA_FUNCTION(openssl_x509_check_email)
{
X509 * cert = CHECK_OBJECT(1, X509, "openssl.x509");
if (lua_isstring(L, 2))
{
const char *email = lua_tostring(L, 2);
lua_pushboolean(L, X509_check_email(cert, email, strlen(email), 0));
}
else
{
lua_pushboolean(L, 0);
}
return 1;
} | 1 | 3,4,5,6,7,8,9,10,11,12 | -1 | https://github.com/zhaozg/lua-openssl/commit/a6dc186dd4b6b9e329a93cca3e7e3cfccfdf3cca | 0CCPP |
static int8_t parse_ext_option(uint16_t *dst, uint8_t **packet_data_pptr, uint8_t *packet_data_start_ptr, uint16_t packet_len, uint16_t *message_left)
{
uint16_t option_number = *dst;
if (option_number == 13) {
uint8_t option_ext;
int8_t read_result = sn_coap_parser_read_packet_u8(&option_ext,
*packet_data_pptr,
packet_data_start_ptr,
packet_len);
if (read_result != 0) {
tr_error("sn_coap_parser_options_parse - **packet_data_pptr overflow !");
return -1;
}
else {
option_number += option_ext;
*message_left = sn_coap_parser_move_packet_ptr(packet_data_pptr,
packet_data_start_ptr,
packet_len,
1);
}
} else if (option_number == 14) {
int8_t read_result = sn_coap_parser_read_packet_u16(&option_number,
*packet_data_pptr,
packet_data_start_ptr,
packet_len);
if (read_result != 0) {
tr_error("sn_coap_parser_options_parse - **packet_data_pptr overflow !");
return -1;
}
else {
option_number += 269;
*message_left = sn_coap_parser_move_packet_ptr(packet_data_pptr,
packet_data_start_ptr,
packet_len,
2);
}
}
else if (option_number == 15) {
tr_error("sn_coap_parser_options_parse - invalid option number(15)!");
return -1;
}
*dst = option_number;
return 0;
} | 1 | 14,15,16,17,18,30,31,32,33,34 | -1 | https://github.com/mjurczak/mbed-coap/commit/4647a68e364401e81dbd370728127d844f221d93 | 0CCPP |
TEST_F(TestCustomAllocation, CustomInputAlloc_AllocateTensorsBefore) {
ASSERT_EQ(interpreter_->AllocateTensors(), kTfLiteOk);
AssignCustomAllocForTensor(interpreter_->inputs()[0],
kDefaultTensorAlignment);
VerifyInvoke();
} | 0 | null | -1 | https://github.com/tensorflow/tensorflow/commit/e11f55585f614645b360563072ffeb5c3eeff162 | 0CCPP |
public static byte[] serializeToBytes(final Object payload) throws IOException {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
serializeToStream(bos, payload);
return bos.toByteArray();
} | 1 | 0,1,2,3,4 | -1 | https://github.com/NationalSecurityAgency/emissary/commit/40260b1ec1f76cc92361702cc14fa1e4388e19d7 | 2Java |
error_t tms570EthInit(NetInterface *interface)
{
error_t error;
uint_t channel;
uint32_t temp;
TRACE_INFO("Initializing TMS570 Ethernet MAC...\r\n");
nicDriverInterface = interface;
tms570EthInitGpio(interface);
EMAC_CTRL_SOFTRESET_R = EMAC_SOFTRESET_SOFTRESET;
while((EMAC_CTRL_SOFTRESET_R & EMAC_SOFTRESET_SOFTRESET) != 0)
{
}
EMAC_SOFTRESET_R = EMAC_SOFTRESET_SOFTRESET;
while((EMAC_SOFTRESET_R & EMAC_SOFTRESET_SOFTRESET) != 0)
{
}
temp = (MDIO_INPUT_CLK / MDIO_OUTPUT_CLK) - 1;
MDIO_CONTROL_R = MDIO_CONTROL_ENABLE |
MDIO_CONTROL_FAULTENB | (temp & MDIO_CONTROL_CLKDIV);
if(interface->phyDriver != NULL)
{
error = interface->phyDriver->init(interface);
}
else if(interface->switchDriver != NULL)
{
error = interface->switchDriver->init(interface);
}
else
{
error = ERROR_FAILURE;
}
if(error)
{
return error;
}
EMAC_MACCONTROL_R = 0;
EMAC_RXCONTROL_R = 0;
EMAC_TXCONTROL_R = 0;
for(channel = EMAC_CH0; channel <= EMAC_CH7; channel++)
{
EMAC_TXHDP_R(channel) = 0;
EMAC_TXCP_R(channel) = 0;
EMAC_RXHDP_R(channel) = 0;
EMAC_RXCP_R(channel) = 0;
}
EMAC_MACSRCADDRHI_R = interface->macAddr.b[0] |
(interface->macAddr.b[1] << 8) |
(interface->macAddr.b[2] << 16) |
(interface->macAddr.b[3] << 24);
EMAC_MACSRCADDRLO_R = interface->macAddr.b[4] |
(interface->macAddr.b[5] << 8);
EMAC_MACINDEX_R = EMAC_CH0;
EMAC_MACADDRHI_R = interface->macAddr.b[0] |
(interface->macAddr.b[1] << 8) |
(interface->macAddr.b[2] << 16) |
(interface->macAddr.b[3] << 24);
temp = interface->macAddr.b[4] |
(interface->macAddr.b[5] << 8);
EMAC_MACADDRLO_R = EMAC_MACADDRLO_VALID | EMAC_MACADDRLO_MATCHFILT |
(EMAC_CH0 << EMAC_MACADDRLO_CHANNEL_SHIFT) | temp;
for(channel = EMAC_CH1; channel <= EMAC_CH7; channel++)
{
EMAC_MACINDEX_R = channel;
EMAC_MACADDRLO_R = (channel << EMAC_MACADDRLO_CHANNEL_SHIFT);
}
EMAC_MACHASH1_R = 0;
EMAC_MACHASH2_R = 0;
EMAC_RXBUFFEROFFSET_R = 0;
EMAC_RXUNICASTCLEAR_R = 0xFF;
EMAC_RXUNICASTSET_R |= (1 << EMAC_CH0);
EMAC_RXMBPENABLE_R = EMAC_RXMBPENABLE_RXPASSCRC;
EMAC_RXMBPENABLE_R |= EMAC_RXMBPENABLE_RXBROADEN |
(EMAC_CH0 << EMAC_RXMBPENABLE_RXBROADCH_SHIFT);
EMAC_RXMBPENABLE_R |= EMAC_RXMBPENABLE_RXMULTEN |
(EMAC_CH0 << EMAC_RXMBPENABLE_RXMULTCH_SHIFT);
vimChannelMap(77, TMS570_ETH_TX_IRQ_CHANNEL,
(t_isrFuncPTR) tms570EthTxIrqHandler);
vimChannelMap(79, TMS570_ETH_RX_IRQ_CHANNEL,
(t_isrFuncPTR) tms570EthRxIrqHandler);
EMAC_TXINTMASKCLEAR_R = 0xFF;
EMAC_RXINTMASKCLEAR_R = 0xFF;
EMAC_TXINTMASKSET_R = (1 << EMAC_CH0);
EMAC_RXINTMASKSET_R = (1 << EMAC_CH0);
tms570EthInitBufferDesc(interface);
EMAC_RXHDP_R(EMAC_CH0) = (uint32_t) rxCurBufferDesc;
EMAC_TXCONTROL_R = EMAC_TXCONTROL_TXEN;
EMAC_RXCONTROL_R = EMAC_RXCONTROL_RXEN;
EMAC_MACCONTROL_R = EMAC_MACCONTROL_GMIIEN;
EMAC_CTRL_CnTXEN_R(EMAC_CORE0) |= (1 << EMAC_CH0);
EMAC_CTRL_CnRXEN_R(EMAC_CORE0) |= (1 << EMAC_CH0);
osSetEvent(&interface->nicTxEvent);
return NO_ERROR;
} | 0 | null | -1 | https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366 | 0CCPP |
static int renameColumnSelectCb(Walker *pWalker, Select *p){
renameWalkWith(pWalker, p);
return WRC_Continue;
} | 1 | null | -1 | https://github.com/sqlite/sqlite/commit/38096961c7cd109110ac21d3ed7dad7e0cb0ae06 | 0CCPP |
componentToHex = function(c) {
var hex;
hex = c.toString(16);
if (hex.length === 1) {
return '0' + hex;
} else {
return hex;
}
}; | 0 | null | -1 | https://github.com/mycolorway/simditor/commit/ef01a643cbb7f8163535d6bfb71135f80ec6a6fd | 3JavaScript |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.