hash
int64 -9,197,960,073,880,366,000
9,199,363,627B
| project
stringclasses 2
values | size
int64 2
5.68k
| label
int64 0
1
| functionSource
stringlengths 31
235k
|
|---|---|---|---|---|
6,320,019,361,007,853,000 | debian | 12 | 0 | static void copy_frame_default ( AVFrame * f , const uint8_t * src , int src_stride , int linelen , int height ) {
int i ;
uint8_t * dst = f -> data [ 0 ] ;
dst += ( height - 1 ) * f -> linesize [ 0 ] ;
for ( i = height ;
i ;
i -- ) {
memcpy ( dst , src , linelen ) ;
src += src_stride ;
dst -= f -> linesize [ 0 ] ;
}
} |
7,607,805,321,589,710,000 | debian | 9 | 0 | static int zcvs ( i_ctx_t * i_ctx_p ) {
os_ptr op = osp ;
int code ;
check_write_type ( * op , t_string ) ;
check_op ( 2 ) ;
code = convert_to_string ( imemory , op - 1 , op ) ;
if ( code >= 0 ) pop ( 1 ) ;
return code ;
} |
-7,899,851,216,763,490,000 | chrome | 84 | 0 | static void U_CALLCONV ucnv_toUnicode_UTF8_OFFSETS_LOGIC ( UConverterToUnicodeArgs * args , UErrorCode * err ) {
UConverter * cnv = args -> converter ;
const unsigned char * mySource = ( unsigned char * ) args -> source ;
UChar * myTarget = args -> target ;
int32_t * myOffsets = args -> offsets ;
int32_t offsetNum = 0 ;
const unsigned char * sourceLimit = ( unsigned char * ) args -> sourceLimit ;
const UChar * targetLimit = args -> targetLimit ;
unsigned char * toUBytes = cnv -> toUBytes ;
UBool isCESU8 = hasCESU8Data ( cnv ) ;
uint32_t ch , ch2 = 0 ;
int32_t i , inBytes ;
if ( cnv -> toUnicodeStatus && myTarget < targetLimit ) {
inBytes = cnv -> mode ;
i = cnv -> toULength ;
cnv -> toULength = 0 ;
ch = cnv -> toUnicodeStatus ;
cnv -> toUnicodeStatus = 0 ;
goto morebytes ;
}
while ( mySource < sourceLimit && myTarget < targetLimit ) {
ch = * ( mySource ++ ) ;
if ( ch < 0x80 ) {
* ( myTarget ++ ) = ( UChar ) ch ;
* ( myOffsets ++ ) = offsetNum ++ ;
}
else {
toUBytes [ 0 ] = ( char ) ch ;
inBytes = bytesFromUTF8 [ ch ] ;
i = 1 ;
morebytes : while ( i < inBytes ) {
if ( mySource < sourceLimit ) {
toUBytes [ i ] = ( char ) ( ch2 = * mySource ) ;
if ( ! U8_IS_TRAIL ( ch2 ) ) {
break ;
}
ch = ( ch << 6 ) + ch2 ;
++ mySource ;
i ++ ;
}
else {
cnv -> toUnicodeStatus = ch ;
cnv -> mode = inBytes ;
cnv -> toULength = ( int8_t ) i ;
goto donefornow ;
}
}
ch -= offsetsFromUTF8 [ inBytes ] ;
if ( i == inBytes && ch <= MAXIMUM_UTF && ch >= utf8_minChar32 [ i ] && ( isCESU8 ? i <= 3 : ! U_IS_SURROGATE ( ch ) ) ) {
if ( ch <= MAXIMUM_UCS2 ) {
* ( myTarget ++ ) = ( UChar ) ch ;
* ( myOffsets ++ ) = offsetNum ;
}
else {
ch -= HALF_BASE ;
* ( myTarget ++ ) = ( UChar ) ( ( ch >> HALF_SHIFT ) + SURROGATE_HIGH_START ) ;
* ( myOffsets ++ ) = offsetNum ;
ch = ( ch & HALF_MASK ) + SURROGATE_LOW_START ;
if ( myTarget < targetLimit ) {
* ( myTarget ++ ) = ( UChar ) ch ;
* ( myOffsets ++ ) = offsetNum ;
}
else {
cnv -> UCharErrorBuffer [ 0 ] = ( UChar ) ch ;
cnv -> UCharErrorBufferLength = 1 ;
* err = U_BUFFER_OVERFLOW_ERROR ;
}
}
offsetNum += i ;
}
else {
cnv -> toULength = ( int8_t ) i ;
* err = U_ILLEGAL_CHAR_FOUND ;
break ;
}
}
}
donefornow : if ( mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS ( * err ) ) {
* err = U_BUFFER_OVERFLOW_ERROR ;
}
args -> target = myTarget ;
args -> source = ( const char * ) mySource ;
args -> offsets = myOffsets ;
} |
5,610,242,550,647,094,000 | debian | 23 | 1 | static int fill_vaapi_ReferenceFrames ( VAPictureParameterBufferH264 * pic_param , H264Context * h ) {
DPB dpb ;
int i ;
dpb . size = 0 ;
dpb . max_size = FF_ARRAY_ELEMS ( pic_param -> ReferenceFrames ) ;
dpb . va_pics = pic_param -> ReferenceFrames ;
for ( i = 0 ;
i < dpb . max_size ;
i ++ ) init_vaapi_pic ( & dpb . va_pics [ i ] ) ;
for ( i = 0 ;
i < h -> short_ref_count ;
i ++ ) {
Picture * const pic = h -> short_ref [ i ] ;
if ( pic && pic -> f . reference && dpb_add ( & dpb , pic ) < 0 ) return - 1 ;
}
for ( i = 0 ;
i < 16 ;
i ++ ) {
Picture * const pic = h -> long_ref [ i ] ;
if ( pic && pic -> f . reference && dpb_add ( & dpb , pic ) < 0 ) return - 1 ;
}
return 0 ;
} |
7,092,216,800,726,730,000 | debian | 4 | 0 | static int dissect_h245_ConnectionIdentifier ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_ConnectionIdentifier , ConnectionIdentifier_sequence ) ;
return offset ;
} |
8,572,106,347,813,672,000 | debian | 18 | 0 | static int verify_address_len ( const void * p ) {
const struct sadb_address * sp = p ;
const struct sockaddr * addr = ( const struct sockaddr * ) ( sp + 1 ) ;
const struct sockaddr_in * sin ;
# if IS_ENABLED ( CONFIG_IPV6 ) const struct sockaddr_in6 * sin6 ;
# endif int len ;
switch ( addr -> sa_family ) {
case AF_INET : len = DIV_ROUND_UP ( sizeof ( * sp ) + sizeof ( * sin ) , sizeof ( uint64_t ) ) ;
if ( sp -> sadb_address_len != len || sp -> sadb_address_prefixlen > 32 ) return - EINVAL ;
break ;
# if IS_ENABLED ( CONFIG_IPV6 ) case AF_INET6 : len = DIV_ROUND_UP ( sizeof ( * sp ) + sizeof ( * sin6 ) , sizeof ( uint64_t ) ) ;
if ( sp -> sadb_address_len != len || sp -> sadb_address_prefixlen > 128 ) return - EINVAL ;
break ;
# endif default : return - EINVAL ;
break ;
}
return 0 ;
} |
914,926,989,019,402,500 | debian | 11 | 0 | int xsnprintf_func ( char * str , int n , const char * fmt , ... ) {
va_list a ;
int ret ;
va_start ( a , fmt ) ;
ret = vsnprintf_func ( str , n , fmt , a ) ;
va_end ( a ) ;
if ( ret < 0 ) {
ret = n ;
}
return ret ;
} |
6,250,095,321,513,210,000 | debian | 25 | 1 | rfbBool rfbSendTextChatMessage ( rfbClientPtr cl , uint32_t length , char * buffer ) {
rfbTextChatMsg tc ;
int bytesToSend = 0 ;
memset ( ( char * ) & tc , 0 , sizeof ( tc ) ) ;
tc . type = rfbTextChat ;
tc . length = Swap32IfLE ( length ) ;
switch ( length ) {
case rfbTextChatOpen : case rfbTextChatClose : case rfbTextChatFinished : bytesToSend = 0 ;
break ;
default : bytesToSend = length ;
if ( bytesToSend > rfbTextMaxSize ) bytesToSend = rfbTextMaxSize ;
}
if ( cl -> ublen + sz_rfbTextChatMsg + bytesToSend > UPDATE_BUF_SIZE ) {
if ( ! rfbSendUpdateBuf ( cl ) ) return FALSE ;
}
memcpy ( & cl -> updateBuf [ cl -> ublen ] , ( char * ) & tc , sz_rfbTextChatMsg ) ;
cl -> ublen += sz_rfbTextChatMsg ;
if ( bytesToSend > 0 ) {
memcpy ( & cl -> updateBuf [ cl -> ublen ] , buffer , bytesToSend ) ;
cl -> ublen += bytesToSend ;
}
rfbStatRecordMessageSent ( cl , rfbTextChat , sz_rfbTextChatMsg + bytesToSend , sz_rfbTextChatMsg + bytesToSend ) ;
if ( ! rfbSendUpdateBuf ( cl ) ) return FALSE ;
return TRUE ;
} |
-2,928,324,134,072,492,500 | debian | 4 | 0 | void remove_tap_listener_iax2_calls ( void ) {
remove_tap_listener ( & ( the_tapinfo_struct . iax2_dummy ) ) ;
have_iax2_tap_listener = FALSE ;
} |
8,460,430,819,945,784,000 | debian | 4 | 0 | static inline uint8_t NVRAM_get_byte ( m48t59_t * nvram , uint32_t addr ) {
m48t59_set_addr ( nvram , addr ) ;
return m48t59_read ( nvram ) ;
} |
8,971,837,418,146,377,000 | chrome | 3 | 0 | void xsltFreeLocale ( xsltLocale locale ) {
# ifdef XSLT_LOCALE_XLOCALE freelocale ( locale ) ;
# endif } |
-5,493,081,488,206,620,000 | debian | 17 | 0 | static const char * cmd_upload_keep_files ( cmd_parms * cmd , void * _dcfg , const char * p1 ) {
directory_config * dcfg = ( directory_config * ) _dcfg ;
if ( dcfg == NULL ) return NULL ;
if ( strcasecmp ( p1 , "on" ) == 0 ) {
dcfg -> upload_keep_files = KEEP_FILES_ON ;
}
else if ( strcasecmp ( p1 , "off" ) == 0 ) {
dcfg -> upload_keep_files = KEEP_FILES_OFF ;
}
else if ( strcasecmp ( p1 , "relevantonly" ) == 0 ) {
dcfg -> upload_keep_files = KEEP_FILES_RELEVANT_ONLY ;
}
else {
return apr_psprintf ( cmd -> pool , "ModSecurity: Invalid setting for SecUploadKeepFiles: %s" , p1 ) ;
}
return NULL ;
} |
-4,370,220,620,850,259,000 | debian | 16 | 0 | static void sipr_decode_lp ( float * lsfnew , const float * lsfold , float * Az , int num_subfr ) {
double lsfint [ LP_FILTER_ORDER ] ;
int i , j ;
float t , t0 = 1.0 / num_subfr ;
t = t0 * 0.5 ;
for ( i = 0 ;
i < num_subfr ;
i ++ ) {
for ( j = 0 ;
j < LP_FILTER_ORDER ;
j ++ ) lsfint [ j ] = lsfold [ j ] * ( 1 - t ) + t * lsfnew [ j ] ;
ff_amrwb_lsp2lpc ( lsfint , Az , LP_FILTER_ORDER ) ;
Az += LP_FILTER_ORDER ;
t += t0 ;
}
} |
6,600,620,671,673,715,000 | debian | 18 | 0 | static byte * i_alloc_string_immovable ( gs_memory_t * mem , uint nbytes , client_name_t cname ) {
gs_ref_memory_t * const imem = ( gs_ref_memory_t * ) mem ;
byte * str ;
uint asize ;
clump_t * cp ;
nbytes += HDR_ID_OFFSET ;
# ifdef MEMENTO if ( Memento_failThisEvent ( ) ) return NULL ;
# endif asize = string_clump_space ( nbytes ) + sizeof ( clump_head_t ) ;
cp = alloc_acquire_clump ( imem , ( ulong ) asize , true , "large string clump" ) ;
if ( cp == 0 ) return 0 ;
cp -> c_alone = true ;
str = cp -> ctop = cp -> climit - nbytes ;
if_debug4m ( 'a' , mem , "[a%d|+>L]%s(%u) = 0x%lx\n" , alloc_trace_space ( imem ) , client_name_string ( cname ) , nbytes , ( ulong ) str ) ;
gs_alloc_fill ( str , gs_alloc_fill_alloc , nbytes ) ;
str += HDR_ID_OFFSET ;
ASSIGN_HDR_ID ( str ) ;
return str ;
} |
5,917,118,798,851,366,000 | debian | 20 | 0 | void proto_register_zbee_zcl_met_idt ( void ) {
static hf_register_info hf [ ] = {
{
& hf_zbee_zcl_met_idt_attr_id , {
"Attribute" , "zbee_zcl_ha.metidt.attr_id" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_met_idt_attr_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_met_idt_meter_type_id , {
"Meter Type ID" , "zbee_zcl_ha.metidt.attr.meter_type.id" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_met_idt_meter_type_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_met_idt_data_quality_id , {
"Data Quality ID" , "zbee_zcl_ha.metidt.attr.data_quality.id" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_met_idt_data_quality_names ) , 0x00 , NULL , HFILL }
}
}
;
proto_zbee_zcl_met_idt = proto_register_protocol ( "ZigBee ZCL Meter Identification" , "ZCL Meter Identification" , ZBEE_PROTOABBREV_ZCL_METIDT ) ;
proto_register_field_array ( proto_zbee_zcl_met_idt , hf , array_length ( hf ) ) ;
register_dissector ( ZBEE_PROTOABBREV_ZCL_METIDT , dissect_zbee_zcl_met_idt , proto_zbee_zcl_met_idt ) ;
} |
-6,552,851,419,396,579,000 | debian | 9 | 0 | static int dissect_printer_attributes ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep ) {
guint32 attributes ;
static const int * hf_attributes [ ] = {
& hf_printer_attributes_published , & hf_printer_attributes_raw_only , & hf_printer_attributes_enable_bidi , & hf_printer_attributes_work_offline , & hf_printer_attributes_do_complete_first , & hf_printer_attributes_keep_printed_jobs , & hf_printer_attributes_enable_devq , & hf_printer_attributes_local , & hf_printer_attributes_hidden , & hf_printer_attributes_network , & hf_printer_attributes_shared , & hf_printer_attributes_default , & hf_printer_attributes_direct , & hf_printer_attributes_queued , NULL }
;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , NULL , di , drep , - 1 , & attributes ) ;
proto_tree_add_bitmask_value_with_flags ( tree , tvb , offset - 4 , hf_printer_attributes , ett_printer_attributes , hf_attributes , attributes , BMT_NO_APPEND ) ;
return offset ;
} |
2,521,579,609,370,336,000 | debian | 12 | 0 | int dtls1_send_server_done ( SSL * s ) {
unsigned char * p ;
if ( s -> state == SSL3_ST_SW_SRVR_DONE_A ) {
p = ( unsigned char * ) s -> init_buf -> data ;
p = dtls1_set_message_header ( s , p , SSL3_MT_SERVER_DONE , 0 , 0 , 0 ) ;
s -> state = SSL3_ST_SW_SRVR_DONE_B ;
s -> init_num = DTLS1_HM_HEADER_LENGTH ;
s -> init_off = 0 ;
dtls1_buffer_message ( s , 0 ) ;
}
return ( dtls1_do_write ( s , SSL3_RT_HANDSHAKE ) ) ;
} |
8,280,197,130,498,467,000 | debian | 3 | 0 | static void incomplete_class_write_property ( zval * object , zval * member , zval * value , const zend_literal * key TSRMLS_DC ) {
incomplete_class_message ( object , E_NOTICE TSRMLS_CC ) ;
} |
-7,187,272,991,279,784,000 | debian | 5 | 0 | static void cpu_halt_signal ( void * opaque , int irq , int level ) {
if ( level && current_cpu ) {
cpu_interrupt ( current_cpu , CPU_INTERRUPT_HALT ) ;
}
} |
7,163,083,127,251,596,000 | chrome | 18 | 0 | IN_PROC_BROWSER_TEST_F ( BookmarkBubbleSignInDelegateTest , BrowserRemoved ) {
Browser * extra_browser = CreateBrowser ( profile ( ) ) ;
ReplaceBlank ( extra_browser ) ;
int starting_tab_count = extra_browser -> tab_strip_model ( ) -> count ( ) ;
scoped_ptr < BookmarkBubbleDelegate > delegate ;
delegate . reset ( new BookmarkBubbleSignInDelegate ( browser ( ) ) ) ;
BrowserList : : SetLastActive ( extra_browser ) ;
browser ( ) -> tab_strip_model ( ) -> CloseAllTabs ( ) ;
content : : RunAllPendingInMessageLoop ( ) ;
delegate -> OnSignInLinkClicked ( ) ;
if ( kHasProfileChooser ) {
EXPECT_TRUE ( ProfileChooserView : : IsShowing ( ) ) ;
}
else {
int tab_count = extra_browser -> tab_strip_model ( ) -> count ( ) ;
EXPECT_EQ ( starting_tab_count + 1 , tab_count ) ;
}
} |
3,672,688,962,041,927,000 | chrome | 26 | 0 | const vpx_codec_cx_pkt_t * vpx_codec_get_cx_data ( vpx_codec_ctx_t * ctx , vpx_codec_iter_t * iter ) {
const vpx_codec_cx_pkt_t * pkt = NULL ;
if ( ctx ) {
if ( ! iter ) ctx -> err = VPX_CODEC_INVALID_PARAM ;
else if ( ! ctx -> iface || ! ctx -> priv ) ctx -> err = VPX_CODEC_ERROR ;
else if ( ! ( ctx -> iface -> caps & VPX_CODEC_CAP_ENCODER ) ) ctx -> err = VPX_CODEC_INCAPABLE ;
else pkt = ctx -> iface -> enc . get_cx_data ( get_alg_priv ( ctx ) , iter ) ;
}
if ( pkt && pkt -> kind == VPX_CODEC_CX_FRAME_PKT ) {
vpx_codec_priv_t * const priv = ctx -> priv ;
char * const dst_buf = ( char * ) priv -> enc . cx_data_dst_buf . buf ;
if ( dst_buf && pkt -> data . raw . buf != dst_buf && pkt -> data . raw . sz + priv -> enc . cx_data_pad_before + priv -> enc . cx_data_pad_after <= priv -> enc . cx_data_dst_buf . sz ) {
vpx_codec_cx_pkt_t * modified_pkt = & priv -> enc . cx_data_pkt ;
memcpy ( dst_buf + priv -> enc . cx_data_pad_before , pkt -> data . raw . buf , pkt -> data . raw . sz ) ;
* modified_pkt = * pkt ;
modified_pkt -> data . raw . buf = dst_buf ;
modified_pkt -> data . raw . sz += priv -> enc . cx_data_pad_before + priv -> enc . cx_data_pad_after ;
pkt = modified_pkt ;
}
if ( dst_buf == pkt -> data . raw . buf ) {
priv -> enc . cx_data_dst_buf . buf = dst_buf + pkt -> data . raw . sz ;
priv -> enc . cx_data_dst_buf . sz -= pkt -> data . raw . sz ;
}
}
return pkt ;
} |
355,220,887,711,506,900 | debian | 54 | 0 | static double var_eq_const ( VariableStatData * vardata , Oid operator , Datum constval , bool constisnull , bool varonleft ) {
double selec ;
bool isdefault ;
Oid opfuncoid ;
if ( constisnull ) return 0.0 ;
if ( vardata -> isunique && vardata -> rel && vardata -> rel -> tuples >= 1.0 ) return 1.0 / vardata -> rel -> tuples ;
if ( HeapTupleIsValid ( vardata -> statsTuple ) && statistic_proc_security_check ( vardata , ( opfuncoid = get_opcode ( operator ) ) ) ) {
Form_pg_statistic stats ;
Datum * values ;
int nvalues ;
float4 * numbers ;
int nnumbers ;
bool match = false ;
int i ;
stats = ( Form_pg_statistic ) GETSTRUCT ( vardata -> statsTuple ) ;
if ( get_attstatsslot ( vardata -> statsTuple , vardata -> atttype , vardata -> atttypmod , STATISTIC_KIND_MCV , InvalidOid , NULL , & values , & nvalues , & numbers , & nnumbers ) ) {
FmgrInfo eqproc ;
fmgr_info ( opfuncoid , & eqproc ) ;
for ( i = 0 ;
i < nvalues ;
i ++ ) {
if ( varonleft ) match = DatumGetBool ( FunctionCall2Coll ( & eqproc , DEFAULT_COLLATION_OID , values [ i ] , constval ) ) ;
else match = DatumGetBool ( FunctionCall2Coll ( & eqproc , DEFAULT_COLLATION_OID , constval , values [ i ] ) ) ;
if ( match ) break ;
}
}
else {
values = NULL ;
numbers = NULL ;
i = nvalues = nnumbers = 0 ;
}
if ( match ) {
selec = numbers [ i ] ;
}
else {
double sumcommon = 0.0 ;
double otherdistinct ;
for ( i = 0 ;
i < nnumbers ;
i ++ ) sumcommon += numbers [ i ] ;
selec = 1.0 - sumcommon - stats -> stanullfrac ;
CLAMP_PROBABILITY ( selec ) ;
otherdistinct = get_variable_numdistinct ( vardata , & isdefault ) - nnumbers ;
if ( otherdistinct > 1 ) selec /= otherdistinct ;
if ( nnumbers > 0 && selec > numbers [ nnumbers - 1 ] ) selec = numbers [ nnumbers - 1 ] ;
}
free_attstatsslot ( vardata -> atttype , values , nvalues , numbers , nnumbers ) ;
}
else {
selec = 1.0 / get_variable_numdistinct ( vardata , & isdefault ) ;
}
CLAMP_PROBABILITY ( selec ) ;
return selec ;
} |
-5,357,254,031,401,750,000 | debian | 10 | 0 | int luaD_protectedparser ( lua_State * L , ZIO * z , const char * name ) {
struct SParser p ;
int status ;
p . z = z ;
p . name = name ;
luaZ_initbuffer ( L , & p . buff ) ;
status = luaD_pcall ( L , f_parser , & p , savestack ( L , L -> top ) , L -> errfunc ) ;
luaZ_freebuffer ( L , & p . buff ) ;
return status ;
} |
-2,423,144,171,479,607,000 | debian | 4 | 0 | static void pdf_run_BI ( fz_context * ctx , pdf_processor * proc , fz_image * image ) {
pdf_run_processor * pr = ( pdf_run_processor * ) proc ;
pdf_show_image ( ctx , pr , image ) ;
} |
-8,721,757,784,652,752,000 | debian | 19 | 0 | int ratestrtosize ( char * s , uint_fast32_t rawsize , uint_fast32_t * size ) {
jpc_flt_t f ;
if ( strchr ( s , 'B' ) ) {
* size = atoi ( s ) ;
}
else {
f = atof ( s ) ;
if ( f < 0 ) {
* size = 0 ;
}
else if ( f > 1.0 ) {
* size = rawsize + 1 ;
}
else {
* size = f * rawsize ;
}
}
return 0 ;
} |
1,245,821,301,839,614,700 | debian | 290 | 1 | static void copy_move_file ( CopyMoveJob * copy_job , GFile * src , GFile * dest_dir , gboolean same_fs , gboolean unique_names , char * * dest_fs_type , SourceInfo * source_info , TransferInfo * transfer_info , GHashTable * debuting_files , GdkPoint * position , gboolean overwrite , gboolean * skipped_file , gboolean readonly_source_fs ) {
GFile * dest , * new_dest ;
g_autofree gchar * dest_uri = NULL ;
GError * error ;
GFileCopyFlags flags ;
char * primary , * secondary , * details ;
int response ;
ProgressData pdata ;
gboolean would_recurse , is_merge ;
CommonJob * job ;
gboolean res ;
int unique_name_nr ;
gboolean handled_invalid_filename ;
job = ( CommonJob * ) copy_job ;
if ( should_skip_file ( job , src ) ) {
* skipped_file = TRUE ;
return ;
}
unique_name_nr = 1 ;
handled_invalid_filename = * dest_fs_type != NULL ;
if ( unique_names ) {
dest = get_unique_target_file ( src , dest_dir , same_fs , * dest_fs_type , unique_name_nr ++ ) ;
}
else if ( copy_job -> target_name != NULL ) {
dest = get_target_file_with_custom_name ( src , dest_dir , * dest_fs_type , same_fs , copy_job -> target_name ) ;
}
else {
dest = get_target_file ( src , dest_dir , * dest_fs_type , same_fs ) ;
}
if ( test_dir_is_parent ( dest_dir , src ) ) {
if ( job -> skip_all_error ) {
goto out ;
}
primary = copy_job -> is_move ? g_strdup ( _ ( "You cannot move a folder into itself." ) ) : g_strdup ( _ ( "You cannot copy a folder into itself." ) ) ;
secondary = g_strdup ( _ ( "The destination folder is inside the source folder." ) ) ;
response = run_cancel_or_skip_warning ( job , primary , secondary , NULL , source_info -> num_files , source_info -> num_files - transfer_info -> num_files ) ;
if ( response == 0 || response == GTK_RESPONSE_DELETE_EVENT ) {
abort_job ( job ) ;
}
else if ( response == 1 ) {
job -> skip_all_error = TRUE ;
}
else if ( response == 2 ) {
}
else {
g_assert_not_reached ( ) ;
}
goto out ;
}
if ( test_dir_is_parent ( src , dest ) ) {
if ( job -> skip_all_error ) {
goto out ;
}
primary = copy_job -> is_move ? g_strdup ( _ ( "You cannot move a file over itself." ) ) : g_strdup ( _ ( "You cannot copy a file over itself." ) ) ;
secondary = g_strdup ( _ ( "The source file would be overwritten by the destination." ) ) ;
response = run_cancel_or_skip_warning ( job , primary , secondary , NULL , source_info -> num_files , source_info -> num_files - transfer_info -> num_files ) ;
if ( response == 0 || response == GTK_RESPONSE_DELETE_EVENT ) {
abort_job ( job ) ;
}
else if ( response == 1 ) {
job -> skip_all_error = TRUE ;
}
else if ( response == 2 ) {
}
else {
g_assert_not_reached ( ) ;
}
goto out ;
}
retry : error = NULL ;
flags = G_FILE_COPY_NOFOLLOW_SYMLINKS ;
if ( overwrite ) {
flags |= G_FILE_COPY_OVERWRITE ;
}
if ( readonly_source_fs ) {
flags |= G_FILE_COPY_TARGET_DEFAULT_PERMS ;
}
pdata . job = copy_job ;
pdata . last_size = 0 ;
pdata . source_info = source_info ;
pdata . transfer_info = transfer_info ;
if ( copy_job -> is_move ) {
res = g_file_move ( src , dest , flags , job -> cancellable , copy_file_progress_callback , & pdata , & error ) ;
}
else {
res = g_file_copy ( src , dest , flags , job -> cancellable , copy_file_progress_callback , & pdata , & error ) ;
}
if ( res ) {
GFile * real ;
real = map_possibly_volatile_file_to_real ( dest , job -> cancellable , & error ) ;
if ( real == NULL ) {
res = FALSE ;
}
else {
g_object_unref ( dest ) ;
dest = real ;
}
}
if ( res ) {
transfer_info -> num_files ++ ;
report_copy_progress ( copy_job , source_info , transfer_info ) ;
if ( debuting_files ) {
dest_uri = g_file_get_uri ( dest ) ;
if ( position ) {
nautilus_file_changes_queue_schedule_position_set ( dest , * position , job -> screen_num ) ;
}
else if ( eel_uri_is_desktop ( dest_uri ) ) {
nautilus_file_changes_queue_schedule_position_remove ( dest ) ;
}
g_hash_table_replace ( debuting_files , g_object_ref ( dest ) , GINT_TO_POINTER ( TRUE ) ) ;
}
if ( copy_job -> is_move ) {
nautilus_file_changes_queue_file_moved ( src , dest ) ;
}
else {
nautilus_file_changes_queue_file_added ( dest ) ;
}
if ( copy_job -> desktop_location != NULL && g_file_equal ( copy_job -> desktop_location , dest_dir ) && is_trusted_desktop_file ( src , job -> cancellable ) ) {
mark_desktop_file_trusted ( job , job -> cancellable , dest , FALSE ) ;
}
if ( job -> undo_info != NULL ) {
nautilus_file_undo_info_ext_add_origin_target_pair ( NAUTILUS_FILE_UNDO_INFO_EXT ( job -> undo_info ) , src , dest ) ;
}
g_object_unref ( dest ) ;
return ;
}
if ( ! handled_invalid_filename && IS_IO_ERROR ( error , INVALID_FILENAME ) ) {
handled_invalid_filename = TRUE ;
g_assert ( * dest_fs_type == NULL ) ;
* dest_fs_type = query_fs_type ( dest_dir , job -> cancellable ) ;
if ( unique_names ) {
new_dest = get_unique_target_file ( src , dest_dir , same_fs , * dest_fs_type , unique_name_nr ) ;
}
else {
new_dest = get_target_file ( src , dest_dir , * dest_fs_type , same_fs ) ;
}
if ( ! g_file_equal ( dest , new_dest ) ) {
g_object_unref ( dest ) ;
dest = new_dest ;
g_error_free ( error ) ;
goto retry ;
}
else {
g_object_unref ( new_dest ) ;
}
}
if ( ! overwrite && IS_IO_ERROR ( error , EXISTS ) ) {
gboolean is_merge ;
FileConflictResponse * response ;
g_error_free ( error ) ;
if ( unique_names ) {
g_object_unref ( dest ) ;
dest = get_unique_target_file ( src , dest_dir , same_fs , * dest_fs_type , unique_name_nr ++ ) ;
goto retry ;
}
is_merge = FALSE ;
if ( is_dir ( dest ) && is_dir ( src ) ) {
is_merge = TRUE ;
}
if ( ( is_merge && job -> merge_all ) || ( ! is_merge && job -> replace_all ) ) {
overwrite = TRUE ;
goto retry ;
}
if ( job -> skip_all_conflict ) {
goto out ;
}
response = handle_copy_move_conflict ( job , src , dest , dest_dir ) ;
if ( response -> id == GTK_RESPONSE_CANCEL || response -> id == GTK_RESPONSE_DELETE_EVENT ) {
file_conflict_response_free ( response ) ;
abort_job ( job ) ;
}
else if ( response -> id == CONFLICT_RESPONSE_SKIP ) {
if ( response -> apply_to_all ) {
job -> skip_all_conflict = TRUE ;
}
file_conflict_response_free ( response ) ;
}
else if ( response -> id == CONFLICT_RESPONSE_REPLACE ) {
if ( response -> apply_to_all ) {
if ( is_merge ) {
job -> merge_all = TRUE ;
}
else {
job -> replace_all = TRUE ;
}
}
overwrite = TRUE ;
file_conflict_response_free ( response ) ;
goto retry ;
}
else if ( response -> id == CONFLICT_RESPONSE_RENAME ) {
g_object_unref ( dest ) ;
dest = get_target_file_for_display_name ( dest_dir , response -> new_name ) ;
file_conflict_response_free ( response ) ;
goto retry ;
}
else {
g_assert_not_reached ( ) ;
}
}
else if ( overwrite && IS_IO_ERROR ( error , IS_DIRECTORY ) ) {
gboolean existing_file_deleted ;
DeleteExistingFileData data ;
g_error_free ( error ) ;
data . job = job ;
data . source = src ;
existing_file_deleted = delete_file_recursively ( dest , job -> cancellable , existing_file_removed_callback , & data ) ;
if ( existing_file_deleted ) {
goto retry ;
}
}
else if ( IS_IO_ERROR ( error , WOULD_RECURSE ) || IS_IO_ERROR ( error , WOULD_MERGE ) ) {
is_merge = error -> code == G_IO_ERROR_WOULD_MERGE ;
would_recurse = error -> code == G_IO_ERROR_WOULD_RECURSE ;
g_error_free ( error ) ;
if ( overwrite && would_recurse ) {
error = NULL ;
if ( ! g_file_delete ( dest , job -> cancellable , & error ) && ! IS_IO_ERROR ( error , NOT_FOUND ) ) {
if ( job -> skip_all_error ) {
g_error_free ( error ) ;
goto out ;
}
if ( copy_job -> is_move ) {
primary = f ( _ ( "Error while moving “%B”." ) , src ) ;
}
else {
primary = f ( _ ( "Error while copying “%B”." ) , src ) ;
}
secondary = f ( _ ( "Could not remove the already existing file with the same name in %F." ) , dest_dir ) ;
details = error -> message ;
response = run_warning ( job , primary , secondary , details , TRUE , CANCEL , SKIP_ALL , SKIP , NULL ) ;
g_error_free ( error ) ;
if ( response == 0 || response == GTK_RESPONSE_DELETE_EVENT ) {
abort_job ( job ) ;
}
else if ( response == 1 ) {
job -> skip_all_error = TRUE ;
}
else if ( response == 2 ) {
}
else {
g_assert_not_reached ( ) ;
}
goto out ;
}
if ( error ) {
g_error_free ( error ) ;
error = NULL ;
}
nautilus_file_changes_queue_file_removed ( dest ) ;
}
if ( is_merge ) {
same_fs = FALSE ;
}
if ( ! copy_move_directory ( copy_job , src , & dest , same_fs , would_recurse , dest_fs_type , source_info , transfer_info , debuting_files , skipped_file , readonly_source_fs ) ) {
g_assert ( * dest_fs_type != NULL ) ;
handled_invalid_filename = TRUE ;
goto retry ;
}
g_object_unref ( dest ) ;
return ;
}
else if ( IS_IO_ERROR ( error , CANCELLED ) ) {
g_error_free ( error ) ;
}
else {
if ( job -> skip_all_error ) {
g_error_free ( error ) ;
goto out ;
}
primary = f ( _ ( "Error while copying “%B”." ) , src ) ;
secondary = f ( _ ( "There was an error copying the file into %F." ) , dest_dir ) ;
details = error -> message ;
response = run_cancel_or_skip_warning ( job , primary , secondary , details , source_info -> num_files , source_info -> num_files - transfer_info -> num_files ) ;
g_error_free ( error ) ;
if ( response == 0 || response == GTK_RESPONSE_DELETE_EVENT ) {
abort_job ( job ) ;
}
else if ( response == 1 ) {
job -> skip_all_error = TRUE ;
}
else if ( response == 2 ) {
}
else {
g_assert_not_reached ( ) ;
}
}
out : * skipped_file = TRUE ;
g_object_unref ( dest ) ;
} |
-7,777,644,912,037,189,000 | debian | 47 | 0 | static int dissect_udvm_reference_operand_memory ( guint8 * buff , guint operand_address , guint16 * value , guint * result_dest ) {
guint bytecode ;
guint16 operand ;
guint offset = operand_address ;
guint test_bits ;
guint8 temp_data ;
guint16 temp_data16 ;
if ( operand_address >= UDVM_MEMORY_SIZE ) return - 1 ;
bytecode = buff [ operand_address ] ;
test_bits = bytecode >> 7 ;
if ( test_bits == 1 ) {
test_bits = bytecode >> 6 ;
if ( test_bits == 2 ) {
temp_data = buff [ operand_address ] & 0x3f ;
operand = temp_data << 8 ;
temp_data = buff [ ( operand_address + 1 ) & 0xffff ] ;
operand = operand | temp_data ;
operand = ( operand * 2 ) ;
* result_dest = operand ;
temp_data16 = buff [ operand ] << 8 ;
temp_data16 = temp_data16 | buff [ ( operand + 1 ) & 0xffff ] ;
* value = temp_data16 ;
offset = offset + 2 ;
}
else {
operand_address ++ ;
operand = buff [ operand_address ] << 8 ;
operand = operand | buff [ ( operand_address + 1 ) & 0xffff ] ;
* result_dest = operand ;
temp_data16 = buff [ operand ] << 8 ;
temp_data16 = temp_data16 | buff [ ( operand + 1 ) & 0xffff ] ;
* value = temp_data16 ;
offset = offset + 3 ;
}
}
else {
operand = ( bytecode & 0x7f ) ;
operand = ( operand * 2 ) ;
* result_dest = operand ;
temp_data16 = buff [ operand ] << 8 ;
temp_data16 = temp_data16 | buff [ ( operand + 1 ) & 0xffff ] ;
* value = temp_data16 ;
offset ++ ;
}
if ( offset >= UDVM_MEMORY_SIZE || * result_dest >= UDVM_MEMORY_SIZE - 1 ) return - 1 ;
return offset ;
} |
-281,311,800,725,760,060 | debian | 7 | 0 | static void set_sample_rate_params ( AVCodecContext * avctx ) {
TAKDecContext * s = avctx -> priv_data ;
int shift = 3 - ( avctx -> sample_rate / 11025 ) ;
shift = FFMAX ( 0 , shift ) ;
s -> uval = FFALIGN ( avctx -> sample_rate + 511 >> 9 , 4 ) << shift ;
s -> subframe_scale = FFALIGN ( avctx -> sample_rate + 511 >> 9 , 4 ) << 1 ;
} |
6,968,788,423,709,606,000 | debian | 165 | 0 | static MagickBooleanType EncodeImage ( const ImageInfo * image_info , Image * image , const size_t data_size ) {
# define MaxCode ( number_bits ) ( ( one << ( number_bits ) ) - 1 ) # define MaxHashTable 5003 # define MaxGIFBits 12UL # define MaxGIFTable ( 1UL << MaxGIFBits ) # define GIFOutputCode ( code ) \ {
if ( bits > 0 ) datum |= ( code ) << bits ;
else datum = code ;
bits += number_bits ;
while ( bits >= 8 ) {
packet [ length ++ ] = ( unsigned char ) ( datum & 0xff ) ;
if ( length >= 254 ) {
( void ) WriteBlobByte ( image , ( unsigned char ) length ) ;
( void ) WriteBlob ( image , length , packet ) ;
length = 0 ;
}
datum >>= 8 ;
bits -= 8 ;
}
if ( free_code > max_code ) {
number_bits ++ ;
if ( number_bits == MaxGIFBits ) max_code = MaxGIFTable ;
else max_code = MaxCode ( number_bits ) ;
}
\ }
IndexPacket index ;
short * hash_code , * hash_prefix , waiting_code ;
size_t bits , clear_code , datum , end_of_information_code , free_code , length , max_code , next_pixel , number_bits , one , pass ;
ssize_t displacement , offset , k , y ;
unsigned char * packet , * hash_suffix ;
assert ( image != ( Image * ) NULL ) ;
one = 1 ;
packet = ( unsigned char * ) AcquireQuantumMemory ( 256 , sizeof ( * packet ) ) ;
hash_code = ( short * ) AcquireQuantumMemory ( MaxHashTable , sizeof ( * hash_code ) ) ;
hash_prefix = ( short * ) AcquireQuantumMemory ( MaxHashTable , sizeof ( * hash_prefix ) ) ;
hash_suffix = ( unsigned char * ) AcquireQuantumMemory ( MaxHashTable , sizeof ( * hash_suffix ) ) ;
if ( ( packet == ( unsigned char * ) NULL ) || ( hash_code == ( short * ) NULL ) || ( hash_prefix == ( short * ) NULL ) || ( hash_suffix == ( unsigned char * ) NULL ) ) {
if ( packet != ( unsigned char * ) NULL ) packet = ( unsigned char * ) RelinquishMagickMemory ( packet ) ;
if ( hash_code != ( short * ) NULL ) hash_code = ( short * ) RelinquishMagickMemory ( hash_code ) ;
if ( hash_prefix != ( short * ) NULL ) hash_prefix = ( short * ) RelinquishMagickMemory ( hash_prefix ) ;
if ( hash_suffix != ( unsigned char * ) NULL ) hash_suffix = ( unsigned char * ) RelinquishMagickMemory ( hash_suffix ) ;
return ( MagickFalse ) ;
}
( void ) ResetMagickMemory ( hash_code , 0 , MaxHashTable * sizeof ( * hash_code ) ) ;
( void ) ResetMagickMemory ( hash_prefix , 0 , MaxHashTable * sizeof ( * hash_prefix ) ) ;
( void ) ResetMagickMemory ( hash_suffix , 0 , MaxHashTable * sizeof ( * hash_suffix ) ) ;
number_bits = data_size ;
max_code = MaxCode ( number_bits ) ;
clear_code = ( ( short ) one << ( data_size - 1 ) ) ;
end_of_information_code = clear_code + 1 ;
free_code = clear_code + 2 ;
length = 0 ;
datum = 0 ;
bits = 0 ;
GIFOutputCode ( clear_code ) ;
offset = 0 ;
pass = 0 ;
waiting_code = 0 ;
for ( y = 0 ;
y < ( ssize_t ) image -> rows ;
y ++ ) {
register const IndexPacket * magick_restrict indexes ;
register const PixelPacket * magick_restrict p ;
register ssize_t x ;
p = GetVirtualPixels ( image , 0 , offset , image -> columns , 1 , & image -> exception ) ;
if ( p == ( const PixelPacket * ) NULL ) break ;
indexes = GetVirtualIndexQueue ( image ) ;
if ( y == 0 ) {
waiting_code = ( short ) ( * indexes ) ;
p ++ ;
}
for ( x = ( ssize_t ) ( y == 0 ? 1 : 0 ) ;
x < ( ssize_t ) image -> columns ;
x ++ ) {
index = ( IndexPacket ) ( ( size_t ) GetPixelIndex ( indexes + x ) & 0xff ) ;
p ++ ;
k = ( ssize_t ) ( ( ( size_t ) index << ( MaxGIFBits - 8 ) ) + waiting_code ) ;
if ( k >= MaxHashTable ) k -= MaxHashTable ;
next_pixel = MagickFalse ;
displacement = 1 ;
if ( hash_code [ k ] > 0 ) {
if ( ( hash_prefix [ k ] == waiting_code ) && ( hash_suffix [ k ] == ( unsigned char ) index ) ) {
waiting_code = hash_code [ k ] ;
continue ;
}
if ( k != 0 ) displacement = MaxHashTable - k ;
for ( ;
;
) {
k -= displacement ;
if ( k < 0 ) k += MaxHashTable ;
if ( hash_code [ k ] == 0 ) break ;
if ( ( hash_prefix [ k ] == waiting_code ) && ( hash_suffix [ k ] == ( unsigned char ) index ) ) {
waiting_code = hash_code [ k ] ;
next_pixel = MagickTrue ;
break ;
}
}
if ( next_pixel != MagickFalse ) continue ;
}
GIFOutputCode ( ( size_t ) waiting_code ) ;
if ( free_code < MaxGIFTable ) {
hash_code [ k ] = ( short ) free_code ++ ;
hash_prefix [ k ] = waiting_code ;
hash_suffix [ k ] = ( unsigned char ) index ;
}
else {
for ( k = 0 ;
k < MaxHashTable ;
k ++ ) hash_code [ k ] = 0 ;
free_code = clear_code + 2 ;
GIFOutputCode ( clear_code ) ;
number_bits = data_size ;
max_code = MaxCode ( number_bits ) ;
}
waiting_code = ( short ) index ;
}
if ( image_info -> interlace == NoInterlace ) offset ++ ;
else switch ( pass ) {
case 0 : default : {
offset += 8 ;
if ( offset >= ( ssize_t ) image -> rows ) {
pass ++ ;
offset = 4 ;
}
break ;
}
case 1 : {
offset += 8 ;
if ( offset >= ( ssize_t ) image -> rows ) {
pass ++ ;
offset = 2 ;
}
break ;
}
case 2 : {
offset += 4 ;
if ( offset >= ( ssize_t ) image -> rows ) {
pass ++ ;
offset = 1 ;
}
break ;
}
case 3 : {
offset += 2 ;
break ;
}
}
}
GIFOutputCode ( ( size_t ) waiting_code ) ;
GIFOutputCode ( end_of_information_code ) ;
if ( bits > 0 ) {
packet [ length ++ ] = ( unsigned char ) ( datum & 0xff ) ;
if ( length >= 254 ) {
( void ) WriteBlobByte ( image , ( unsigned char ) length ) ;
( void ) WriteBlob ( image , length , packet ) ;
length = 0 ;
}
}
if ( length > 0 ) {
( void ) WriteBlobByte ( image , ( unsigned char ) length ) ;
( void ) WriteBlob ( image , length , packet ) ;
}
hash_suffix = ( unsigned char * ) RelinquishMagickMemory ( hash_suffix ) ;
hash_prefix = ( short * ) RelinquishMagickMemory ( hash_prefix ) ;
hash_code = ( short * ) RelinquishMagickMemory ( hash_code ) ;
packet = ( unsigned char * ) RelinquishMagickMemory ( packet ) ;
return ( MagickTrue ) ;
} |
-7,237,039,260,294,671,000 | debian | 3 | 0 | static int dissect_nlm4_share ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , void * data _U_ ) {
return dissect_nlm_share ( tvb , 0 , pinfo , tree , 4 , ( rpc_call_info_value * ) data ) ;
} |
4,187,524,518,637,656,600 | debian | 21 | 0 | int __glob_pattern_type ( pattern , quote ) const char * pattern ;
int quote ;
{
register const char * p ;
int ret = 0 ;
for ( p = pattern ;
* p != '\0' ;
++ p ) switch ( * p ) {
case '?' : case '*' : return 1 ;
case '\\' : if ( quote ) {
if ( p [ 1 ] != '\0' ) ++ p ;
ret |= 2 ;
}
break ;
case '[' : ret |= 4 ;
break ;
case ']' : if ( ret & 4 ) return 1 ;
break ;
}
return ret ;
} |
-4,960,438,251,319,819,000 | chrome | 49 | 0 | static int calc_arf_boost ( VP9_COMP * cpi , int offset , int f_frames , int b_frames , int * f_boost , int * b_boost ) {
TWO_PASS * const twopass = & cpi -> twopass ;
int i ;
double boost_score = 0.0 ;
double mv_ratio_accumulator = 0.0 ;
double decay_accumulator = 1.0 ;
double this_frame_mv_in_out = 0.0 ;
double mv_in_out_accumulator = 0.0 ;
double abs_mv_in_out_accumulator = 0.0 ;
int arf_boost ;
int flash_detected = 0 ;
for ( i = 0 ;
i < f_frames ;
++ i ) {
const FIRSTPASS_STATS * this_frame = read_frame_stats ( twopass , i + offset ) ;
if ( this_frame == NULL ) break ;
accumulate_frame_motion_stats ( this_frame , & this_frame_mv_in_out , & mv_in_out_accumulator , & abs_mv_in_out_accumulator , & mv_ratio_accumulator ) ;
flash_detected = detect_flash ( twopass , i + offset ) || detect_flash ( twopass , i + offset + 1 ) ;
if ( ! flash_detected ) {
decay_accumulator *= get_prediction_decay_rate ( & cpi -> common , this_frame ) ;
decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR ? MIN_DECAY_FACTOR : decay_accumulator ;
}
boost_score += decay_accumulator * calc_frame_boost ( cpi , this_frame , this_frame_mv_in_out , GF_MAX_BOOST ) ;
}
* f_boost = ( int ) boost_score ;
boost_score = 0.0 ;
mv_ratio_accumulator = 0.0 ;
decay_accumulator = 1.0 ;
this_frame_mv_in_out = 0.0 ;
mv_in_out_accumulator = 0.0 ;
abs_mv_in_out_accumulator = 0.0 ;
for ( i = - 1 ;
i >= - b_frames ;
-- i ) {
const FIRSTPASS_STATS * this_frame = read_frame_stats ( twopass , i + offset ) ;
if ( this_frame == NULL ) break ;
accumulate_frame_motion_stats ( this_frame , & this_frame_mv_in_out , & mv_in_out_accumulator , & abs_mv_in_out_accumulator , & mv_ratio_accumulator ) ;
flash_detected = detect_flash ( twopass , i + offset ) || detect_flash ( twopass , i + offset + 1 ) ;
if ( ! flash_detected ) {
decay_accumulator *= get_prediction_decay_rate ( & cpi -> common , this_frame ) ;
decay_accumulator = decay_accumulator < MIN_DECAY_FACTOR ? MIN_DECAY_FACTOR : decay_accumulator ;
}
boost_score += decay_accumulator * calc_frame_boost ( cpi , this_frame , this_frame_mv_in_out , GF_MAX_BOOST ) ;
}
* b_boost = ( int ) boost_score ;
arf_boost = ( * f_boost + * b_boost ) ;
if ( arf_boost < ( ( b_frames + f_frames ) * 20 ) ) arf_boost = ( ( b_frames + f_frames ) * 20 ) ;
return arf_boost ;
} |
-7,076,754,245,473,579,000 | chrome | 7 | 1 | static void evhttp_maybe_add_content_length_header ( struct evkeyvalq * headers , long content_length ) {
if ( evhttp_find_header ( headers , "Transfer-Encoding" ) == NULL && evhttp_find_header ( headers , "Content-Length" ) == NULL ) {
char len [ 12 ] ;
evutil_snprintf ( len , sizeof ( len ) , "%ld" , content_length ) ;
evhttp_add_header ( headers , "Content-Length" , len ) ;
}
} |
-1,929,262,071,302,712,000 | debian | 37 | 0 | static void * Type_MPEmatrix_Read ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , cmsUInt32Number * nItems , cmsUInt32Number SizeOfTag ) {
cmsStage * mpe ;
cmsUInt16Number InputChans , OutputChans ;
cmsUInt32Number nElems , i ;
cmsFloat64Number * Matrix ;
cmsFloat64Number * Offsets ;
if ( ! _cmsReadUInt16Number ( io , & InputChans ) ) return NULL ;
if ( ! _cmsReadUInt16Number ( io , & OutputChans ) ) return NULL ;
nElems = InputChans * OutputChans ;
Matrix = ( cmsFloat64Number * ) _cmsCalloc ( self -> ContextID , nElems , sizeof ( cmsFloat64Number ) ) ;
if ( Matrix == NULL ) return NULL ;
Offsets = ( cmsFloat64Number * ) _cmsCalloc ( self -> ContextID , OutputChans , sizeof ( cmsFloat64Number ) ) ;
if ( Offsets == NULL ) {
_cmsFree ( self -> ContextID , Matrix ) ;
return NULL ;
}
for ( i = 0 ;
i < nElems ;
i ++ ) {
cmsFloat32Number v ;
if ( ! _cmsReadFloat32Number ( io , & v ) ) return NULL ;
Matrix [ i ] = v ;
}
for ( i = 0 ;
i < OutputChans ;
i ++ ) {
cmsFloat32Number v ;
if ( ! _cmsReadFloat32Number ( io , & v ) ) return NULL ;
Offsets [ i ] = v ;
}
mpe = cmsStageAllocMatrix ( self -> ContextID , OutputChans , InputChans , Matrix , Offsets ) ;
_cmsFree ( self -> ContextID , Matrix ) ;
_cmsFree ( self -> ContextID , Offsets ) ;
* nItems = 1 ;
return mpe ;
cmsUNUSED_PARAMETER ( SizeOfTag ) ;
} |
-2,607,754,285,145,856,500 | debian | 16 | 0 | static void isofile_connect_hardlink_files ( struct iso9660 * iso9660 ) {
struct archive_rb_node * n ;
struct hardlink * hl ;
struct isofile * target , * nf ;
ARCHIVE_RB_TREE_FOREACH ( n , & ( iso9660 -> hardlink_rbtree ) ) {
hl = ( struct hardlink * ) n ;
target = hl -> file_list . first ;
archive_entry_set_nlink ( target -> entry , hl -> nlink ) ;
for ( nf = target -> hlnext ;
nf != NULL ;
nf = nf -> hlnext ) {
nf -> hardlink_target = target ;
archive_entry_set_nlink ( nf -> entry , hl -> nlink ) ;
}
}
} |
2,820,551,931,453,396,000 | debian | 24 | 0 | int jas_image_addfmt ( int id , char * name , char * ext , char * desc , jas_image_fmtops_t * ops ) {
jas_image_fmtinfo_t * fmtinfo ;
assert ( id >= 0 && name && ext && ops ) ;
if ( jas_image_numfmts >= JAS_IMAGE_MAXFMTS ) {
return - 1 ;
}
fmtinfo = & jas_image_fmtinfos [ jas_image_numfmts ] ;
fmtinfo -> id = id ;
if ( ! ( fmtinfo -> name = jas_strdup ( name ) ) ) {
return - 1 ;
}
if ( ! ( fmtinfo -> ext = jas_strdup ( ext ) ) ) {
jas_free ( fmtinfo -> name ) ;
return - 1 ;
}
if ( ! ( fmtinfo -> desc = jas_strdup ( desc ) ) ) {
jas_free ( fmtinfo -> name ) ;
jas_free ( fmtinfo -> ext ) ;
return - 1 ;
}
fmtinfo -> ops = * ops ;
++ jas_image_numfmts ;
return 0 ;
} |
-5,280,794,106,681,745,000 | debian | 18 | 0 | static gboolean gst_asf_demux_check_buffer_is_header ( GstASFDemux * demux , GstBuffer * buf ) {
AsfObject obj ;
GstMapInfo map ;
gboolean valid ;
g_assert ( buf != NULL ) ;
GST_LOG_OBJECT ( demux , "Checking if buffer is a header" ) ;
gst_buffer_map ( buf , & map , GST_MAP_READ ) ;
if ( map . size < ASF_OBJECT_HEADER_SIZE ) {
gst_buffer_unmap ( buf , & map ) ;
return FALSE ;
}
valid = asf_demux_peek_object ( demux , map . data , ASF_OBJECT_HEADER_SIZE , & obj , TRUE ) ;
gst_buffer_unmap ( buf , & map ) ;
if ( valid && obj . id == ASF_OBJ_HEADER ) {
return TRUE ;
}
return FALSE ;
} |
5,400,542,917,484,464,000 | chrome | 91 | 1 | vpx_codec_err_t vpx_svc_init ( SvcContext * svc_ctx , vpx_codec_ctx_t * codec_ctx , vpx_codec_iface_t * iface , vpx_codec_enc_cfg_t * enc_cfg ) {
vpx_codec_err_t res ;
int i ;
SvcInternal * const si = get_svc_internal ( svc_ctx ) ;
if ( svc_ctx == NULL || codec_ctx == NULL || iface == NULL || enc_cfg == NULL ) {
return VPX_CODEC_INVALID_PARAM ;
}
if ( si == NULL ) return VPX_CODEC_MEM_ERROR ;
si -> codec_ctx = codec_ctx ;
si -> width = enc_cfg -> g_w ;
si -> height = enc_cfg -> g_h ;
if ( enc_cfg -> kf_max_dist < 2 ) {
svc_log ( svc_ctx , SVC_LOG_ERROR , "key frame distance too small: %d\n" , enc_cfg -> kf_max_dist ) ;
return VPX_CODEC_INVALID_PARAM ;
}
si -> kf_dist = enc_cfg -> kf_max_dist ;
if ( svc_ctx -> spatial_layers == 0 ) svc_ctx -> spatial_layers = VPX_SS_DEFAULT_LAYERS ;
if ( svc_ctx -> spatial_layers < 1 || svc_ctx -> spatial_layers > VPX_SS_MAX_LAYERS ) {
svc_log ( svc_ctx , SVC_LOG_ERROR , "spatial layers: invalid value: %d\n" , svc_ctx -> spatial_layers ) ;
return VPX_CODEC_INVALID_PARAM ;
}
res = parse_quantizer_values ( svc_ctx , si -> quantizers ) ;
if ( res != VPX_CODEC_OK ) return res ;
res = parse_scale_factors ( svc_ctx , si -> scale_factors ) ;
if ( res != VPX_CODEC_OK ) return res ;
res = parse_options ( svc_ctx , si -> options ) ;
if ( res != VPX_CODEC_OK ) return res ;
if ( svc_ctx -> spatial_layers < 1 ) svc_ctx -> spatial_layers = 1 ;
if ( svc_ctx -> spatial_layers > VPX_SS_MAX_LAYERS ) svc_ctx -> spatial_layers = VPX_SS_MAX_LAYERS ;
if ( svc_ctx -> temporal_layers < 1 ) svc_ctx -> temporal_layers = 1 ;
if ( svc_ctx -> temporal_layers > VPX_TS_MAX_LAYERS ) svc_ctx -> temporal_layers = VPX_TS_MAX_LAYERS ;
si -> layers = svc_ctx -> spatial_layers ;
if ( si -> layers > 1 ) {
float total = 0 ;
float alloc_ratio [ VPX_SS_MAX_LAYERS ] = {
0 }
;
assert ( si -> layers <= VPX_SS_MAX_LAYERS ) ;
for ( i = 0 ;
i < si -> layers ;
++ i ) {
int pos = i + VPX_SS_MAX_LAYERS - svc_ctx -> spatial_layers ;
if ( pos < VPX_SS_MAX_LAYERS && si -> scaling_factor_den [ pos ] > 0 ) {
alloc_ratio [ i ] = ( float ) ( si -> scaling_factor_num [ pos ] * 1.0 / si -> scaling_factor_den [ pos ] ) ;
alloc_ratio [ i ] *= alloc_ratio [ i ] ;
total += alloc_ratio [ i ] ;
}
}
for ( i = 0 ;
i < si -> layers ;
++ i ) {
if ( total > 0 ) {
enc_cfg -> ss_target_bitrate [ i ] = ( unsigned int ) ( enc_cfg -> rc_target_bitrate * alloc_ratio [ i ] / total ) ;
}
}
}
# if CONFIG_SPATIAL_SVC for ( i = 0 ;
i < si -> layers ;
++ i ) enc_cfg -> ss_enable_auto_alt_ref [ i ] = si -> enable_auto_alt_ref [ i ] ;
# endif if ( svc_ctx -> temporal_layers > 1 ) {
int i ;
for ( i = 0 ;
i < svc_ctx -> temporal_layers ;
++ i ) {
enc_cfg -> ts_target_bitrate [ i ] = enc_cfg -> rc_target_bitrate / svc_ctx -> temporal_layers ;
enc_cfg -> ts_rate_decimator [ i ] = 1 << ( svc_ctx -> temporal_layers - 1 - i ) ;
}
}
enc_cfg -> ss_number_layers = si -> layers ;
enc_cfg -> ts_number_layers = svc_ctx -> temporal_layers ;
enc_cfg -> rc_dropframe_thresh = 0 ;
enc_cfg -> rc_resize_allowed = 0 ;
if ( enc_cfg -> g_pass == VPX_RC_ONE_PASS ) {
enc_cfg -> rc_min_quantizer = 33 ;
enc_cfg -> rc_max_quantizer = 33 ;
}
enc_cfg -> rc_undershoot_pct = 100 ;
enc_cfg -> rc_overshoot_pct = 15 ;
enc_cfg -> rc_buf_initial_sz = 500 ;
enc_cfg -> rc_buf_optimal_sz = 600 ;
enc_cfg -> rc_buf_sz = 1000 ;
if ( enc_cfg -> g_error_resilient == 0 && si -> use_multiple_frame_contexts == 0 ) enc_cfg -> g_error_resilient = 1 ;
res = vpx_codec_enc_init ( codec_ctx , iface , enc_cfg , VPX_CODEC_USE_PSNR ) ;
if ( res != VPX_CODEC_OK ) {
svc_log ( svc_ctx , SVC_LOG_ERROR , "svc_enc_init error\n" ) ;
return res ;
}
vpx_codec_control ( codec_ctx , VP9E_SET_SVC , 1 ) ;
vpx_codec_control ( codec_ctx , VP8E_SET_TOKEN_PARTITIONS , 1 ) ;
return VPX_CODEC_OK ;
} |
1,223,258,652,239,369,200 | debian | 7 | 0 | SPL_METHOD ( DirectoryIterator , getFilename ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
if ( zend_parse_parameters_none ( ) == FAILURE ) {
return ;
}
RETURN_STRING ( intern -> u . dir . entry . d_name , 1 ) ;
} |
2,546,373,479,020,365,300 | debian | 11 | 0 | static inline void relocate ( MIMEField * field , MIMEFieldBlockImpl * dest_block , MIMEFieldBlockImpl * src_block ) {
for ( ;
src_block ;
src_block = src_block -> m_next , dest_block = dest_block -> m_next ) {
ink_release_assert ( dest_block ) ;
if ( field -> m_next_dup >= src_block -> m_field_slots && field -> m_next_dup < src_block -> m_field_slots + src_block -> m_freetop ) {
field -> m_next_dup = rebase ( field -> m_next_dup , dest_block -> m_field_slots , src_block -> m_field_slots ) ;
return ;
}
}
} |
-2,127,895,299,879,503,400 | debian | 6 | 0 | static void macio_ide_realizefn ( DeviceState * dev , Error * * errp ) {
MACIOIDEState * s = MACIO_IDE ( dev ) ;
ide_init2 ( & s -> bus , s -> irq ) ;
s -> dma . ops = & dbdma_ops ;
s -> bus . dma = & s -> dma ;
} |
-2,423,144,171,479,607,000 | debian | 9 | 0 | static void pdf_copy_pattern_gstate ( fz_context * ctx , pdf_gstate * gs , const pdf_gstate * old ) {
gs -> ctm = old -> ctm ;
pdf_drop_font ( ctx , gs -> text . font ) ;
gs -> text . font = pdf_keep_font ( ctx , old -> text . font ) ;
pdf_drop_xobject ( ctx , gs -> softmask ) ;
gs -> softmask = pdf_keep_xobject ( ctx , old -> softmask ) ;
fz_drop_stroke_state ( ctx , gs -> stroke_state ) ;
gs -> stroke_state = fz_keep_stroke_state ( ctx , old -> stroke_state ) ;
} |
3,599,206,110,384,554,500 | debian | 72 | 0 | static ossl_inline t2 * sk_ ## t1 ## _value ( const STACK_OF ( t1 ) * sk , int idx ) {
return ( t2 * ) OPENSSL_sk_value ( ( const OPENSSL_STACK * ) sk , idx ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new ( sk_ ## t1 ## _compfunc compare ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new ( ( OPENSSL_sk_compfunc ) compare ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new_null ( void ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new_null ( ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new_reserve ( sk_ ## t1 ## _compfunc compare , int n ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new_reserve ( ( OPENSSL_sk_compfunc ) compare , n ) ;
}
static ossl_inline int sk_ ## t1 ## _reserve ( STACK_OF ( t1 ) * sk , int n ) {
return OPENSSL_sk_reserve ( ( OPENSSL_STACK * ) sk , n ) ;
}
static ossl_inline void sk_ ## t1 ## _free ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_free ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _zero ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_zero ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _delete ( STACK_OF ( t1 ) * sk , int i ) {
return ( t2 * ) OPENSSL_sk_delete ( ( OPENSSL_STACK * ) sk , i ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _delete_ptr ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_delete_ptr ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _push ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_push ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _unshift ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_unshift ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _pop ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_pop ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) {
OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) {
return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char ) DEFINE_SPECIAL_STACK_OF_CONST ( OPENSSL_CSTRING , char ) |
-7,019,074,708,255,237,000 | debian | 10 | 0 | static float noise_enhancer ( float fixed_gain , float * prev_tr_gain , float voice_fac , float stab_fac ) {
float sm_fac = 0.5 * ( 1 - voice_fac ) * stab_fac ;
float g0 ;
if ( fixed_gain < * prev_tr_gain ) {
g0 = FFMIN ( * prev_tr_gain , fixed_gain + fixed_gain * ( 6226 * ( 1.0f / ( 1 << 15 ) ) ) ) ;
}
else g0 = FFMAX ( * prev_tr_gain , fixed_gain * ( 27536 * ( 1.0f / ( 1 << 15 ) ) ) ) ;
* prev_tr_gain = g0 ;
return sm_fac * g0 + ( 1 - sm_fac ) * fixed_gain ;
} |
4,489,017,523,191,997,000 | debian | 4 | 0 | static int dissect_h225_InfoRequestResponseStatus ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h225_InfoRequestResponseStatus , InfoRequestResponseStatus_choice , NULL ) ;
return offset ;
} |
-866,921,002,076,081,900 | debian | 16 | 0 | int cont_data_handler ( TSCont contp , TSEvent , void * ) {
MyData * my_data = ( MyData * ) TSContDataGet ( contp ) ;
if ( my_data -> data1 == 1 && my_data -> data2 == 2 ) {
SDK_RPRINT ( SDK_ContData_test , "TSContDataSet" , "TestCase1" , TC_PASS , "ok" ) ;
SDK_RPRINT ( SDK_ContData_test , "TSContDataGet" , "TestCase1" , TC_PASS , "ok" ) ;
* SDK_ContData_pstatus = REGRESSION_TEST_PASSED ;
}
else {
SDK_RPRINT ( SDK_ContData_test , "TSContDataSet" , "TestCase1" , TC_FAIL , "bad data" ) ;
SDK_RPRINT ( SDK_ContData_test , "TSContDataGet" , "TestCase1" , TC_FAIL , "bad data" ) ;
* SDK_ContData_pstatus = REGRESSION_TEST_FAILED ;
}
TSfree ( my_data ) ;
TSContDestroy ( contp ) ;
return 0 ;
} |
2,546,373,479,020,365,300 | debian | 3 | 0 | void mime_scanner_init ( MIMEScanner * scanner ) {
_mime_scanner_init ( scanner ) ;
} |
-2,242,211,406,757,466,600 | debian | 10 | 0 | static gint handle_message_connect ( tvbuff_t * tvb , packet_info * pinfo , gint offset , proto_tree * message_tree ) {
guint8 the_one_byte ;
the_one_byte = tvb_get_guint8 ( tvb , offset ) ;
if ( 0 == the_one_byte ) {
col_set_str ( pinfo -> cinfo , COL_INFO , "CONNECT-initial byte" ) ;
proto_tree_add_item ( message_tree , hf_alljoyn_connect_byte_value , tvb , offset , 1 , ENC_NA ) ;
offset += 1 ;
}
return offset ;
} |
8,139,827,869,427,660,000 | debian | 16 | 0 | static int unescape_octals ( gx_device_pdf * pdev , char * src , int size ) {
char * start , * dest ;
start = src ;
dest = src ;
while ( size ) {
if ( size > 4 && src [ 0 ] == '\\' && src [ 1 ] == '\\' && src [ 2 ] > 0x29 && src [ 2 ] < 0x35 && src [ 3 ] > 0x29 && src [ 3 ] < 0x38 && src [ 4 ] > 0x29 && src [ 4 ] < 0x38 ) {
src ++ ;
size -- ;
}
else {
* dest ++ = * src ++ ;
size -- ;
}
}
return ( dest - start ) ;
} |
7,072,059,544,915,634,000 | chrome | 14 | 0 | static size_t LMBCSConvertUni ( ulmbcs_byte_t * pLMBCS , UChar uniChar ) {
uint8_t LowCh = ( uint8_t ) ( uniChar & 0x00FF ) ;
uint8_t HighCh = ( uint8_t ) ( uniChar >> 8 ) ;
* pLMBCS ++ = ULMBCS_GRP_UNICODE ;
if ( LowCh == 0 ) {
* pLMBCS ++ = ULMBCS_UNICOMPATZERO ;
* pLMBCS ++ = HighCh ;
}
else {
* pLMBCS ++ = HighCh ;
* pLMBCS ++ = LowCh ;
}
return ULMBCS_UNICODE_SIZE ;
} |
-7,506,793,256,180,115,000 | chrome | 30 | 0 | int GetCertificateFailure ( JNIEnv * env , const JavaParamRef < jclass > & obj , const JavaParamRef < jobject > & java_web_contents ) {
enum CertificateFailure {
NONE = 0 , CERTIFICATE_FAIL_UNSPECIFIED = 1 , CERTIFICATE_FAIL_UNTRUSTED = 2 , CERTIFICATE_FAIL_REVOKED = 3 , CERTIFICATE_FAIL_NOT_YET_VALID = 4 , CERTIFICATE_FAIL_EXPIRED = 5 , CERTIFICATE_FAIL_UNABLE_TO_CHECK_REVOCATION_STATUS = 6 , }
;
content : : WebContents * web_contents = content : : WebContents : : FromJavaWebContents ( java_web_contents ) ;
content : : NavigationEntry * entry = web_contents -> GetController ( ) . GetVisibleEntry ( ) ;
if ( ! entry ) return NONE ;
const content : : SSLStatus & ssl = entry -> GetSSL ( ) ;
if ( ssl . certificate && entry -> GetURL ( ) . SchemeIsCryptographic ( ) ) {
if ( net : : IsCertStatusError ( ssl . cert_status ) ) {
if ( ssl . cert_status & net : : CERT_STATUS_AUTHORITY_INVALID ) {
return CERTIFICATE_FAIL_UNTRUSTED ;
}
if ( ssl . cert_status & net : : CERT_STATUS_REVOKED ) {
return CERTIFICATE_FAIL_REVOKED ;
}
if ( ssl . cert_status & net : : CERT_STATUS_DATE_INVALID ) {
return CERTIFICATE_FAIL_EXPIRED ;
}
if ( ssl . cert_status & net : : CERT_STATUS_UNABLE_TO_CHECK_REVOCATION ) {
return CERTIFICATE_FAIL_UNABLE_TO_CHECK_REVOCATION_STATUS ;
}
return CERTIFICATE_FAIL_UNSPECIFIED ;
}
if ( ssl . content_status & content : : SSLStatus : : DISPLAYED_INSECURE_CONTENT || ssl . content_status & content : : SSLStatus : : DISPLAYED_CONTENT_WITH_CERT_ERRORS ) {
return CERTIFICATE_FAIL_UNSPECIFIED ;
}
}
return NONE ;
} |
-1,929,262,071,302,712,000 | debian | 12 | 0 | static void * Type_Measurement_Read ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , cmsUInt32Number * nItems , cmsUInt32Number SizeOfTag ) {
cmsICCMeasurementConditions mc ;
memset ( & mc , 0 , sizeof ( mc ) ) ;
if ( ! _cmsReadUInt32Number ( io , & mc . Observer ) ) return NULL ;
if ( ! _cmsReadXYZNumber ( io , & mc . Backing ) ) return NULL ;
if ( ! _cmsReadUInt32Number ( io , & mc . Geometry ) ) return NULL ;
if ( ! _cmsRead15Fixed16Number ( io , & mc . Flare ) ) return NULL ;
if ( ! _cmsReadUInt32Number ( io , & mc . IlluminantType ) ) return NULL ;
* nItems = 1 ;
return _cmsDupMem ( self -> ContextID , & mc , sizeof ( cmsICCMeasurementConditions ) ) ;
cmsUNUSED_PARAMETER ( SizeOfTag ) ;
} |
4,489,017,523,191,997,000 | debian | 7 | 0 | static int dissect_h225_TBCD_STRING ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 912 "./asn1/h225/h225.cnf" int min_len , max_len ;
gboolean has_extension ;
get_size_constraint_from_stack ( actx , "TBCD_STRING" , & min_len , & max_len , & has_extension ) ;
offset = dissect_per_restricted_character_string ( tvb , offset , actx , tree , hf_index , min_len , max_len , has_extension , "0123456789#*abc" , 15 , NULL ) ;
return offset ;
} |
2,895,622,461,494,525,400 | debian | 36 | 0 | static void test_bug5399 ( ) {
# define NUM_OF_USED_STMT 97 MYSQL_STMT * stmt_list [ NUM_OF_USED_STMT ] ;
MYSQL_STMT * * stmt ;
MYSQL_BIND my_bind [ 1 ] ;
char buff [ 600 ] ;
int rc ;
int32 no ;
myheader ( "test_bug5399" ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_LONG ;
my_bind [ 0 ] . buffer = & no ;
for ( stmt = stmt_list ;
stmt != stmt_list + NUM_OF_USED_STMT ;
++ stmt ) {
sprintf ( buff , "select %d" , ( int ) ( stmt - stmt_list ) ) ;
* stmt = mysql_stmt_init ( mysql ) ;
rc = mysql_stmt_prepare ( * stmt , buff , strlen ( buff ) ) ;
check_execute ( * stmt , rc ) ;
mysql_stmt_bind_result ( * stmt , my_bind ) ;
}
if ( ! opt_silent ) printf ( "%d statements prepared.\n" , NUM_OF_USED_STMT ) ;
for ( stmt = stmt_list ;
stmt != stmt_list + NUM_OF_USED_STMT ;
++ stmt ) {
rc = mysql_stmt_execute ( * stmt ) ;
check_execute ( * stmt , rc ) ;
rc = mysql_stmt_store_result ( * stmt ) ;
check_execute ( * stmt , rc ) ;
rc = mysql_stmt_fetch ( * stmt ) ;
DIE_UNLESS ( rc == 0 ) ;
DIE_UNLESS ( ( int32 ) ( stmt - stmt_list ) == no ) ;
}
for ( stmt = stmt_list ;
stmt != stmt_list + NUM_OF_USED_STMT ;
++ stmt ) mysql_stmt_close ( * stmt ) ;
# undef NUM_OF_USED_STMT } |
4,489,017,523,191,997,000 | debian | 15 | 0 | static int dissect_h225_Progress_UUIE ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 414 "./asn1/h225/h225.cnf" h225_packet_info * h225_pi ;
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h225_Progress_UUIE , Progress_UUIE_sequence ) ;
# line 418 "./asn1/h225/h225.cnf" h225_pi = ( h225_packet_info * ) p_get_proto_data ( wmem_packet_scope ( ) , actx -> pinfo , proto_h225 , 0 ) ;
if ( h225_pi != NULL ) {
h225_pi -> cs_type = H225_PROGRESS ;
if ( contains_faststart ) {
char temp [ 50 ] ;
g_snprintf ( temp , 50 , "%s OLC (%s)" , val_to_str ( h225_pi -> cs_type , T_h323_message_body_vals , "<unknown>" ) , h225_pi -> frame_label ) ;
g_strlcpy ( h225_pi -> frame_label , temp , 50 ) ;
}
else g_snprintf ( h225_pi -> frame_label , 50 , "%s" , val_to_str ( h225_pi -> cs_type , T_h323_message_body_vals , "<unknown>" ) ) ;
}
return offset ;
} |
2,335,222,688,263,906,300 | debian | 30 | 0 | static void rv34_gen_vlc ( const uint8_t * bits , int size , VLC * vlc , const uint8_t * insyms , const int num ) {
int i ;
int counts [ 17 ] = {
0 }
, codes [ 17 ] ;
uint16_t cw [ MAX_VLC_SIZE ] , syms [ MAX_VLC_SIZE ] ;
uint8_t bits2 [ MAX_VLC_SIZE ] ;
int maxbits = 0 , realsize = 0 ;
for ( i = 0 ;
i < size ;
i ++ ) {
if ( bits [ i ] ) {
bits2 [ realsize ] = bits [ i ] ;
syms [ realsize ] = insyms ? insyms [ i ] : i ;
realsize ++ ;
maxbits = FFMAX ( maxbits , bits [ i ] ) ;
counts [ bits [ i ] ] ++ ;
}
}
codes [ 0 ] = 0 ;
for ( i = 0 ;
i < 16 ;
i ++ ) codes [ i + 1 ] = ( codes [ i ] + counts [ i ] ) << 1 ;
for ( i = 0 ;
i < realsize ;
i ++ ) cw [ i ] = codes [ bits2 [ i ] ] ++ ;
vlc -> table = & table_data [ table_offs [ num ] ] ;
vlc -> table_allocated = table_offs [ num + 1 ] - table_offs [ num ] ;
ff_init_vlc_sparse ( vlc , FFMIN ( maxbits , 9 ) , realsize , bits2 , 1 , 1 , cw , 2 , 2 , syms , 2 , 2 , INIT_VLC_USE_NEW_STATIC ) ;
} |
5,347,874,611,477,979,000 | chrome | 35 | 0 | static void test_registerfds ( void ) {
int i , j ;
int pair [ 2 ] ;
struct event read_evs [ 512 ] ;
struct event write_evs [ 512 ] ;
struct event_base * base = event_base_new ( ) ;
fprintf ( stdout , "Testing register fds: " ) ;
for ( i = 0 ;
i < 512 ;
++ i ) {
if ( evutil_socketpair ( AF_UNIX , SOCK_STREAM , 0 , pair ) == - 1 ) {
break ;
}
event_set ( & read_evs [ i ] , pair [ 0 ] , EV_READ | EV_PERSIST , simple_read_cb , NULL ) ;
event_base_set ( base , & read_evs [ i ] ) ;
event_add ( & read_evs [ i ] , NULL ) ;
event_set ( & write_evs [ i ] , pair [ 1 ] , EV_WRITE | EV_PERSIST , simple_write_cb , NULL ) ;
event_base_set ( base , & write_evs [ i ] ) ;
event_add ( & write_evs [ i ] , NULL ) ;
event_base_loop ( base , EVLOOP_ONCE ) ;
}
for ( j = 0 ;
j < i ;
++ j ) {
event_del ( & read_evs [ j ] ) ;
event_del ( & write_evs [ j ] ) ;
# ifndef WIN32 close ( read_evs [ j ] . ev_fd ) ;
close ( write_evs [ j ] . ev_fd ) ;
# else CloseHandle ( ( HANDLE ) read_evs [ j ] . ev_fd ) ;
CloseHandle ( ( HANDLE ) write_evs [ j ] . ev_fd ) ;
# endif event_base_loop ( base , EVLOOP_ONCE ) ;
}
event_base_free ( base ) ;
fprintf ( stdout , "OK\n" ) ;
} |
8,206,514,580,434,226,000 | chrome | 10 | 0 | IN_PROC_BROWSER_TEST_F ( HttpsEngagementPageLoadMetricsBrowserTest , SameOrigin_Http ) {
StartHttpServer ( ) ;
NavigateTwiceInTabAndClose ( http_test_server_ -> GetURL ( "/simple.html" ) , http_test_server_ -> GetURL ( "/empty.html" ) ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHttpEngagementHistogram , 2 ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHttpsEngagementHistogram , 0 ) ;
FakeUserMetricsUpload ( ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHttpsEngagementSessionPercentage , 1 ) ;
int32_t ratio_bucket = histogram_tester_ . GetAllSamples ( internal : : kHttpsEngagementSessionPercentage ) [ 0 ] . min ;
EXPECT_EQ ( 0 , ratio_bucket ) ;
} |
2,473,550,066,879,118,300 | debian | 56 | 0 | gpg_err_code_t _gcry_ecc_ecdsa_verify ( gcry_mpi_t input , ECC_public_key * pkey , gcry_mpi_t r , gcry_mpi_t s ) {
gpg_err_code_t err = 0 ;
gcry_mpi_t hash , h , h1 , h2 , x ;
mpi_point_struct Q , Q1 , Q2 ;
mpi_ec_t ctx ;
unsigned int nbits ;
if ( ! ( mpi_cmp_ui ( r , 0 ) > 0 && mpi_cmp ( r , pkey -> E . n ) < 0 ) ) return GPG_ERR_BAD_SIGNATURE ;
if ( ! ( mpi_cmp_ui ( s , 0 ) > 0 && mpi_cmp ( s , pkey -> E . n ) < 0 ) ) return GPG_ERR_BAD_SIGNATURE ;
nbits = mpi_get_nbits ( pkey -> E . n ) ;
err = _gcry_dsa_normalize_hash ( input , & hash , nbits ) ;
if ( err ) return err ;
h = mpi_alloc ( 0 ) ;
h1 = mpi_alloc ( 0 ) ;
h2 = mpi_alloc ( 0 ) ;
x = mpi_alloc ( 0 ) ;
point_init ( & Q ) ;
point_init ( & Q1 ) ;
point_init ( & Q2 ) ;
ctx = _gcry_mpi_ec_p_internal_new ( pkey -> E . model , pkey -> E . dialect , 0 , pkey -> E . p , pkey -> E . a , pkey -> E . b ) ;
mpi_invm ( h , s , pkey -> E . n ) ;
mpi_mulm ( h1 , hash , h , pkey -> E . n ) ;
_gcry_mpi_ec_mul_point ( & Q1 , h1 , & pkey -> E . G , ctx ) ;
mpi_mulm ( h2 , r , h , pkey -> E . n ) ;
_gcry_mpi_ec_mul_point ( & Q2 , h2 , & pkey -> Q , ctx ) ;
_gcry_mpi_ec_add_points ( & Q , & Q1 , & Q2 , ctx ) ;
if ( ! mpi_cmp_ui ( Q . z , 0 ) ) {
if ( DBG_CIPHER ) log_debug ( "ecc verify: Rejected\n" ) ;
err = GPG_ERR_BAD_SIGNATURE ;
goto leave ;
}
if ( _gcry_mpi_ec_get_affine ( x , NULL , & Q , ctx ) ) {
if ( DBG_CIPHER ) log_debug ( "ecc verify: Failed to get affine coordinates\n" ) ;
err = GPG_ERR_BAD_SIGNATURE ;
goto leave ;
}
mpi_mod ( x , x , pkey -> E . n ) ;
if ( mpi_cmp ( x , r ) ) {
if ( DBG_CIPHER ) {
log_mpidump ( " x" , x ) ;
log_mpidump ( " r" , r ) ;
log_mpidump ( " s" , s ) ;
}
err = GPG_ERR_BAD_SIGNATURE ;
goto leave ;
}
leave : _gcry_mpi_ec_free ( ctx ) ;
point_free ( & Q2 ) ;
point_free ( & Q1 ) ;
point_free ( & Q ) ;
mpi_free ( x ) ;
mpi_free ( h2 ) ;
mpi_free ( h1 ) ;
mpi_free ( h ) ;
if ( hash != input ) mpi_free ( hash ) ;
return err ;
} |
4,180,964,683,905,831,000 | debian | 39 | 0 | static int sb_finish_set_opts ( struct super_block * sb ) {
struct superblock_security_struct * sbsec = sb -> s_security ;
struct dentry * root = sb -> s_root ;
struct inode * root_inode = d_backing_inode ( root ) ;
int rc = 0 ;
if ( sbsec -> behavior == SECURITY_FS_USE_XATTR ) {
if ( ! ( root_inode -> i_opflags & IOP_XATTR ) ) {
printk ( KERN_WARNING "SELinux: (dev %s, type %s) has no " "xattr support\n" , sb -> s_id , sb -> s_type -> name ) ;
rc = - EOPNOTSUPP ;
goto out ;
}
rc = __vfs_getxattr ( root , root_inode , XATTR_NAME_SELINUX , NULL , 0 ) ;
if ( rc < 0 && rc != - ENODATA ) {
if ( rc == - EOPNOTSUPP ) printk ( KERN_WARNING "SELinux: (dev %s, type " "%s) has no security xattr handler\n" , sb -> s_id , sb -> s_type -> name ) ;
else printk ( KERN_WARNING "SELinux: (dev %s, type " "%s) getxattr errno %d\n" , sb -> s_id , sb -> s_type -> name , - rc ) ;
goto out ;
}
}
if ( sbsec -> behavior > ARRAY_SIZE ( labeling_behaviors ) ) printk ( KERN_ERR "SELinux: initialized (dev %s, type %s), unknown behavior\n" , sb -> s_id , sb -> s_type -> name ) ;
sbsec -> flags |= SE_SBINITIALIZED ;
if ( selinux_is_sblabel_mnt ( sb ) ) sbsec -> flags |= SBLABEL_MNT ;
rc = inode_doinit_with_dentry ( root_inode , root ) ;
spin_lock ( & sbsec -> isec_lock ) ;
next_inode : if ( ! list_empty ( & sbsec -> isec_head ) ) {
struct inode_security_struct * isec = list_entry ( sbsec -> isec_head . next , struct inode_security_struct , list ) ;
struct inode * inode = isec -> inode ;
list_del_init ( & isec -> list ) ;
spin_unlock ( & sbsec -> isec_lock ) ;
inode = igrab ( inode ) ;
if ( inode ) {
if ( ! IS_PRIVATE ( inode ) ) inode_doinit ( inode ) ;
iput ( inode ) ;
}
spin_lock ( & sbsec -> isec_lock ) ;
goto next_inode ;
}
spin_unlock ( & sbsec -> isec_lock ) ;
out : return rc ;
} |
7,749,168,290,238,235,000 | debian | 36 | 0 | static int test_source_cksum_offset ( xd3_stream * stream , int ignore ) {
xd3_source source ;
struct {
xoff_t cpos ;
xoff_t ipos ;
xoff_t size ;
usize_t input ;
xoff_t output ;
}
cksum_test [ ] = {
{
1 , 1 , 1 , 1 , 1 }
, # if XD3_USE_LARGEFILE64 {
0x100100000ULL , 0x100000000ULL , 0x100200000ULL , 0x00000000UL , 0x100000000ULL }
, {
0x100100000ULL , 0x100000000ULL , 0x100200000ULL , 0xF0000000UL , 0x0F0000000ULL }
, {
0x100200000ULL , 0x100100000ULL , 0x100200000ULL , 0x00300000UL , 0x000300000ULL }
, {
25771983104ULL , 25770000000ULL , 26414808769ULL , 2139216707UL , 23614053187ULL }
, # endif {
0 , 0 , 0 , 0 , 0 }
, }
, * test_ptr ;
stream -> src = & source ;
for ( test_ptr = cksum_test ;
test_ptr -> cpos ;
test_ptr ++ ) {
xoff_t r ;
stream -> srcwin_cksum_pos = test_ptr -> cpos ;
stream -> total_in = test_ptr -> ipos ;
r = xd3_source_cksum_offset ( stream , test_ptr -> input ) ;
CHECK ( r == test_ptr -> output ) ;
}
return 0 ;
} |
-7,456,613,930,747,244,000 | debian | 37 | 1 | static int decode_frame ( AVCodecContext * avctx , void * data , int * got_frame_ptr , AVPacket * avpkt ) {
BinkAudioContext * s = avctx -> priv_data ;
AVFrame * frame = data ;
GetBitContext * gb = & s -> gb ;
int ret , consumed = 0 ;
if ( ! get_bits_left ( gb ) ) {
uint8_t * buf ;
if ( ! avpkt -> size ) {
* got_frame_ptr = 0 ;
return 0 ;
}
if ( avpkt -> size < 4 ) {
av_log ( avctx , AV_LOG_ERROR , "Packet is too small\n" ) ;
return AVERROR_INVALIDDATA ;
}
buf = av_realloc ( s -> packet_buffer , avpkt -> size + FF_INPUT_BUFFER_PADDING_SIZE ) ;
if ( ! buf ) return AVERROR ( ENOMEM ) ;
s -> packet_buffer = buf ;
memcpy ( s -> packet_buffer , avpkt -> data , avpkt -> size ) ;
init_get_bits ( gb , s -> packet_buffer , avpkt -> size * 8 ) ;
consumed = avpkt -> size ;
skip_bits_long ( gb , 32 ) ;
}
frame -> nb_samples = s -> frame_len ;
if ( ( ret = ff_get_buffer ( avctx , frame ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "get_buffer() failed\n" ) ;
return ret ;
}
if ( decode_block ( s , ( float * * ) frame -> extended_data , avctx -> codec -> id == AV_CODEC_ID_BINKAUDIO_DCT ) ) {
av_log ( avctx , AV_LOG_ERROR , "Incomplete packet\n" ) ;
return AVERROR_INVALIDDATA ;
}
get_bits_align32 ( gb ) ;
frame -> nb_samples = s -> block_size / avctx -> channels ;
* got_frame_ptr = 1 ;
return consumed ;
} |
1,202,634,027,547,122,400 | debian | 389 | 0 | static int diffie_hellman_sha256 ( LIBSSH2_SESSION * session , _libssh2_bn * g , _libssh2_bn * p , int group_order , unsigned char packet_type_init , unsigned char packet_type_reply , unsigned char * midhash , unsigned long midhash_len , kmdhgGPshakex_state_t * exchange_state ) {
int ret = 0 ;
int rc ;
libssh2_sha256_ctx exchange_hash_ctx ;
if ( exchange_state -> state == libssh2_NB_state_idle ) {
exchange_state -> e_packet = NULL ;
exchange_state -> s_packet = NULL ;
exchange_state -> k_value = NULL ;
exchange_state -> ctx = _libssh2_bn_ctx_new ( ) ;
exchange_state -> x = _libssh2_bn_init ( ) ;
exchange_state -> e = _libssh2_bn_init ( ) ;
exchange_state -> f = _libssh2_bn_init_from_bin ( ) ;
exchange_state -> k = _libssh2_bn_init ( ) ;
memset ( & exchange_state -> req_state , 0 , sizeof ( packet_require_state_t ) ) ;
_libssh2_bn_rand ( exchange_state -> x , group_order * 8 - 1 , 0 , - 1 ) ;
_libssh2_bn_mod_exp ( exchange_state -> e , g , exchange_state -> x , p , exchange_state -> ctx ) ;
exchange_state -> e_packet_len = _libssh2_bn_bytes ( exchange_state -> e ) + 6 ;
if ( _libssh2_bn_bits ( exchange_state -> e ) % 8 ) {
exchange_state -> e_packet_len -- ;
}
exchange_state -> e_packet = LIBSSH2_ALLOC ( session , exchange_state -> e_packet_len ) ;
if ( ! exchange_state -> e_packet ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_ALLOC , "Out of memory error" ) ;
goto clean_exit ;
}
exchange_state -> e_packet [ 0 ] = packet_type_init ;
_libssh2_htonu32 ( exchange_state -> e_packet + 1 , exchange_state -> e_packet_len - 5 ) ;
if ( _libssh2_bn_bits ( exchange_state -> e ) % 8 ) {
_libssh2_bn_to_bin ( exchange_state -> e , exchange_state -> e_packet + 5 ) ;
}
else {
exchange_state -> e_packet [ 5 ] = 0 ;
_libssh2_bn_to_bin ( exchange_state -> e , exchange_state -> e_packet + 6 ) ;
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Sending KEX packet %d" , ( int ) packet_type_init ) ;
exchange_state -> state = libssh2_NB_state_created ;
}
if ( exchange_state -> state == libssh2_NB_state_created ) {
rc = _libssh2_transport_send ( session , exchange_state -> e_packet , exchange_state -> e_packet_len , NULL , 0 ) ;
if ( rc == LIBSSH2_ERROR_EAGAIN ) {
return rc ;
}
else if ( rc ) {
ret = _libssh2_error ( session , rc , "Unable to send KEX init message" ) ;
goto clean_exit ;
}
exchange_state -> state = libssh2_NB_state_sent ;
}
if ( exchange_state -> state == libssh2_NB_state_sent ) {
if ( session -> burn_optimistic_kexinit ) {
int burn_type ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Waiting for badly guessed KEX packet (to be ignored)" ) ;
burn_type = _libssh2_packet_burn ( session , & exchange_state -> burn_state ) ;
if ( burn_type == LIBSSH2_ERROR_EAGAIN ) {
return burn_type ;
}
else if ( burn_type <= 0 ) {
ret = burn_type ;
goto clean_exit ;
}
session -> burn_optimistic_kexinit = 0 ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Burnt packet of type: %02x" , ( unsigned int ) burn_type ) ;
}
exchange_state -> state = libssh2_NB_state_sent1 ;
}
if ( exchange_state -> state == libssh2_NB_state_sent1 ) {
rc = _libssh2_packet_require ( session , packet_type_reply , & exchange_state -> s_packet , & exchange_state -> s_packet_len , 0 , NULL , 0 , & exchange_state -> req_state ) ;
if ( rc == LIBSSH2_ERROR_EAGAIN ) {
return rc ;
}
if ( rc ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_TIMEOUT , "Timed out waiting for KEX reply" ) ;
goto clean_exit ;
}
exchange_state -> s = exchange_state -> s_packet + 1 ;
session -> server_hostkey_len = _libssh2_ntohu32 ( exchange_state -> s ) ;
exchange_state -> s += 4 ;
if ( session -> server_hostkey ) LIBSSH2_FREE ( session , session -> server_hostkey ) ;
session -> server_hostkey = LIBSSH2_ALLOC ( session , session -> server_hostkey_len ) ;
if ( ! session -> server_hostkey ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_ALLOC , "Unable to allocate memory for a copy " "of the host key" ) ;
goto clean_exit ;
}
memcpy ( session -> server_hostkey , exchange_state -> s , session -> server_hostkey_len ) ;
exchange_state -> s += session -> server_hostkey_len ;
# if LIBSSH2_MD5 {
libssh2_md5_ctx fingerprint_ctx ;
if ( libssh2_md5_init ( & fingerprint_ctx ) ) {
libssh2_md5_update ( fingerprint_ctx , session -> server_hostkey , session -> server_hostkey_len ) ;
libssh2_md5_final ( fingerprint_ctx , session -> server_hostkey_md5 ) ;
session -> server_hostkey_md5_valid = TRUE ;
}
else {
session -> server_hostkey_md5_valid = FALSE ;
}
}
# ifdef LIBSSH2DEBUG {
char fingerprint [ 50 ] , * fprint = fingerprint ;
int i ;
for ( i = 0 ;
i < 16 ;
i ++ , fprint += 3 ) {
snprintf ( fprint , 4 , "%02x:" , session -> server_hostkey_md5 [ i ] ) ;
}
* ( -- fprint ) = '\0' ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server's MD5 Fingerprint: %s" , fingerprint ) ;
}
# endif # endif {
libssh2_sha1_ctx fingerprint_ctx ;
if ( libssh2_sha1_init ( & fingerprint_ctx ) ) {
libssh2_sha1_update ( fingerprint_ctx , session -> server_hostkey , session -> server_hostkey_len ) ;
libssh2_sha1_final ( fingerprint_ctx , session -> server_hostkey_sha1 ) ;
session -> server_hostkey_sha1_valid = TRUE ;
}
else {
session -> server_hostkey_sha1_valid = FALSE ;
}
}
# ifdef LIBSSH2DEBUG {
char fingerprint [ 64 ] , * fprint = fingerprint ;
int i ;
for ( i = 0 ;
i < 20 ;
i ++ , fprint += 3 ) {
snprintf ( fprint , 4 , "%02x:" , session -> server_hostkey_sha1 [ i ] ) ;
}
* ( -- fprint ) = '\0' ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server's SHA1 Fingerprint: %s" , fingerprint ) ;
}
# endif if ( session -> hostkey -> init ( session , session -> server_hostkey , session -> server_hostkey_len , & session -> server_hostkey_abstract ) ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_HOSTKEY_INIT , "Unable to initialize hostkey importer" ) ;
goto clean_exit ;
}
exchange_state -> f_value_len = _libssh2_ntohu32 ( exchange_state -> s ) ;
exchange_state -> s += 4 ;
exchange_state -> f_value = exchange_state -> s ;
exchange_state -> s += exchange_state -> f_value_len ;
_libssh2_bn_from_bin ( exchange_state -> f , exchange_state -> f_value_len , exchange_state -> f_value ) ;
exchange_state -> h_sig_len = _libssh2_ntohu32 ( exchange_state -> s ) ;
exchange_state -> s += 4 ;
exchange_state -> h_sig = exchange_state -> s ;
_libssh2_bn_mod_exp ( exchange_state -> k , exchange_state -> f , exchange_state -> x , p , exchange_state -> ctx ) ;
exchange_state -> k_value_len = _libssh2_bn_bytes ( exchange_state -> k ) + 5 ;
if ( _libssh2_bn_bits ( exchange_state -> k ) % 8 ) {
exchange_state -> k_value_len -- ;
}
exchange_state -> k_value = LIBSSH2_ALLOC ( session , exchange_state -> k_value_len ) ;
if ( ! exchange_state -> k_value ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_ALLOC , "Unable to allocate buffer for K" ) ;
goto clean_exit ;
}
_libssh2_htonu32 ( exchange_state -> k_value , exchange_state -> k_value_len - 4 ) ;
if ( _libssh2_bn_bits ( exchange_state -> k ) % 8 ) {
_libssh2_bn_to_bin ( exchange_state -> k , exchange_state -> k_value + 4 ) ;
}
else {
exchange_state -> k_value [ 4 ] = 0 ;
_libssh2_bn_to_bin ( exchange_state -> k , exchange_state -> k_value + 5 ) ;
}
exchange_state -> exchange_hash = ( void * ) & exchange_hash_ctx ;
libssh2_sha256_init ( & exchange_hash_ctx ) ;
if ( session -> local . banner ) {
_libssh2_htonu32 ( exchange_state -> h_sig_comp , strlen ( ( char * ) session -> local . banner ) - 2 ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , ( char * ) session -> local . banner , strlen ( ( char * ) session -> local . banner ) - 2 ) ;
}
else {
_libssh2_htonu32 ( exchange_state -> h_sig_comp , sizeof ( LIBSSH2_SSH_DEFAULT_BANNER ) - 1 ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , LIBSSH2_SSH_DEFAULT_BANNER , sizeof ( LIBSSH2_SSH_DEFAULT_BANNER ) - 1 ) ;
}
_libssh2_htonu32 ( exchange_state -> h_sig_comp , strlen ( ( char * ) session -> remote . banner ) ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , session -> remote . banner , strlen ( ( char * ) session -> remote . banner ) ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp , session -> local . kexinit_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , session -> local . kexinit , session -> local . kexinit_len ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp , session -> remote . kexinit_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , session -> remote . kexinit , session -> remote . kexinit_len ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp , session -> server_hostkey_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , session -> server_hostkey , session -> server_hostkey_len ) ;
if ( packet_type_init == SSH_MSG_KEX_DH_GEX_INIT ) {
# ifdef LIBSSH2_DH_GEX_NEW _libssh2_htonu32 ( exchange_state -> h_sig_comp , LIBSSH2_DH_GEX_MINGROUP ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp + 4 , LIBSSH2_DH_GEX_OPTGROUP ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp + 8 , LIBSSH2_DH_GEX_MAXGROUP ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 12 ) ;
# else _libssh2_htonu32 ( exchange_state -> h_sig_comp , LIBSSH2_DH_GEX_OPTGROUP ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
# endif }
if ( midhash ) {
libssh2_sha256_update ( exchange_hash_ctx , midhash , midhash_len ) ;
}
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> e_packet + 1 , exchange_state -> e_packet_len - 1 ) ;
_libssh2_htonu32 ( exchange_state -> h_sig_comp , exchange_state -> f_value_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> h_sig_comp , 4 ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> f_value , exchange_state -> f_value_len ) ;
libssh2_sha256_update ( exchange_hash_ctx , exchange_state -> k_value , exchange_state -> k_value_len ) ;
libssh2_sha256_final ( exchange_hash_ctx , exchange_state -> h_sig_comp ) ;
if ( session -> hostkey -> sig_verify ( session , exchange_state -> h_sig , exchange_state -> h_sig_len , exchange_state -> h_sig_comp , SHA256_DIGEST_LENGTH , & session -> server_hostkey_abstract ) ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_HOSTKEY_SIGN , "Unable to verify hostkey signature" ) ;
goto clean_exit ;
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Sending NEWKEYS message" ) ;
exchange_state -> c = SSH_MSG_NEWKEYS ;
exchange_state -> state = libssh2_NB_state_sent2 ;
}
if ( exchange_state -> state == libssh2_NB_state_sent2 ) {
rc = _libssh2_transport_send ( session , & exchange_state -> c , 1 , NULL , 0 ) ;
if ( rc == LIBSSH2_ERROR_EAGAIN ) {
return rc ;
}
else if ( rc ) {
ret = _libssh2_error ( session , rc , "Unable to send NEWKEYS message" ) ;
goto clean_exit ;
}
exchange_state -> state = libssh2_NB_state_sent3 ;
}
if ( exchange_state -> state == libssh2_NB_state_sent3 ) {
rc = _libssh2_packet_require ( session , SSH_MSG_NEWKEYS , & exchange_state -> tmp , & exchange_state -> tmp_len , 0 , NULL , 0 , & exchange_state -> req_state ) ;
if ( rc == LIBSSH2_ERROR_EAGAIN ) {
return rc ;
}
else if ( rc ) {
ret = _libssh2_error ( session , rc , "Timed out waiting for NEWKEYS" ) ;
goto clean_exit ;
}
session -> state |= LIBSSH2_STATE_NEWKEYS ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Received NEWKEYS message" ) ;
LIBSSH2_FREE ( session , exchange_state -> tmp ) ;
if ( ! session -> session_id ) {
session -> session_id = LIBSSH2_ALLOC ( session , SHA256_DIGEST_LENGTH ) ;
if ( ! session -> session_id ) {
ret = _libssh2_error ( session , LIBSSH2_ERROR_ALLOC , "Unable to allocate buffer for SHA digest" ) ;
goto clean_exit ;
}
memcpy ( session -> session_id , exchange_state -> h_sig_comp , SHA256_DIGEST_LENGTH ) ;
session -> session_id_len = SHA256_DIGEST_LENGTH ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "session_id calculated" ) ;
}
if ( session -> local . crypt -> dtor ) {
session -> local . crypt -> dtor ( session , & session -> local . crypt_abstract ) ;
}
if ( session -> local . crypt -> init ) {
unsigned char * iv = NULL , * secret = NULL ;
int free_iv = 0 , free_secret = 0 ;
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( iv , session -> local . crypt -> iv_len , "A" ) ;
if ( ! iv ) {
ret = - 1 ;
goto clean_exit ;
}
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( secret , session -> local . crypt -> secret_len , "C" ) ;
if ( ! secret ) {
LIBSSH2_FREE ( session , iv ) ;
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
if ( session -> local . crypt -> init ( session , session -> local . crypt , iv , & free_iv , secret , & free_secret , 1 , & session -> local . crypt_abstract ) ) {
LIBSSH2_FREE ( session , iv ) ;
LIBSSH2_FREE ( session , secret ) ;
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
if ( free_iv ) {
memset ( iv , 0 , session -> local . crypt -> iv_len ) ;
LIBSSH2_FREE ( session , iv ) ;
}
if ( free_secret ) {
memset ( secret , 0 , session -> local . crypt -> secret_len ) ;
LIBSSH2_FREE ( session , secret ) ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Client to Server IV and Key calculated" ) ;
if ( session -> remote . crypt -> dtor ) {
session -> remote . crypt -> dtor ( session , & session -> remote . crypt_abstract ) ;
}
if ( session -> remote . crypt -> init ) {
unsigned char * iv = NULL , * secret = NULL ;
int free_iv = 0 , free_secret = 0 ;
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( iv , session -> remote . crypt -> iv_len , "B" ) ;
if ( ! iv ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( secret , session -> remote . crypt -> secret_len , "D" ) ;
if ( ! secret ) {
LIBSSH2_FREE ( session , iv ) ;
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
if ( session -> remote . crypt -> init ( session , session -> remote . crypt , iv , & free_iv , secret , & free_secret , 0 , & session -> remote . crypt_abstract ) ) {
LIBSSH2_FREE ( session , iv ) ;
LIBSSH2_FREE ( session , secret ) ;
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
if ( free_iv ) {
memset ( iv , 0 , session -> remote . crypt -> iv_len ) ;
LIBSSH2_FREE ( session , iv ) ;
}
if ( free_secret ) {
memset ( secret , 0 , session -> remote . crypt -> secret_len ) ;
LIBSSH2_FREE ( session , secret ) ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server to Client IV and Key calculated" ) ;
if ( session -> local . mac -> dtor ) {
session -> local . mac -> dtor ( session , & session -> local . mac_abstract ) ;
}
if ( session -> local . mac -> init ) {
unsigned char * key = NULL ;
int free_key = 0 ;
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( key , session -> local . mac -> key_len , "E" ) ;
if ( ! key ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
session -> local . mac -> init ( session , key , & free_key , & session -> local . mac_abstract ) ;
if ( free_key ) {
memset ( key , 0 , session -> local . mac -> key_len ) ;
LIBSSH2_FREE ( session , key ) ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Client to Server HMAC Key calculated" ) ;
if ( session -> remote . mac -> dtor ) {
session -> remote . mac -> dtor ( session , & session -> remote . mac_abstract ) ;
}
if ( session -> remote . mac -> init ) {
unsigned char * key = NULL ;
int free_key = 0 ;
LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA256_HASH ( key , session -> remote . mac -> key_len , "F" ) ;
if ( ! key ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
session -> remote . mac -> init ( session , key , & free_key , & session -> remote . mac_abstract ) ;
if ( free_key ) {
memset ( key , 0 , session -> remote . mac -> key_len ) ;
LIBSSH2_FREE ( session , key ) ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server to Client HMAC Key calculated" ) ;
if ( session -> local . comp && session -> local . comp -> dtor ) {
session -> local . comp -> dtor ( session , 1 , & session -> local . comp_abstract ) ;
}
if ( session -> local . comp && session -> local . comp -> init ) {
if ( session -> local . comp -> init ( session , 1 , & session -> local . comp_abstract ) ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Client to Server compression initialized" ) ;
if ( session -> remote . comp && session -> remote . comp -> dtor ) {
session -> remote . comp -> dtor ( session , 0 , & session -> remote . comp_abstract ) ;
}
if ( session -> remote . comp && session -> remote . comp -> init ) {
if ( session -> remote . comp -> init ( session , 0 , & session -> remote . comp_abstract ) ) {
ret = LIBSSH2_ERROR_KEX_FAILURE ;
goto clean_exit ;
}
}
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Server to Client compression initialized" ) ;
}
clean_exit : _libssh2_bn_free ( exchange_state -> x ) ;
exchange_state -> x = NULL ;
_libssh2_bn_free ( exchange_state -> e ) ;
exchange_state -> e = NULL ;
_libssh2_bn_free ( exchange_state -> f ) ;
exchange_state -> f = NULL ;
_libssh2_bn_free ( exchange_state -> k ) ;
exchange_state -> k = NULL ;
_libssh2_bn_ctx_free ( exchange_state -> ctx ) ;
exchange_state -> ctx = NULL ;
if ( exchange_state -> e_packet ) {
LIBSSH2_FREE ( session , exchange_state -> e_packet ) ;
exchange_state -> e_packet = NULL ;
}
if ( exchange_state -> s_packet ) {
LIBSSH2_FREE ( session , exchange_state -> s_packet ) ;
exchange_state -> s_packet = NULL ;
}
if ( exchange_state -> k_value ) {
LIBSSH2_FREE ( session , exchange_state -> k_value ) ;
exchange_state -> k_value = NULL ;
}
exchange_state -> state = libssh2_NB_state_idle ;
return ret ;
} |
7,889,142,355,347,192,000 | debian | 53 | 0 | int __udp6_lib_rcv ( struct sk_buff * skb , struct udp_table * udptable , int proto ) {
struct net * net = dev_net ( skb -> dev ) ;
struct sock * sk ;
struct udphdr * uh ;
struct in6_addr * saddr , * daddr ;
u32 ulen = 0 ;
if ( ! pskb_may_pull ( skb , sizeof ( struct udphdr ) ) ) goto short_packet ;
saddr = & ipv6_hdr ( skb ) -> saddr ;
daddr = & ipv6_hdr ( skb ) -> daddr ;
uh = udp_hdr ( skb ) ;
ulen = ntohs ( uh -> len ) ;
if ( ulen > skb -> len ) goto short_packet ;
if ( proto == IPPROTO_UDP ) {
if ( ulen == 0 ) ulen = skb -> len ;
if ( ulen < sizeof ( * uh ) ) goto short_packet ;
if ( ulen < skb -> len ) {
if ( pskb_trim_rcsum ( skb , ulen ) ) goto short_packet ;
saddr = & ipv6_hdr ( skb ) -> saddr ;
daddr = & ipv6_hdr ( skb ) -> daddr ;
uh = udp_hdr ( skb ) ;
}
}
if ( udp6_csum_init ( skb , uh , proto ) ) goto discard ;
if ( ipv6_addr_is_multicast ( daddr ) ) return __udp6_lib_mcast_deliver ( net , skb , saddr , daddr , udptable ) ;
sk = __udp6_lib_lookup_skb ( skb , uh -> source , uh -> dest , udptable ) ;
if ( sk == NULL ) {
if ( ! xfrm6_policy_check ( NULL , XFRM_POLICY_IN , skb ) ) goto discard ;
if ( udp_lib_checksum_complete ( skb ) ) goto discard ;
UDP6_INC_STATS_BH ( net , UDP_MIB_NOPORTS , proto == IPPROTO_UDPLITE ) ;
icmpv6_send ( skb , ICMPV6_DEST_UNREACH , ICMPV6_PORT_UNREACH , 0 ) ;
kfree_skb ( skb ) ;
return 0 ;
}
if ( sk_rcvqueues_full ( sk , skb ) ) {
sock_put ( sk ) ;
goto discard ;
}
bh_lock_sock ( sk ) ;
if ( ! sock_owned_by_user ( sk ) ) udpv6_queue_rcv_skb ( sk , skb ) ;
else if ( sk_add_backlog ( sk , skb ) ) {
atomic_inc ( & sk -> sk_drops ) ;
bh_unlock_sock ( sk ) ;
sock_put ( sk ) ;
goto discard ;
}
bh_unlock_sock ( sk ) ;
sock_put ( sk ) ;
return 0 ;
short_packet : LIMIT_NETDEBUG ( KERN_DEBUG "UDP%sv6: short packet: %d/%u\n" , proto == IPPROTO_UDPLITE ? "-Lite" : "" , ulen , skb -> len ) ;
discard : UDP6_INC_STATS_BH ( net , UDP_MIB_INERRORS , proto == IPPROTO_UDPLITE ) ;
kfree_skb ( skb ) ;
return 0 ;
} |
7,549,435,794,356,072,000 | debian | 3 | 0 | VALUE asn1str_to_str ( const ASN1_STRING * str ) {
return rb_str_new ( ( const char * ) str -> data , str -> length ) ;
} |
9,199,363,626,704,328,000 | debian | 34 | 1 | static int vble_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) {
VBLEContext * ctx = avctx -> priv_data ;
AVFrame * pic = avctx -> coded_frame ;
GetBitContext gb ;
const uint8_t * src = avpkt -> data ;
int version ;
int offset = 0 ;
int width_uv = avctx -> width / 2 , height_uv = avctx -> height / 2 ;
pic -> reference = 0 ;
if ( pic -> data [ 0 ] ) avctx -> release_buffer ( avctx , pic ) ;
if ( ff_get_buffer ( avctx , pic ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "Could not allocate buffer.\n" ) ;
return AVERROR ( ENOMEM ) ;
}
pic -> key_frame = 1 ;
pic -> pict_type = AV_PICTURE_TYPE_I ;
version = AV_RL32 ( src ) ;
if ( version != 1 ) av_log ( avctx , AV_LOG_WARNING , "Unsupported VBLE Version: %d\n" , version ) ;
init_get_bits ( & gb , src + 4 , ( avpkt -> size - 4 ) * 8 ) ;
if ( vble_unpack ( ctx , & gb ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "Invalid Code\n" ) ;
return AVERROR_INVALIDDATA ;
}
vble_restore_plane ( ctx , 0 , offset , avctx -> width , avctx -> height ) ;
if ( ! ( ctx -> avctx -> flags & CODEC_FLAG_GRAY ) ) {
offset += avctx -> width * avctx -> height ;
vble_restore_plane ( ctx , 1 , offset , width_uv , height_uv ) ;
offset += width_uv * height_uv ;
vble_restore_plane ( ctx , 2 , offset , width_uv , height_uv ) ;
}
* got_frame = 1 ;
* ( AVFrame * ) data = * pic ;
return avpkt -> size ;
} |
6,675,626,110,148,442,000 | debian | 22 | 0 | long jas_stream_seek ( jas_stream_t * stream , long offset , int origin ) {
long newpos ;
assert ( ! ( ( stream -> bufmode_ & JAS_STREAM_RDBUF ) && ( stream -> bufmode_ & JAS_STREAM_WRBUF ) ) ) ;
stream -> flags_ &= ~ JAS_STREAM_EOF ;
if ( stream -> bufmode_ & JAS_STREAM_RDBUF ) {
if ( origin == SEEK_CUR ) {
offset -= stream -> cnt_ ;
}
}
else if ( stream -> bufmode_ & JAS_STREAM_WRBUF ) {
if ( jas_stream_flush ( stream ) ) {
return - 1 ;
}
}
stream -> cnt_ = 0 ;
stream -> ptr_ = stream -> bufstart_ ;
stream -> bufmode_ &= ~ ( JAS_STREAM_RDBUF | JAS_STREAM_WRBUF ) ;
if ( ( newpos = ( * stream -> ops_ -> seek_ ) ( stream -> obj_ , offset , origin ) ) < 0 ) {
return - 1 ;
}
return newpos ;
} |
-1,102,844,685,921,778,700 | debian | 70 | 0 | static int archive_string_append_unicode ( struct archive_string * as , const void * _p , size_t len , struct archive_string_conv * sc ) {
const char * s ;
char * p , * endp ;
uint32_t uc ;
size_t w ;
int n , ret = 0 , ts , tm ;
int ( * parse ) ( uint32_t * , const char * , size_t ) ;
size_t ( * unparse ) ( char * , size_t , uint32_t ) ;
if ( sc -> flag & SCONV_TO_UTF16BE ) {
unparse = unicode_to_utf16be ;
ts = 2 ;
}
else if ( sc -> flag & SCONV_TO_UTF16LE ) {
unparse = unicode_to_utf16le ;
ts = 2 ;
}
else if ( sc -> flag & SCONV_TO_UTF8 ) {
unparse = unicode_to_utf8 ;
ts = 1 ;
}
else {
if ( sc -> flag & SCONV_FROM_UTF16BE ) {
unparse = unicode_to_utf16be ;
ts = 2 ;
}
else if ( sc -> flag & SCONV_FROM_UTF16LE ) {
unparse = unicode_to_utf16le ;
ts = 2 ;
}
else {
unparse = unicode_to_utf8 ;
ts = 1 ;
}
}
if ( sc -> flag & SCONV_FROM_UTF16BE ) {
parse = utf16be_to_unicode ;
tm = 1 ;
}
else if ( sc -> flag & SCONV_FROM_UTF16LE ) {
parse = utf16le_to_unicode ;
tm = 1 ;
}
else {
parse = cesu8_to_unicode ;
tm = ts ;
}
if ( archive_string_ensure ( as , as -> length + len * tm + ts ) == NULL ) return ( - 1 ) ;
s = ( const char * ) _p ;
p = as -> s + as -> length ;
endp = as -> s + as -> buffer_length - ts ;
while ( ( n = parse ( & uc , s , len ) ) != 0 ) {
if ( n < 0 ) {
n *= - 1 ;
ret = - 1 ;
}
s += n ;
len -= n ;
while ( ( w = unparse ( p , endp - p , uc ) ) == 0 ) {
as -> length = p - as -> s ;
if ( archive_string_ensure ( as , as -> buffer_length + len * tm + ts ) == NULL ) return ( - 1 ) ;
p = as -> s + as -> length ;
endp = as -> s + as -> buffer_length - ts ;
}
p += w ;
}
as -> length = p - as -> s ;
as -> s [ as -> length ] = '\0' ;
if ( ts == 2 ) as -> s [ as -> length + 1 ] = '\0' ;
return ( ret ) ;
} |
-3,569,070,884,878,445,600 | debian | 40 | 0 | static int get_buffer ( AVCodecContext * avctx , Picture * pic ) {
SVQ3Context * s = avctx -> priv_data ;
H264Context * h = & s -> h ;
const int big_mb_num = h -> mb_stride * ( h -> mb_height + 1 ) + 1 ;
const int mb_array_size = h -> mb_stride * h -> mb_height ;
const int b4_stride = h -> mb_width * 4 + 1 ;
const int b4_array_size = b4_stride * h -> mb_height * 4 ;
int ret ;
if ( ! pic -> motion_val_buf [ 0 ] ) {
int i ;
pic -> mb_type_buf = av_buffer_allocz ( ( big_mb_num + h -> mb_stride ) * sizeof ( uint32_t ) ) ;
if ( ! pic -> mb_type_buf ) return AVERROR ( ENOMEM ) ;
pic -> mb_type = ( uint32_t * ) pic -> mb_type_buf -> data + 2 * h -> mb_stride + 1 ;
for ( i = 0 ;
i < 2 ;
i ++ ) {
pic -> motion_val_buf [ i ] = av_buffer_allocz ( 2 * ( b4_array_size + 4 ) * sizeof ( int16_t ) ) ;
pic -> ref_index_buf [ i ] = av_buffer_allocz ( 4 * mb_array_size ) ;
if ( ! pic -> motion_val_buf [ i ] || ! pic -> ref_index_buf [ i ] ) {
ret = AVERROR ( ENOMEM ) ;
goto fail ;
}
pic -> motion_val [ i ] = ( int16_t ( * ) [ 2 ] ) pic -> motion_val_buf [ i ] -> data + 4 ;
pic -> ref_index [ i ] = pic -> ref_index_buf [ i ] -> data ;
}
}
pic -> f . motion_subsample_log2 = 2 ;
pic -> reference = ! ( h -> pict_type == AV_PICTURE_TYPE_B ) ;
ret = ff_get_buffer ( avctx , & pic -> f , pic -> reference ? AV_GET_BUFFER_FLAG_REF : 0 ) ;
if ( ret < 0 ) goto fail ;
if ( ! h -> edge_emu_buffer ) {
h -> edge_emu_buffer = av_mallocz ( pic -> f . linesize [ 0 ] * 17 ) ;
if ( ! h -> edge_emu_buffer ) return AVERROR ( ENOMEM ) ;
}
h -> linesize = pic -> f . linesize [ 0 ] ;
h -> uvlinesize = pic -> f . linesize [ 1 ] ;
return 0 ;
fail : free_picture ( avctx , pic ) ;
return ret ;
} |
-7,559,567,117,301,601,000 | debian | 29 | 1 | int main ( int argc , char * argv [ ] ) {
libettercap_init ( ) ;
ef_globals_alloc ( ) ;
select_text_interface ( ) ;
libettercap_ui_init ( ) ;
fprintf ( stdout , "\n" EC_COLOR_BOLD "%s %s" EC_COLOR_END " copyright %s %s\n\n" , PROGRAM , EC_VERSION , EC_COPYRIGHT , EC_AUTHORS ) ;
EF_GBL -> lineno = 1 ;
parse_options ( argc , argv ) ;
if ( EF_GBL_OPTIONS -> source_file ) {
yyin = fopen ( EF_GBL_OPTIONS -> source_file , "r" ) ;
if ( yyin == NULL ) FATAL_ERROR ( "Input file not found !" ) ;
}
else {
FATAL_ERROR ( "No source file." ) ;
}
setbuf ( yyin , NULL ) ;
setbuf ( stdout , NULL ) ;
setbuf ( stderr , NULL ) ;
load_tables ( ) ;
load_constants ( ) ;
fprintf ( stdout , "\n Parsing source file \'%s\' " , EF_GBL_OPTIONS -> source_file ) ;
fflush ( stdout ) ;
ef_debug ( 1 , "\n" ) ;
if ( yyparse ( ) == 0 ) fprintf ( stdout , " done.\n\n" ) ;
else fprintf ( stdout , "\n\nThe script contains errors...\n\n" ) ;
if ( write_output ( ) != E_SUCCESS ) FATAL_ERROR ( "Cannot write output file (%s)" , EF_GBL_OPTIONS -> output_file ) ;
ef_globals_free ( ) ;
return 0 ;
} |
5,917,118,798,851,366,000 | debian | 12 | 0 | static void dissect_zcl_appl_stats_log_queue_rsp ( tvbuff_t * tvb , proto_tree * tree , guint * offset ) {
gint list_len ;
proto_tree_add_item ( tree , hf_zbee_zcl_appl_stats_log_queue_size , tvb , * offset , 1 , ENC_NA ) ;
* offset += 1 ;
list_len = tvb_reported_length_remaining ( tvb , * offset ) ;
if ( list_len > 0 ) {
while ( * offset < ( guint ) list_len ) {
proto_tree_add_item ( tree , hf_zbee_zcl_appl_stats_log_id , tvb , * offset , 4 , ENC_LITTLE_ENDIAN ) ;
* offset += 4 ;
}
}
} |
4,423,867,112,908,499,000 | chrome | 39 | 0 | void vp9_quantize_b_32x32_c ( const tran_low_t * coeff_ptr , intptr_t n_coeffs , int skip_block , const int16_t * zbin_ptr , const int16_t * round_ptr , const int16_t * quant_ptr , const int16_t * quant_shift_ptr , tran_low_t * qcoeff_ptr , tran_low_t * dqcoeff_ptr , const int16_t * dequant_ptr , int zbin_oq_value , uint16_t * eob_ptr , const int16_t * scan , const int16_t * iscan ) {
const int zbins [ 2 ] = {
ROUND_POWER_OF_TWO ( zbin_ptr [ 0 ] + zbin_oq_value , 1 ) , ROUND_POWER_OF_TWO ( zbin_ptr [ 1 ] + zbin_oq_value , 1 ) }
;
const int nzbins [ 2 ] = {
zbins [ 0 ] * - 1 , zbins [ 1 ] * - 1 }
;
int idx = 0 ;
int idx_arr [ 1024 ] ;
int i , eob = - 1 ;
( void ) iscan ;
vpx_memset ( qcoeff_ptr , 0 , n_coeffs * sizeof ( * qcoeff_ptr ) ) ;
vpx_memset ( dqcoeff_ptr , 0 , n_coeffs * sizeof ( * dqcoeff_ptr ) ) ;
if ( ! skip_block ) {
for ( i = 0 ;
i < n_coeffs ;
i ++ ) {
const int rc = scan [ i ] ;
const int coeff = coeff_ptr [ rc ] ;
if ( coeff >= zbins [ rc != 0 ] || coeff <= nzbins [ rc != 0 ] ) idx_arr [ idx ++ ] = i ;
}
for ( i = 0 ;
i < idx ;
i ++ ) {
const int rc = scan [ idx_arr [ i ] ] ;
const int coeff = coeff_ptr [ rc ] ;
const int coeff_sign = ( coeff >> 31 ) ;
int tmp ;
int abs_coeff = ( coeff ^ coeff_sign ) - coeff_sign ;
abs_coeff += ROUND_POWER_OF_TWO ( round_ptr [ rc != 0 ] , 1 ) ;
abs_coeff = clamp ( abs_coeff , INT16_MIN , INT16_MAX ) ;
tmp = ( ( ( ( abs_coeff * quant_ptr [ rc != 0 ] ) >> 16 ) + abs_coeff ) * quant_shift_ptr [ rc != 0 ] ) >> 15 ;
qcoeff_ptr [ rc ] = ( tmp ^ coeff_sign ) - coeff_sign ;
dqcoeff_ptr [ rc ] = qcoeff_ptr [ rc ] * dequant_ptr [ rc != 0 ] / 2 ;
if ( tmp ) eob = idx_arr [ i ] ;
}
}
* eob_ptr = eob + 1 ;
} |
8,461,782,184,979,846,000 | chrome | 10 | 1 | TEST_F ( ProtocolHandlerRegistryTest , TestReplaceNonDefaultHandler ) {
ProtocolHandler ph1 = CreateProtocolHandler ( "mailto" , GURL ( "http://test.com/%s" ) , "test1" ) ;
ProtocolHandler ph2 = CreateProtocolHandler ( "mailto" , GURL ( "http://test.com/updated-url/%s" ) , "test2" ) ;
ProtocolHandler ph3 = CreateProtocolHandler ( "mailto" , GURL ( "http://else.com/%s" ) , "test3" ) ;
registry ( ) -> OnAcceptRegisterProtocolHandler ( ph1 ) ;
registry ( ) -> OnAcceptRegisterProtocolHandler ( ph3 ) ;
ASSERT_TRUE ( registry ( ) -> AttemptReplace ( ph2 ) ) ;
const ProtocolHandler & handler ( registry ( ) -> GetHandlerFor ( "mailto" ) ) ;
ASSERT_EQ ( handler . url ( ) , ph3 . url ( ) ) ;
} |
-7,076,754,245,473,579,000 | chrome | 3 | 0 | static void fake_freeaddrinfo ( struct addrinfo * ai ) {
free ( ai -> ai_addr ) ;
} |
1,859,256,631,654,517,000 | chrome | 29 | 0 | void ff_h264_draw_horiz_band ( H264Context * h , int y , int height ) {
AVCodecContext * avctx = h -> avctx ;
Picture * cur = & h -> cur_pic ;
Picture * last = h -> ref_list [ 0 ] [ 0 ] . f . data [ 0 ] ? & h -> ref_list [ 0 ] [ 0 ] : NULL ;
const AVPixFmtDescriptor * desc = av_pix_fmt_desc_get ( avctx -> pix_fmt ) ;
int vshift = desc -> log2_chroma_h ;
const int field_pic = h -> picture_structure != PICT_FRAME ;
if ( field_pic ) {
height <<= 1 ;
y <<= 1 ;
}
height = FFMIN ( height , avctx -> height - y ) ;
if ( field_pic && h -> first_field && ! ( avctx -> slice_flags & SLICE_FLAG_ALLOW_FIELD ) ) return ;
if ( avctx -> draw_horiz_band ) {
AVFrame * src ;
int offset [ AV_NUM_DATA_POINTERS ] ;
int i ;
if ( cur -> f . pict_type == AV_PICTURE_TYPE_B || h -> low_delay || ( avctx -> slice_flags & SLICE_FLAG_CODED_ORDER ) ) src = & cur -> f ;
else if ( last ) src = & last -> f ;
else return ;
offset [ 0 ] = y * src -> linesize [ 0 ] ;
offset [ 1 ] = offset [ 2 ] = ( y >> vshift ) * src -> linesize [ 1 ] ;
for ( i = 3 ;
i < AV_NUM_DATA_POINTERS ;
i ++ ) offset [ i ] = 0 ;
emms_c ( ) ;
avctx -> draw_horiz_band ( avctx , src , offset , y , h -> picture_structure , height ) ;
}
} |
7,549,435,794,356,072,000 | debian | 4 | 0 | static VALUE ossl_asn1cons_each ( VALUE self ) {
rb_ary_each ( ossl_asn1_get_value ( self ) ) ;
return self ;
} |
692,314,327,553,049,500 | chrome | 67 | 0 | unsigned int vp8_variance8x8_neon ( const unsigned char * src_ptr , int source_stride , const unsigned char * ref_ptr , int recon_stride , unsigned int * sse ) {
int i ;
uint8x8_t d0u8 , d1u8 , d2u8 , d3u8 , d4u8 , d5u8 , d6u8 , d7u8 ;
int16x4_t d22s16 , d23s16 , d24s16 , d25s16 , d26s16 , d27s16 , d28s16 , d29s16 ;
uint32x2_t d0u32 , d10u32 ;
int64x1_t d0s64 , d1s64 ;
uint16x8_t q11u16 , q12u16 , q13u16 , q14u16 ;
int32x4_t q8s32 , q9s32 , q10s32 ;
int64x2_t q0s64 , q1s64 , q5s64 ;
q8s32 = vdupq_n_s32 ( 0 ) ;
q9s32 = vdupq_n_s32 ( 0 ) ;
q10s32 = vdupq_n_s32 ( 0 ) ;
for ( i = 0 ;
i < 2 ;
i ++ ) {
d0u8 = vld1_u8 ( src_ptr ) ;
src_ptr += source_stride ;
d1u8 = vld1_u8 ( src_ptr ) ;
src_ptr += source_stride ;
d2u8 = vld1_u8 ( src_ptr ) ;
src_ptr += source_stride ;
d3u8 = vld1_u8 ( src_ptr ) ;
src_ptr += source_stride ;
d4u8 = vld1_u8 ( ref_ptr ) ;
ref_ptr += recon_stride ;
d5u8 = vld1_u8 ( ref_ptr ) ;
ref_ptr += recon_stride ;
d6u8 = vld1_u8 ( ref_ptr ) ;
ref_ptr += recon_stride ;
d7u8 = vld1_u8 ( ref_ptr ) ;
ref_ptr += recon_stride ;
q11u16 = vsubl_u8 ( d0u8 , d4u8 ) ;
q12u16 = vsubl_u8 ( d1u8 , d5u8 ) ;
q13u16 = vsubl_u8 ( d2u8 , d6u8 ) ;
q14u16 = vsubl_u8 ( d3u8 , d7u8 ) ;
d22s16 = vreinterpret_s16_u16 ( vget_low_u16 ( q11u16 ) ) ;
d23s16 = vreinterpret_s16_u16 ( vget_high_u16 ( q11u16 ) ) ;
q8s32 = vpadalq_s16 ( q8s32 , vreinterpretq_s16_u16 ( q11u16 ) ) ;
q9s32 = vmlal_s16 ( q9s32 , d22s16 , d22s16 ) ;
q10s32 = vmlal_s16 ( q10s32 , d23s16 , d23s16 ) ;
d24s16 = vreinterpret_s16_u16 ( vget_low_u16 ( q12u16 ) ) ;
d25s16 = vreinterpret_s16_u16 ( vget_high_u16 ( q12u16 ) ) ;
q8s32 = vpadalq_s16 ( q8s32 , vreinterpretq_s16_u16 ( q12u16 ) ) ;
q9s32 = vmlal_s16 ( q9s32 , d24s16 , d24s16 ) ;
q10s32 = vmlal_s16 ( q10s32 , d25s16 , d25s16 ) ;
d26s16 = vreinterpret_s16_u16 ( vget_low_u16 ( q13u16 ) ) ;
d27s16 = vreinterpret_s16_u16 ( vget_high_u16 ( q13u16 ) ) ;
q8s32 = vpadalq_s16 ( q8s32 , vreinterpretq_s16_u16 ( q13u16 ) ) ;
q9s32 = vmlal_s16 ( q9s32 , d26s16 , d26s16 ) ;
q10s32 = vmlal_s16 ( q10s32 , d27s16 , d27s16 ) ;
d28s16 = vreinterpret_s16_u16 ( vget_low_u16 ( q14u16 ) ) ;
d29s16 = vreinterpret_s16_u16 ( vget_high_u16 ( q14u16 ) ) ;
q8s32 = vpadalq_s16 ( q8s32 , vreinterpretq_s16_u16 ( q14u16 ) ) ;
q9s32 = vmlal_s16 ( q9s32 , d28s16 , d28s16 ) ;
q10s32 = vmlal_s16 ( q10s32 , d29s16 , d29s16 ) ;
}
q10s32 = vaddq_s32 ( q10s32 , q9s32 ) ;
q0s64 = vpaddlq_s32 ( q8s32 ) ;
q1s64 = vpaddlq_s32 ( q10s32 ) ;
d0s64 = vadd_s64 ( vget_low_s64 ( q0s64 ) , vget_high_s64 ( q0s64 ) ) ;
d1s64 = vadd_s64 ( vget_low_s64 ( q1s64 ) , vget_high_s64 ( q1s64 ) ) ;
q5s64 = vmull_s32 ( vreinterpret_s32_s64 ( d0s64 ) , vreinterpret_s32_s64 ( d0s64 ) ) ;
vst1_lane_u32 ( ( uint32_t * ) sse , vreinterpret_u32_s64 ( d1s64 ) , 0 ) ;
d10u32 = vshr_n_u32 ( vreinterpret_u32_s64 ( vget_low_s64 ( q5s64 ) ) , 6 ) ;
d0u32 = vsub_u32 ( vreinterpret_u32_s64 ( d1s64 ) , d10u32 ) ;
return vget_lane_u32 ( d0u32 , 0 ) ;
} |
-3,146,697,469,509,848,600 | debian | 3 | 0 | static void int_dsa_free ( EVP_PKEY * pkey ) {
DSA_free ( pkey -> pkey . dsa ) ;
} |
-5,511,323,081,862,746,000 | debian | 5 | 0 | int k12_dump_can_write_encap ( int encap ) {
if ( encap == WTAP_ENCAP_PER_PACKET ) return WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED ;
if ( encap != WTAP_ENCAP_K12 ) return WTAP_ERR_UNWRITABLE_ENCAP ;
return 0 ;
} |
-4,635,544,075,321,012,000 | debian | 12 | 0 | static char * Curl_basename ( char * path ) {
char * s1 ;
char * s2 ;
s1 = strrchr ( path , '/' ) ;
s2 = strrchr ( path , '\\' ) ;
if ( s1 && s2 ) {
path = ( s1 > s2 ? s1 : s2 ) + 1 ;
}
else if ( s1 ) path = s1 + 1 ;
else if ( s2 ) path = s2 + 1 ;
return path ;
} |
7,607,805,321,589,710,000 | debian | 50 | 0 | static int zcvrs ( i_ctx_t * i_ctx_p ) {
os_ptr op = osp ;
int radix ;
check_type ( op [ - 1 ] , t_integer ) ;
if ( op [ - 1 ] . value . intval < 2 || op [ - 1 ] . value . intval > 36 ) return_error ( gs_error_rangecheck ) ;
radix = op [ - 1 ] . value . intval ;
check_write_type ( * op , t_string ) ;
if ( radix == 10 ) {
switch ( r_type ( op - 2 ) ) {
case t_integer : case t_real : {
int code = convert_to_string ( imemory , op - 2 , op ) ;
if ( code < 0 ) return code ;
pop ( 2 ) ;
return 0 ;
}
case t__invalid : return_error ( gs_error_stackunderflow ) ;
default : return_error ( gs_error_rangecheck ) ;
}
}
else {
uint ival ;
byte digits [ sizeof ( ulong ) * 8 ] ;
byte * endp = & digits [ countof ( digits ) ] ;
byte * dp = endp ;
switch ( r_type ( op - 2 ) ) {
case t_integer : ival = ( uint ) op [ - 2 ] . value . intval ;
break ;
case t_real : {
float fval = op [ - 2 ] . value . realval ;
if ( ! REAL_CAN_BE_INT ( fval ) ) return_error ( gs_error_rangecheck ) ;
ival = ( ulong ) ( long ) fval ;
}
break ;
case t__invalid : return_error ( gs_error_stackunderflow ) ;
default : return_error ( gs_error_rangecheck ) ;
}
do {
int dit = ival % radix ;
* -- dp = dit + ( dit < 10 ? '0' : ( 'A' - 10 ) ) ;
ival /= radix ;
}
while ( ival ) ;
if ( endp - dp > r_size ( op ) ) return_error ( gs_error_rangecheck ) ;
memcpy ( op -> value . bytes , dp , ( uint ) ( endp - dp ) ) ;
r_set_size ( op , endp - dp ) ;
}
op [ - 2 ] = * op ;
pop ( 2 ) ;
return 0 ;
} |
1,676,654,288,894,940,700 | debian | 6 | 0 | static krb5_error_code randkey_princ ( krb5_principal princ , krb5_boolean keepold , int n_ks , krb5_key_salt_tuple * ks ) {
if ( keepold || ks ) {
return kadm5_randkey_principal_3 ( handle , princ , keepold , n_ks , ks , NULL , NULL ) ;
}
else return kadm5_randkey_principal ( handle , princ , NULL , NULL ) ;
} |
8,801,969,307,247,113,000 | debian | 415 | 0 | const EVP_CIPHER * EVP_aes_ ## keylen ## _ ## mode ( void ) \ {
return & aes_ ## keylen ## _ ## mode ;
}
# endif # if defined ( OPENSSL_CPUID_OBJ ) && ( defined ( __arm__ ) || defined ( __arm ) || defined ( __aarch64__ ) ) # include "arm_arch.h" # if __ARM_MAX_ARCH__ >= 7 # if defined ( BSAES_ASM ) # define BSAES_CAPABLE ( OPENSSL_armcap_P & ARMV7_NEON ) # endif # if defined ( VPAES_ASM ) # define VPAES_CAPABLE ( OPENSSL_armcap_P & ARMV7_NEON ) # endif # define HWAES_CAPABLE ( OPENSSL_armcap_P & ARMV8_AES ) # define HWAES_set_encrypt_key aes_v8_set_encrypt_key # define HWAES_set_decrypt_key aes_v8_set_decrypt_key # define HWAES_encrypt aes_v8_encrypt # define HWAES_decrypt aes_v8_decrypt # define HWAES_cbc_encrypt aes_v8_cbc_encrypt # define HWAES_ctr32_encrypt_blocks aes_v8_ctr32_encrypt_blocks # endif # endif # if defined ( HWAES_CAPABLE ) int HWAES_set_encrypt_key ( const unsigned char * userKey , const int bits , AES_KEY * key ) ;
int HWAES_set_decrypt_key ( const unsigned char * userKey , const int bits , AES_KEY * key ) ;
void HWAES_encrypt ( const unsigned char * in , unsigned char * out , const AES_KEY * key ) ;
void HWAES_decrypt ( const unsigned char * in , unsigned char * out , const AES_KEY * key ) ;
void HWAES_cbc_encrypt ( const unsigned char * in , unsigned char * out , size_t length , const AES_KEY * key , unsigned char * ivec , const int enc ) ;
void HWAES_ctr32_encrypt_blocks ( const unsigned char * in , unsigned char * out , size_t len , const AES_KEY * key , const unsigned char ivec [ 16 ] ) ;
void HWAES_xts_encrypt ( const unsigned char * inp , unsigned char * out , size_t len , const AES_KEY * key1 , const AES_KEY * key2 , const unsigned char iv [ 16 ] ) ;
void HWAES_xts_decrypt ( const unsigned char * inp , unsigned char * out , size_t len , const AES_KEY * key1 , const AES_KEY * key2 , const unsigned char iv [ 16 ] ) ;
# endif # define BLOCK_CIPHER_generic_pack ( nid , keylen , flags ) \ BLOCK_CIPHER_generic ( nid , keylen , 16 , 16 , cbc , cbc , CBC , flags | EVP_CIPH_FLAG_DEFAULT_ASN1 ) \ BLOCK_CIPHER_generic ( nid , keylen , 16 , 0 , ecb , ecb , ECB , flags | EVP_CIPH_FLAG_DEFAULT_ASN1 ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , ofb128 , ofb , OFB , flags | EVP_CIPH_FLAG_DEFAULT_ASN1 ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , cfb128 , cfb , CFB , flags | EVP_CIPH_FLAG_DEFAULT_ASN1 ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , cfb1 , cfb1 , CFB , flags ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , cfb8 , cfb8 , CFB , flags ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , ctr , ctr , CTR , flags ) static int aes_init_key ( EVP_CIPHER_CTX * ctx , const unsigned char * key , const unsigned char * iv , int enc ) {
int ret , mode ;
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
mode = EVP_CIPHER_CTX_mode ( ctx ) ;
if ( ( mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE ) && ! enc ) {
# ifdef HWAES_CAPABLE if ( HWAES_CAPABLE ) {
ret = HWAES_set_decrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) HWAES_decrypt ;
dat -> stream . cbc = NULL ;
# ifdef HWAES_cbc_encrypt if ( mode == EVP_CIPH_CBC_MODE ) dat -> stream . cbc = ( cbc128_f ) HWAES_cbc_encrypt ;
# endif }
else # endif # ifdef BSAES_CAPABLE if ( BSAES_CAPABLE && mode == EVP_CIPH_CBC_MODE ) {
ret = AES_set_decrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) AES_decrypt ;
dat -> stream . cbc = ( cbc128_f ) bsaes_cbc_encrypt ;
}
else # endif # ifdef VPAES_CAPABLE if ( VPAES_CAPABLE ) {
ret = vpaes_set_decrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) vpaes_decrypt ;
dat -> stream . cbc = mode == EVP_CIPH_CBC_MODE ? ( cbc128_f ) vpaes_cbc_encrypt : NULL ;
}
else # endif {
ret = AES_set_decrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) AES_decrypt ;
dat -> stream . cbc = mode == EVP_CIPH_CBC_MODE ? ( cbc128_f ) AES_cbc_encrypt : NULL ;
}
}
else # ifdef HWAES_CAPABLE if ( HWAES_CAPABLE ) {
ret = HWAES_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) HWAES_encrypt ;
dat -> stream . cbc = NULL ;
# ifdef HWAES_cbc_encrypt if ( mode == EVP_CIPH_CBC_MODE ) dat -> stream . cbc = ( cbc128_f ) HWAES_cbc_encrypt ;
else # endif # ifdef HWAES_ctr32_encrypt_blocks if ( mode == EVP_CIPH_CTR_MODE ) dat -> stream . ctr = ( ctr128_f ) HWAES_ctr32_encrypt_blocks ;
else # endif ( void ) 0 ;
}
else # endif # ifdef BSAES_CAPABLE if ( BSAES_CAPABLE && mode == EVP_CIPH_CTR_MODE ) {
ret = AES_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) AES_encrypt ;
dat -> stream . ctr = ( ctr128_f ) bsaes_ctr32_encrypt_blocks ;
}
else # endif # ifdef VPAES_CAPABLE if ( VPAES_CAPABLE ) {
ret = vpaes_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) vpaes_encrypt ;
dat -> stream . cbc = mode == EVP_CIPH_CBC_MODE ? ( cbc128_f ) vpaes_cbc_encrypt : NULL ;
}
else # endif {
ret = AES_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) AES_encrypt ;
dat -> stream . cbc = mode == EVP_CIPH_CBC_MODE ? ( cbc128_f ) AES_cbc_encrypt : NULL ;
# ifdef AES_CTR_ASM if ( mode == EVP_CIPH_CTR_MODE ) dat -> stream . ctr = ( ctr128_f ) AES_ctr32_encrypt ;
# endif }
if ( ret < 0 ) {
EVPerr ( EVP_F_AES_INIT_KEY , EVP_R_AES_KEY_SETUP_FAILED ) ;
return 0 ;
}
return 1 ;
}
static int aes_cbc_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
if ( dat -> stream . cbc ) ( * dat -> stream . cbc ) ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , EVP_CIPHER_CTX_encrypting ( ctx ) ) ;
else if ( EVP_CIPHER_CTX_encrypting ( ctx ) ) CRYPTO_cbc128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , dat -> block ) ;
else CRYPTO_cbc128_decrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , dat -> block ) ;
return 1 ;
}
static int aes_ecb_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
size_t bl = EVP_CIPHER_CTX_block_size ( ctx ) ;
size_t i ;
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
if ( len < bl ) return 1 ;
for ( i = 0 , len -= bl ;
i <= len ;
i += bl ) ( * dat -> block ) ( in + i , out + i , & dat -> ks ) ;
return 1 ;
}
static int aes_ofb_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_ofb128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
static int aes_cfb_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
static int aes_cfb8_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_8_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
static int aes_cfb1_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
if ( EVP_CIPHER_CTX_test_flags ( ctx , EVP_CIPH_FLAG_LENGTH_BITS ) ) {
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_1_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
while ( len >= MAXBITCHUNK ) {
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_1_encrypt ( in , out , MAXBITCHUNK * 8 , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
len -= MAXBITCHUNK ;
}
if ( len ) {
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_1_encrypt ( in , out , len * 8 , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
}
return 1 ;
}
static int aes_ctr_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
unsigned int num = EVP_CIPHER_CTX_num ( ctx ) ;
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
if ( dat -> stream . ctr ) CRYPTO_ctr128_encrypt_ctr32 ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , EVP_CIPHER_CTX_buf_noconst ( ctx ) , & num , dat -> stream . ctr ) ;
else CRYPTO_ctr128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , EVP_CIPHER_CTX_buf_noconst ( ctx ) , & num , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
BLOCK_CIPHER_generic_pack ( NID_aes , 128 , 0 ) BLOCK_CIPHER_generic_pack ( NID_aes , 192 , 0 ) BLOCK_CIPHER_generic_pack ( NID_aes , 256 , 0 ) static int aes_gcm_cleanup ( EVP_CIPHER_CTX * c ) {
EVP_AES_GCM_CTX * gctx = EVP_C_DATA ( EVP_AES_GCM_CTX , c ) ;
OPENSSL_cleanse ( & gctx -> gcm , sizeof ( gctx -> gcm ) ) ;
if ( gctx -> iv != EVP_CIPHER_CTX_iv_noconst ( c ) ) OPENSSL_free ( gctx -> iv ) ;
return 1 ;
}
static void ctr64_inc ( unsigned char * counter ) {
int n = 8 ;
unsigned char c ;
do {
-- n ;
c = counter [ n ] ;
++ c ;
counter [ n ] = c ;
if ( c ) return ;
}
while ( n ) ;
}
static int aes_gcm_ctrl ( EVP_CIPHER_CTX * c , int type , int arg , void * ptr ) {
EVP_AES_GCM_CTX * gctx = EVP_C_DATA ( EVP_AES_GCM_CTX , c ) ;
switch ( type ) {
case EVP_CTRL_INIT : gctx -> key_set = 0 ;
gctx -> iv_set = 0 ;
gctx -> ivlen = EVP_CIPHER_CTX_iv_length ( c ) ;
gctx -> iv = EVP_CIPHER_CTX_iv_noconst ( c ) ;
gctx -> taglen = - 1 ;
gctx -> iv_gen = 0 ;
gctx -> tls_aad_len = - 1 ;
return 1 ;
case EVP_CTRL_AEAD_SET_IVLEN : if ( arg <= 0 ) return 0 ;
if ( ( arg > EVP_MAX_IV_LENGTH ) && ( arg > gctx -> ivlen ) ) {
if ( gctx -> iv != EVP_CIPHER_CTX_iv_noconst ( c ) ) OPENSSL_free ( gctx -> iv ) ;
gctx -> iv = OPENSSL_malloc ( arg ) ;
if ( gctx -> iv == NULL ) return 0 ;
}
gctx -> ivlen = arg ;
return 1 ;
case EVP_CTRL_AEAD_SET_TAG : if ( arg <= 0 || arg > 16 || EVP_CIPHER_CTX_encrypting ( c ) ) return 0 ;
memcpy ( EVP_CIPHER_CTX_buf_noconst ( c ) , ptr , arg ) ;
gctx -> taglen = arg ;
return 1 ;
case EVP_CTRL_AEAD_GET_TAG : if ( arg <= 0 || arg > 16 || ! EVP_CIPHER_CTX_encrypting ( c ) || gctx -> taglen < 0 ) return 0 ;
memcpy ( ptr , EVP_CIPHER_CTX_buf_noconst ( c ) , arg ) ;
return 1 ;
case EVP_CTRL_GCM_SET_IV_FIXED : if ( arg == - 1 ) {
memcpy ( gctx -> iv , ptr , gctx -> ivlen ) ;
gctx -> iv_gen = 1 ;
return 1 ;
}
if ( ( arg < 4 ) || ( gctx -> ivlen - arg ) < 8 ) return 0 ;
if ( arg ) memcpy ( gctx -> iv , ptr , arg ) ;
if ( EVP_CIPHER_CTX_encrypting ( c ) && RAND_bytes ( gctx -> iv + arg , gctx -> ivlen - arg ) <= 0 ) return 0 ;
gctx -> iv_gen = 1 ;
return 1 ;
case EVP_CTRL_GCM_IV_GEN : if ( gctx -> iv_gen == 0 || gctx -> key_set == 0 ) return 0 ;
CRYPTO_gcm128_setiv ( & gctx -> gcm , gctx -> iv , gctx -> ivlen ) ;
if ( arg <= 0 || arg > gctx -> ivlen ) arg = gctx -> ivlen ;
memcpy ( ptr , gctx -> iv + gctx -> ivlen - arg , arg ) ;
ctr64_inc ( gctx -> iv + gctx -> ivlen - 8 ) ;
gctx -> iv_set = 1 ;
return 1 ;
case EVP_CTRL_GCM_SET_IV_INV : if ( gctx -> iv_gen == 0 || gctx -> key_set == 0 || EVP_CIPHER_CTX_encrypting ( c ) ) return 0 ;
memcpy ( gctx -> iv + gctx -> ivlen - arg , ptr , arg ) ;
CRYPTO_gcm128_setiv ( & gctx -> gcm , gctx -> iv , gctx -> ivlen ) ;
gctx -> iv_set = 1 ;
return 1 ;
case EVP_CTRL_AEAD_TLS1_AAD : if ( arg != EVP_AEAD_TLS1_AAD_LEN ) return 0 ;
memcpy ( EVP_CIPHER_CTX_buf_noconst ( c ) , ptr , arg ) ;
gctx -> tls_aad_len = arg ;
{
unsigned int len = EVP_CIPHER_CTX_buf_noconst ( c ) [ arg - 2 ] << 8 | EVP_CIPHER_CTX_buf_noconst ( c ) [ arg - 1 ] ;
if ( len < EVP_GCM_TLS_EXPLICIT_IV_LEN ) return 0 ;
len -= EVP_GCM_TLS_EXPLICIT_IV_LEN ;
if ( ! EVP_CIPHER_CTX_encrypting ( c ) ) {
if ( len < EVP_GCM_TLS_TAG_LEN ) return 0 ;
len -= EVP_GCM_TLS_TAG_LEN ;
}
EVP_CIPHER_CTX_buf_noconst ( c ) [ arg - 2 ] = len >> 8 ;
EVP_CIPHER_CTX_buf_noconst ( c ) [ arg - 1 ] = len & 0xff ;
}
return EVP_GCM_TLS_TAG_LEN ;
case EVP_CTRL_COPY : {
EVP_CIPHER_CTX * out = ptr ;
EVP_AES_GCM_CTX * gctx_out = EVP_C_DATA ( EVP_AES_GCM_CTX , out ) ;
if ( gctx -> gcm . key ) {
if ( gctx -> gcm . key != & gctx -> ks ) return 0 ;
gctx_out -> gcm . key = & gctx_out -> ks ;
}
if ( gctx -> iv == EVP_CIPHER_CTX_iv_noconst ( c ) ) gctx_out -> iv = EVP_CIPHER_CTX_iv_noconst ( out ) ;
else {
gctx_out -> iv = OPENSSL_malloc ( gctx -> ivlen ) ;
if ( gctx_out -> iv == NULL ) return 0 ;
memcpy ( gctx_out -> iv , gctx -> iv , gctx -> ivlen ) ;
}
return 1 ;
}
default : return - 1 ;
}
}
static int aes_gcm_init_key ( EVP_CIPHER_CTX * ctx , const unsigned char * key , const unsigned char * iv , int enc ) {
EVP_AES_GCM_CTX * gctx = EVP_C_DATA ( EVP_AES_GCM_CTX , ctx ) ;
if ( ! iv && ! key ) return 1 ;
if ( key ) {
do {
# ifdef HWAES_CAPABLE if ( HWAES_CAPABLE ) {
HWAES_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & gctx -> ks . ks ) ;
CRYPTO_gcm128_init ( & gctx -> gcm , & gctx -> ks , ( block128_f ) HWAES_encrypt ) ;
# ifdef HWAES_ctr32_encrypt_blocks gctx -> ctr = ( ctr128_f ) HWAES_ctr32_encrypt_blocks ;
# else gctx -> ctr = NULL ;
# endif break ;
}
else # endif # ifdef BSAES_CAPABLE if ( BSAES_CAPABLE ) {
AES_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & gctx -> ks . ks ) ;
CRYPTO_gcm128_init ( & gctx -> gcm , & gctx -> ks , ( block128_f ) AES_encrypt ) ;
gctx -> ctr = ( ctr128_f ) bsaes_ctr32_encrypt_blocks ;
break ;
}
else # endif # ifdef VPAES_CAPABLE if ( VPAES_CAPABLE ) {
vpaes_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & gctx -> ks . ks ) ;
CRYPTO_gcm128_init ( & gctx -> gcm , & gctx -> ks , ( block128_f ) vpaes_encrypt ) ;
gctx -> ctr = NULL ;
break ;
}
else # endif ( void ) 0 ;
AES_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & gctx -> ks . ks ) ;
CRYPTO_gcm128_init ( & gctx -> gcm , & gctx -> ks , ( block128_f ) AES_encrypt ) ;
# ifdef AES_CTR_ASM gctx -> ctr = ( ctr128_f ) AES_ctr32_encrypt ;
# else gctx -> ctr = NULL ;
# endif }
while ( 0 ) ;
if ( iv == NULL && gctx -> iv_set ) iv = gctx -> iv ;
if ( iv ) {
CRYPTO_gcm128_setiv ( & gctx -> gcm , iv , gctx -> ivlen ) ;
gctx -> iv_set = 1 ;
}
gctx -> key_set = 1 ;
}
else {
if ( gctx -> key_set ) CRYPTO_gcm128_setiv ( & gctx -> gcm , iv , gctx -> ivlen ) ;
else memcpy ( gctx -> iv , iv , gctx -> ivlen ) ;
gctx -> iv_set = 1 ;
gctx -> iv_gen = 0 ;
}
return 1 ;
}
static int aes_gcm_tls_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_GCM_CTX * gctx = EVP_C_DATA ( EVP_AES_GCM_CTX , ctx ) ;
int rv = - 1 ;
if ( out != in || len < ( EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN ) ) return - 1 ;
if ( EVP_CIPHER_CTX_ctrl ( ctx , EVP_CIPHER_CTX_encrypting ( ctx ) ? EVP_CTRL_GCM_IV_GEN : EVP_CTRL_GCM_SET_IV_INV , EVP_GCM_TLS_EXPLICIT_IV_LEN , out ) <= 0 ) goto err ;
if ( CRYPTO_gcm128_aad ( & gctx -> gcm , EVP_CIPHER_CTX_buf_noconst ( ctx ) , gctx -> tls_aad_len ) ) goto err ;
in += EVP_GCM_TLS_EXPLICIT_IV_LEN ;
out += EVP_GCM_TLS_EXPLICIT_IV_LEN ;
len -= EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN ;
if ( EVP_CIPHER_CTX_encrypting ( ctx ) ) {
if ( gctx -> ctr ) {
size_t bulk = 0 ;
# if defined ( AES_GCM_ASM ) if ( len >= 32 && AES_GCM_ASM ( gctx ) ) {
if ( CRYPTO_gcm128_encrypt ( & gctx -> gcm , NULL , NULL , 0 ) ) return - 1 ;
bulk = AES_gcm_encrypt ( in , out , len , gctx -> gcm . key , gctx -> gcm . Yi . c , gctx -> gcm . Xi . u ) ;
gctx -> gcm . len . u [ 1 ] += bulk ;
}
# endif if ( CRYPTO_gcm128_encrypt_ctr32 ( & gctx -> gcm , in + bulk , out + bulk , len - bulk , gctx -> ctr ) ) goto err ;
}
else {
size_t bulk = 0 ;
# if defined ( AES_GCM_ASM2 ) if ( len >= 32 && AES_GCM_ASM2 ( gctx ) ) {
if ( CRYPTO_gcm128_encrypt ( & gctx -> gcm , NULL , NULL , 0 ) ) return - 1 ;
bulk = AES_gcm_encrypt ( in , out , len , gctx -> gcm . key , gctx -> gcm . Yi . c , gctx -> gcm . Xi . u ) ;
gctx -> gcm . len . u [ 1 ] += bulk ;
}
# endif if ( CRYPTO_gcm128_encrypt ( & gctx -> gcm , in + bulk , out + bulk , len - bulk ) ) goto err ;
}
out += len ;
CRYPTO_gcm128_tag ( & gctx -> gcm , out , EVP_GCM_TLS_TAG_LEN ) ;
rv = len + EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN ;
}
else {
if ( gctx -> ctr ) {
size_t bulk = 0 ;
# if defined ( AES_GCM_ASM ) if ( len >= 16 && AES_GCM_ASM ( gctx ) ) {
if ( CRYPTO_gcm128_decrypt ( & gctx -> gcm , NULL , NULL , 0 ) ) return - 1 ;
bulk = AES_gcm_decrypt ( in , out , len , gctx -> gcm . key , gctx -> gcm . Yi . c , gctx -> gcm . Xi . u ) ;
gctx -> gcm . len . u [ 1 ] += bulk ;
}
# endif if ( CRYPTO_gcm128_decrypt_ctr32 ( & gctx -> gcm , in + bulk , out + bulk , len - bulk , gctx -> ctr ) ) goto err ;
}
else {
size_t bulk = 0 ;
# if defined ( AES_GCM_ASM2 ) if ( len >= 16 && AES_GCM_ASM2 ( gctx ) ) {
if ( CRYPTO_gcm128_decrypt ( & gctx -> gcm , NULL , NULL , 0 ) ) return - 1 ;
bulk = AES_gcm_decrypt ( in , out , len , gctx -> gcm . key , gctx -> gcm . Yi . c , gctx -> gcm . Xi . u ) ;
gctx -> gcm . len . u [ 1 ] += bulk ;
}
# endif if ( CRYPTO_gcm128_decrypt ( & gctx -> gcm , in + bulk , out + bulk , len - bulk ) ) goto err ;
}
CRYPTO_gcm128_tag ( & gctx -> gcm , EVP_CIPHER_CTX_buf_noconst ( ctx ) , EVP_GCM_TLS_TAG_LEN ) ;
if ( CRYPTO_memcmp ( EVP_CIPHER_CTX_buf_noconst ( ctx ) , in + len , EVP_GCM_TLS_TAG_LEN ) ) {
OPENSSL_cleanse ( out , len ) ;
goto err ;
}
rv = len ;
}
err : gctx -> iv_set = 0 ;
gctx -> tls_aad_len = - 1 ;
return rv ;
}
static int aes_gcm_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_GCM_CTX * gctx = EVP_C_DATA ( EVP_AES_GCM_CTX , ctx ) ;
if ( ! gctx -> key_set ) return - 1 ;
if ( gctx -> tls_aad_len >= 0 ) return aes_gcm_tls_cipher ( ctx , out , in , len ) ;
if ( ! gctx -> iv_set ) return - 1 ;
if ( in ) {
if ( out == NULL ) {
if ( CRYPTO_gcm128_aad ( & gctx -> gcm , in , len ) ) return - 1 ;
}
else if ( EVP_CIPHER_CTX_encrypting ( ctx ) ) {
if ( gctx -> ctr ) {
size_t bulk = 0 ;
# if defined ( AES_GCM_ASM ) if ( len >= 32 && AES_GCM_ASM ( gctx ) ) {
size_t res = ( 16 - gctx -> gcm . mres ) % 16 ;
if ( CRYPTO_gcm128_encrypt ( & gctx -> gcm , in , out , res ) ) return - 1 ;
bulk = AES_gcm_encrypt ( in + res , out + res , len - res , gctx -> gcm . key , gctx -> gcm . Yi . c , gctx -> gcm . Xi . u ) ;
gctx -> gcm . len . u [ 1 ] += bulk ;
bulk += res ;
}
# endif if ( CRYPTO_gcm128_encrypt_ctr32 ( & gctx -> gcm , in + bulk , out + bulk , len - bulk , gctx -> ctr ) ) return - 1 ;
}
else {
size_t bulk = 0 ;
# if defined ( AES_GCM_ASM2 ) if ( len >= 32 && AES_GCM_ASM2 ( gctx ) ) {
size_t res = ( 16 - gctx -> gcm . mres ) % 16 ;
if ( CRYPTO_gcm128_encrypt ( & gctx -> gcm , in , out , res ) ) return - 1 ;
bulk = AES_gcm_encrypt ( in + res , out + res , len - res , gctx -> gcm . key , gctx -> gcm . Yi . c , gctx -> gcm . Xi . u ) ;
gctx -> gcm . len . u [ 1 ] += bulk ;
bulk += res ;
}
# endif if ( CRYPTO_gcm128_encrypt ( & gctx -> gcm , in + bulk , out + bulk , len - bulk ) ) return - 1 ;
}
}
else {
if ( gctx -> ctr ) {
size_t bulk = 0 ;
# if defined ( AES_GCM_ASM ) if ( len >= 16 && AES_GCM_ASM ( gctx ) ) {
size_t res = ( 16 - gctx -> gcm . mres ) % 16 ;
if ( CRYPTO_gcm128_decrypt ( & gctx -> gcm , in , out , res ) ) return - 1 ;
bulk = AES_gcm_decrypt ( in + res , out + res , len - res , gctx -> gcm . key , gctx -> gcm . Yi . c , gctx -> gcm . Xi . u ) ;
gctx -> gcm . len . u [ 1 ] += bulk ;
bulk += res ;
}
# endif if ( CRYPTO_gcm128_decrypt_ctr32 ( & gctx -> gcm , in + bulk , out + bulk , len - bulk , gctx -> ctr ) ) return - 1 ;
}
else {
size_t bulk = 0 ;
# if defined ( AES_GCM_ASM2 ) if ( len >= 16 && AES_GCM_ASM2 ( gctx ) ) {
size_t res = ( 16 - gctx -> gcm . mres ) % 16 ;
if ( CRYPTO_gcm128_decrypt ( & gctx -> gcm , in , out , res ) ) return - 1 ;
bulk = AES_gcm_decrypt ( in + res , out + res , len - res , gctx -> gcm . key , gctx -> gcm . Yi . c , gctx -> gcm . Xi . u ) ;
gctx -> gcm . len . u [ 1 ] += bulk ;
bulk += res ;
}
# endif if ( CRYPTO_gcm128_decrypt ( & gctx -> gcm , in + bulk , out + bulk , len - bulk ) ) return - 1 ;
}
}
return len ;
}
else {
if ( ! EVP_CIPHER_CTX_encrypting ( ctx ) ) {
if ( gctx -> taglen < 0 ) return - 1 ;
if ( CRYPTO_gcm128_finish ( & gctx -> gcm , EVP_CIPHER_CTX_buf_noconst ( ctx ) , gctx -> taglen ) != 0 ) return - 1 ;
gctx -> iv_set = 0 ;
return 0 ;
}
CRYPTO_gcm128_tag ( & gctx -> gcm , EVP_CIPHER_CTX_buf_noconst ( ctx ) , 16 ) ;
gctx -> taglen = 16 ;
gctx -> iv_set = 0 ;
return 0 ;
}
}
# define CUSTOM_FLAGS ( EVP_CIPH_FLAG_DEFAULT_ASN1 \ | EVP_CIPH_CUSTOM_IV | EVP_CIPH_FLAG_CUSTOM_CIPHER \ | EVP_CIPH_ALWAYS_CALL_INIT | EVP_CIPH_CTRL_INIT \ | EVP_CIPH_CUSTOM_COPY ) BLOCK_CIPHER_custom ( NID_aes , 128 , 1 , 12 , gcm , GCM , EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS ) BLOCK_CIPHER_custom ( NID_aes , 192 , 1 , 12 , gcm , GCM , EVP_CIPH_FLAG_AEAD_CIPHER | CUSTOM_FLAGS ) |
-6,552,851,419,396,579,000 | debian | 6 | 0 | static int SpoolssGeneric_r ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep _U_ ) {
int len = tvb_reported_length ( tvb ) ;
proto_tree_add_expert ( tree , pinfo , & ei_unimplemented_dissector , tvb , offset , 0 ) ;
offset = dissect_doserror ( tvb , len - 4 , pinfo , tree , di , drep , hf_rc , NULL ) ;
return offset ;
} |
-4,239,386,405,881,995,300 | chrome | 25 | 0 | xmlHashTablePtr xmlHashCopy ( xmlHashTablePtr table , xmlHashCopier f ) {
int i ;
xmlHashEntryPtr iter ;
xmlHashEntryPtr next ;
xmlHashTablePtr ret ;
if ( table == NULL ) return ( NULL ) ;
if ( f == NULL ) return ( NULL ) ;
ret = xmlHashCreate ( table -> size ) ;
if ( ret == NULL ) return ( NULL ) ;
if ( table -> table ) {
for ( i = 0 ;
i < table -> size ;
i ++ ) {
if ( table -> table [ i ] . valid == 0 ) continue ;
iter = & ( table -> table [ i ] ) ;
while ( iter ) {
next = iter -> next ;
xmlHashAddEntry3 ( ret , iter -> name , iter -> name2 , iter -> name3 , f ( iter -> payload , iter -> name ) ) ;
iter = next ;
}
}
}
ret -> nbElems = table -> nbElems ;
return ( ret ) ;
} |
-8,884,965,407,551,054,000 | debian | 21 | 0 | static void DecoderPlaySpu ( decoder_t * p_dec , subpicture_t * p_subpic ) {
decoder_owner_sys_t * p_owner = p_dec -> p_owner ;
vout_thread_t * p_vout = p_owner -> p_spu_vout ;
if ( p_subpic -> i_start <= VLC_TS_INVALID ) {
msg_Warn ( p_dec , "non-dated spu buffer received" ) ;
subpicture_Delete ( p_subpic ) ;
return ;
}
vlc_mutex_lock ( & p_owner -> lock ) ;
if ( p_owner -> b_waiting ) {
p_owner -> b_has_data = true ;
vlc_cond_signal ( & p_owner -> wait_acknowledge ) ;
}
bool b_reject = DecoderWaitUnblock ( p_dec ) ;
DecoderFixTs ( p_dec , & p_subpic -> i_start , & p_subpic -> i_stop , NULL , NULL , INT64_MAX ) ;
if ( p_subpic -> i_start <= VLC_TS_INVALID ) b_reject = true ;
DecoderWaitDate ( p_dec , & b_reject , p_subpic -> i_start - SPU_MAX_PREPARE_TIME ) ;
vlc_mutex_unlock ( & p_owner -> lock ) ;
if ( ! b_reject ) vout_PutSubpicture ( p_vout , p_subpic ) ;
else subpicture_Delete ( p_subpic ) ;
} |
-769,658,847,024,738,700 | debian | 13 | 0 | static gpgme_error_t uiserver_cancel ( void * engine ) {
engine_uiserver_t uiserver = engine ;
if ( ! uiserver ) return gpg_error ( GPG_ERR_INV_VALUE ) ;
if ( uiserver -> status_cb . fd != - 1 ) _gpgme_io_close ( uiserver -> status_cb . fd ) ;
if ( uiserver -> input_cb . fd != - 1 ) _gpgme_io_close ( uiserver -> input_cb . fd ) ;
if ( uiserver -> output_cb . fd != - 1 ) _gpgme_io_close ( uiserver -> output_cb . fd ) ;
if ( uiserver -> message_cb . fd != - 1 ) _gpgme_io_close ( uiserver -> message_cb . fd ) ;
if ( uiserver -> assuan_ctx ) {
assuan_release ( uiserver -> assuan_ctx ) ;
uiserver -> assuan_ctx = NULL ;
}
return 0 ;
} |
-4,719,501,675,862,911,000 | debian | 7 | 0 | static void update_unicast_addr ( unicast_addr_t * req_addr , unicast_addr_t * ack_addr ) {
if ( ack_addr -> addr . type != AT_NONE && ack_addr -> port != 0 ) {
memcpy ( req_addr -> addr_buf , ack_addr -> addr_buf , sizeof ( req_addr -> addr_buf ) ) ;
SET_ADDRESS ( & req_addr -> addr , ack_addr -> addr . type , ack_addr -> addr . len , req_addr -> addr_buf ) ;
req_addr -> port = ack_addr -> port ;
}
} |
1,981,604,082,870,872,600 | chrome | 12 | 0 | static int32_t u_printf_char_handler ( const u_printf_stream_handler * handler , void * context , ULocaleBundle * formatBundle , const u_printf_spec_info * info , const ufmt_args * args ) {
( void ) formatBundle ;
UChar s [ U16_MAX_LENGTH + 1 ] ;
int32_t len = 1 , written ;
unsigned char arg = ( unsigned char ) ( args [ 0 ] . int64Value ) ;
ufmt_defaultCPToUnicode ( ( const char * ) & arg , 2 , s , UPRV_LENGTHOF ( s ) ) ;
if ( arg != 0 ) {
len = u_strlen ( s ) ;
}
written = handler -> pad_and_justify ( context , info , s , len ) ;
return written ;
} |
7,092,216,800,726,730,000 | debian | 5 | 0 | static int dissect_h245_T_h223_al_type_al2WithSequenceNumbers ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 309 "../../asn1/h245/h245.cnf" if ( h223_lc_params_temp ) h223_lc_params_temp -> al_type = al2WithSequenceNumbers ;
offset = dissect_per_null ( tvb , offset , actx , tree , hf_index ) ;
return offset ;
} |
5,357,882,892,791,796,000 | debian | 3 | 0 | static void e1000e_set_dlen ( E1000ECore * core , int index , uint32_t val ) {
core -> mac [ index ] = val & E1000_XDLEN_MASK ;
} |
3,668,456,668,028,960,000 | debian | 16 | 0 | static void generate_json_float ( FBuffer * buffer , VALUE Vstate , JSON_Generator_State * state , VALUE obj ) {
double value = RFLOAT_VALUE ( obj ) ;
char allow_nan = state -> allow_nan ;
VALUE tmp = rb_funcall ( obj , i_to_s , 0 ) ;
if ( ! allow_nan ) {
if ( isinf ( value ) ) {
fbuffer_free ( buffer ) ;
rb_raise ( eGeneratorError , "%u: %" PRIsVALUE " not allowed in JSON" , __LINE__ , RB_OBJ_STRING ( tmp ) ) ;
}
else if ( isnan ( value ) ) {
fbuffer_free ( buffer ) ;
rb_raise ( eGeneratorError , "%u: %" PRIsVALUE " not allowed in JSON" , __LINE__ , RB_OBJ_STRING ( tmp ) ) ;
}
}
fbuffer_append_str ( buffer , tmp ) ;
} |
-8,721,757,784,652,752,000 | debian | 3 | 0 | static int jpc_calcssexp ( jpc_fix_t stepsize ) {
return jpc_firstone ( stepsize ) - JPC_FIX_FRACBITS ;
} |
7,092,216,800,726,730,000 | debian | 4 | 0 | static int dissect_h245_T_containedThreads ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_constrained_sequence_of ( tvb , offset , actx , tree , hf_index , ett_h245_T_containedThreads , T_containedThreads_sequence_of , 1 , 256 , FALSE ) ;
return offset ;
} |
5,366,785,327,268,799,000 | chrome | 3 | 0 | IN_PROC_BROWSER_TEST_F ( MimeHandlerViewTest , NonAsciiHeaders ) {
RunTest ( "testNonAsciiHeaders.csv" ) ;
} |
1,312,888,211,311,687,000 | debian | 8 | 0 | static int lbmpdm_get_segment_length ( tvbuff_t * tvb , int offset , int encoding , int * data_length ) {
guint32 datalen = 0 ;
int seglen = 0 ;
datalen = lbmpdm_fetch_uint32_encoded ( tvb , offset + O_LBMPDM_SEG_HDR_T_LEN , encoding ) ;
seglen = ( ( int ) datalen ) + L_LBMPDM_SEG_HDR_T ;
* data_length = ( int ) datalen ;
return ( seglen ) ;
} |
8,084,418,997,489,372,000 | chrome | 3 | 0 | static hb_codepoint_t hb_icu_unicode_mirroring ( hb_unicode_funcs_t * ufuncs HB_UNUSED , hb_codepoint_t unicode , void * user_data HB_UNUSED ) {
return u_charMirror ( unicode ) ;
} |
252,275,190,935,145,020 | debian | 93 | 0 | static const uint8_t * decode_tiles_mt ( VP9Decoder * pbi , const uint8_t * data , const uint8_t * data_end ) {
VP9_COMMON * const cm = & pbi -> common ;
const VP9WorkerInterface * const winterface = vp9_get_worker_interface ( ) ;
const uint8_t * bit_reader_end = NULL ;
const int aligned_mi_cols = mi_cols_aligned_to_sb ( cm -> mi_cols ) ;
const int tile_cols = 1 << cm -> log2_tile_cols ;
const int tile_rows = 1 << cm -> log2_tile_rows ;
const int num_workers = MIN ( pbi -> max_threads & ~ 1 , tile_cols ) ;
TileBuffer tile_buffers [ 1 ] [ 1 << 6 ] ;
int n ;
int final_worker = - 1 ;
assert ( tile_cols <= ( 1 << 6 ) ) ;
assert ( tile_rows == 1 ) ;
( void ) tile_rows ;
if ( pbi -> num_tile_workers == 0 ) {
const int num_threads = pbi -> max_threads & ~ 1 ;
int i ;
CHECK_MEM_ERROR ( cm , pbi -> tile_workers , vpx_malloc ( num_threads * sizeof ( * pbi -> tile_workers ) ) ) ;
for ( i = 0 ;
i < num_threads ;
++ i ) {
VP9Worker * const worker = & pbi -> tile_workers [ i ] ;
++ pbi -> num_tile_workers ;
winterface -> init ( worker ) ;
CHECK_MEM_ERROR ( cm , worker -> data1 , vpx_memalign ( 32 , sizeof ( TileWorkerData ) ) ) ;
CHECK_MEM_ERROR ( cm , worker -> data2 , vpx_malloc ( sizeof ( TileInfo ) ) ) ;
if ( i < num_threads - 1 && ! winterface -> reset ( worker ) ) {
vpx_internal_error ( & cm -> error , VPX_CODEC_ERROR , "Tile decoder thread creation failed" ) ;
}
}
}
for ( n = 0 ;
n < num_workers ;
++ n ) {
pbi -> tile_workers [ n ] . hook = ( VP9WorkerHook ) tile_worker_hook ;
}
vpx_memset ( cm -> above_context , 0 , sizeof ( * cm -> above_context ) * MAX_MB_PLANE * 2 * aligned_mi_cols ) ;
vpx_memset ( cm -> above_seg_context , 0 , sizeof ( * cm -> above_seg_context ) * aligned_mi_cols ) ;
get_tile_buffers ( pbi , data , data_end , tile_cols , tile_rows , tile_buffers ) ;
qsort ( tile_buffers [ 0 ] , tile_cols , sizeof ( tile_buffers [ 0 ] [ 0 ] ) , compare_tile_buffers ) ;
{
int group_start = 0 ;
while ( group_start < tile_cols ) {
const TileBuffer largest = tile_buffers [ 0 ] [ group_start ] ;
const int group_end = MIN ( group_start + num_workers , tile_cols ) - 1 ;
memmove ( tile_buffers [ 0 ] + group_start , tile_buffers [ 0 ] + group_start + 1 , ( group_end - group_start ) * sizeof ( tile_buffers [ 0 ] [ 0 ] ) ) ;
tile_buffers [ 0 ] [ group_end ] = largest ;
group_start = group_end + 1 ;
}
}
n = 0 ;
while ( n < tile_cols ) {
int i ;
for ( i = 0 ;
i < num_workers && n < tile_cols ;
++ i ) {
VP9Worker * const worker = & pbi -> tile_workers [ i ] ;
TileWorkerData * const tile_data = ( TileWorkerData * ) worker -> data1 ;
TileInfo * const tile = ( TileInfo * ) worker -> data2 ;
TileBuffer * const buf = & tile_buffers [ 0 ] [ n ] ;
tile_data -> cm = cm ;
tile_data -> xd = pbi -> mb ;
tile_data -> xd . corrupted = 0 ;
vp9_tile_init ( tile , tile_data -> cm , 0 , buf -> col ) ;
setup_token_decoder ( buf -> data , data_end , buf -> size , & cm -> error , & tile_data -> bit_reader , pbi -> decrypt_cb , pbi -> decrypt_state ) ;
init_macroblockd ( cm , & tile_data -> xd ) ;
vp9_zero ( tile_data -> xd . dqcoeff ) ;
worker -> had_error = 0 ;
if ( i == num_workers - 1 || n == tile_cols - 1 ) {
winterface -> execute ( worker ) ;
}
else {
winterface -> launch ( worker ) ;
}
if ( buf -> col == tile_cols - 1 ) {
final_worker = i ;
}
++ n ;
}
for ( ;
i > 0 ;
-- i ) {
VP9Worker * const worker = & pbi -> tile_workers [ i - 1 ] ;
pbi -> mb . corrupted |= ! winterface -> sync ( worker ) ;
}
if ( final_worker > - 1 ) {
TileWorkerData * const tile_data = ( TileWorkerData * ) pbi -> tile_workers [ final_worker ] . data1 ;
bit_reader_end = vp9_reader_find_end ( & tile_data -> bit_reader ) ;
final_worker = - 1 ;
}
}
return bit_reader_end ;
} |
4,489,017,523,191,997,000 | debian | 4 | 0 | static int dissect_h225_NonStandardProtocol ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h225_NonStandardProtocol , NonStandardProtocol_sequence ) ;
return offset ;
} |
6,336,384,260,629,386,000 | debian | 84 | 0 | void proto_register_zbee_zcl_power_config ( void ) {
static hf_register_info hf [ ] = {
{
& hf_zbee_zcl_power_config_attr_id , {
"Attribute" , "zbee_zcl_general.power_config.attr_id" , FT_UINT16 , BASE_HEX , VALS ( zbee_zcl_power_config_attr_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_batt_type , {
"Battery Type" , "zbee_zcl_general.power_config.attr.batt_type" , FT_UINT8 , BASE_HEX , VALS ( zbee_zcl_power_config_batt_type_names ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_mains_alarm_mask , {
"Mains Alarm Mask" , "zbee_zcl_general.power_config.attr.mains_alarm_mask" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_mains_alarm_mask_low , {
"Mains Voltage too low" , "zbee_zcl_general.power_config.attr.mains_alarm_mask.mains_too_low" , FT_UINT8 , BASE_DEC , NULL , ZBEE_ZCL_POWER_CONF_MAINS_ALARM_LOW , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_mains_alarm_mask_high , {
"Mains Voltage too high" , "zbee_zcl_general.power_config.attr.mains_alarm_mask.mains_too_high" , FT_UINT8 , BASE_DEC , NULL , ZBEE_ZCL_POWER_CONF_MAINS_ALARM_HIGH , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_mains_alarm_mask_reserved , {
"Reserved" , "zbee_zcl_general.power_config.attr.mains_alarm_mask.reserved" , FT_UINT8 , BASE_DEC , NULL , ZBEE_ZCL_POWER_CONF_MAINS_ALARM_RESERVED , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_batt_alarm_mask , {
"Battery Alarm Mask" , "zbee_zcl_general.power_config.attr.batt_alarm_mask" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_batt_alarm_mask_low , {
"Battery Voltage too low" , "zbee_zcl_general.power_config.batt_attr.alarm_mask.batt_too_low" , FT_UINT8 , BASE_DEC , NULL , ZBEE_ZCL_POWER_CONF_BATTERY_ALARM_LOW , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_batt_alarm_mask_reserved , {
"Reserved" , "zbee_zcl_general.power_config.attr.batt_alarm_mask.reserved" , FT_UINT8 , BASE_DEC , NULL , ZBEE_ZCL_POWER_CONF_BATTERY_ALARM_RESERVED , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_mains_voltage , {
"Measured Mains Voltage" , "zbee_zcl_general.power_config.attr.mains_voltage" , FT_UINT16 , BASE_CUSTOM , CF_FUNC ( decode_power_conf_voltage ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_mains_frequency , {
"Measured Mains Frequency" , "zbee_zcl_general.power_config.attr.mains_frequency" , FT_UINT8 , BASE_CUSTOM , CF_FUNC ( decode_power_conf_frequency ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_mains_voltage_min_thr , {
"Mains Voltage Minimum Threshold" , "zbee_zcl_general.power_config.attr.mains_volt_min" , FT_UINT16 , BASE_CUSTOM , CF_FUNC ( decode_power_conf_voltage ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_mains_voltage_max_thr , {
"Mains Voltage Maximum Threshold" , "zbee_zcl_general.power_config.attr.mains_volt_max" , FT_UINT16 , BASE_CUSTOM , CF_FUNC ( decode_power_conf_voltage ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_batt_voltage , {
"Measured Battey Voltage" , "zbee_zcl_general.power_config.attr.batt_voltage" , FT_UINT8 , BASE_CUSTOM , CF_FUNC ( decode_power_conf_voltage ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_batt_ah_rating , {
"Battery Capacity" , "zbee_zcl_general.power_config.attr.batt_AHr" , FT_UINT16 , BASE_CUSTOM , CF_FUNC ( decode_power_conf_batt_AHr ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_batt_rated_voltage , {
"Battery Rated Voltage" , "zbee_zcl_general.power_config.attr.batt_rated_voltage" , FT_UINT8 , BASE_CUSTOM , CF_FUNC ( decode_power_conf_voltage ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_batt_voltage_min_thr , {
"Battery Voltage Minimum Threshold" , "zbee_zcl_general.power_config.attr.batt_voltage_min_thr" , FT_UINT8 , BASE_CUSTOM , CF_FUNC ( decode_power_conf_voltage ) , 0x00 , NULL , HFILL }
}
, {
& hf_zbee_zcl_power_config_mains_voltage_dwell_tp , {
"Mains Voltage Dwell Trip Point" , "zbee_zcl_general.power_config.attr.mains_dwell_tp" , FT_UINT16 , BASE_DEC , NULL , 0x00 , NULL , HFILL }
}
, }
;
static gint * ett [ ] = {
& ett_zbee_zcl_power_config , & ett_zbee_zcl_power_config_mains_alarm_mask , & ett_zbee_zcl_power_config_batt_alarm_mask }
;
proto_zbee_zcl_power_config = proto_register_protocol ( "ZigBee ZCL Power Configuration" , "ZCL Power Configuration" , ZBEE_PROTOABBREV_ZCL_POWER_CONFIG ) ;
proto_register_field_array ( proto_zbee_zcl_power_config , hf , array_length ( hf ) ) ;
proto_register_subtree_array ( ett , array_length ( ett ) ) ;
register_dissector ( ZBEE_PROTOABBREV_ZCL_POWER_CONFIG , dissect_zbee_zcl_power_config , proto_zbee_zcl_power_config ) ;
} |
Subsets and Splits