Unnamed: 0
int64 0
3.91k
| source
stringlengths 77
30.3k
| target
stringlengths 41
19k
|
|---|---|---|
0
|
CWE-362 int cipso_v4_sock_getattr ( struct sock * sk , struct netlbl_lsm_secattr * secattr ) { <vul-start> struct ip_options * opt ; opt = inet_sk ( sk ) -> opt ; if ( opt == NULL || opt -> cipso == 0 ) return - ENOMSG ; return cipso_v4_getattr ( opt -> __data + opt -> cipso - sizeof ( struct iphdr ) , <vul-end> secattr ) ; <vul-start> <vul-end> }
|
<vul-sep> { <vul-start> struct ip_options_rcu * opt ; int res = - ENOMSG ; rcu_read_lock ( ) ; opt = rcu_dereference ( inet_sk ( sk ) -> inet_opt ) ; if ( opt && opt -> opt . cipso ) res = cipso_v4_getattr ( opt -> opt . __data + opt -> opt . cipso - sizeof ( struct iphdr ) , <vul-end><vul-sep> secattr ) ; <vul-start> rcu_read_unlock ( ) ; return res ; <vul-end><vul-sep>
|
1
|
CWE-772 int virtio_gpu_object_create ( struct virtio_gpu_device * vgdev , unsigned long size , bool kernel , bool pinned , struct virtio_gpu_object * * bo_ptr ) { struct virtio_gpu_object * bo ; enum ttm_bo_type type ; size_t acc_size ; int ret ; if ( kernel ) type = ttm_bo_type_kernel ; else type = ttm_bo_type_device ; * bo_ptr = NULL ; acc_size = ttm_bo_dma_acc_size ( & vgdev -> mman . bdev , size , sizeof ( struct virtio_gpu_object ) ) ; bo = kzalloc ( sizeof ( struct virtio_gpu_object ) , GFP_KERNEL ) ; if ( bo == NULL ) return - ENOMEM ; size = roundup ( size , PAGE_SIZE ) ; ret = drm_gem_object_init ( vgdev -> ddev , & bo -> gem_base , size ) ; <vul-start> if ( ret != 0 ) <vul-end> return ret ; <vul-start> <vul-end> bo -> dumb = false ; virtio_gpu_init_ttm_placement ( bo , pinned ) ; ret = ttm_bo_init ( & vgdev -> mman . bdev , & bo -> tbo , size , type , & bo -> placement , 0 , ! kernel , NULL , acc_size , NULL , NULL , & virtio_gpu_ttm_bo_destroy ) ; if ( ret != 0 ) return ret ; * bo_ptr = bo ; return 0 ; }
|
<vul-sep> ret = drm_gem_object_init ( vgdev -> ddev , & bo -> gem_base , size ) ; <vul-start> if ( ret != 0 ) { kfree ( bo ) ; <vul-end><vul-sep> return ret ; <vul-start> } <vul-end><vul-sep>
|
2
|
CWE-273 int unquoted_glob_pattern_p ( string ) register char * string ; { register int c ; char * send ; int open , bsquote ; DECLARE_MBSTATE ; open = bsquote = 0 ; send = string + strlen ( string ) ; while ( c = * string ++ ) { switch ( c ) { case '?' : case '*' : return ( 1 ) ; case '[' : open ++ ; continue ; case ']' : if ( open ) return ( 1 ) ; continue ; <vul-start> <vul-end> case '+' : case '@' : case '!' : if ( * string == '(' ) return ( 1 ) ; continue ; case '\\\\' : if ( * string != '\\0' && * string != '/' ) { bsquote = 1 ; <vul-start> <vul-end> string ++ ; continue ; } else if ( * string == 0 ) return ( 0 ) ; case CTLESC : if ( * string ++ == '\\0' ) return ( 0 ) ; } # ifdef HANDLE_MULTIBYTE string -- ; ADVANCE_CHAR_P ( string , send - string ) ; string ++ ; # else ADVANCE_CHAR_P ( string , send - string ) ; # endif } return ( ( bsquote && posix_glob_backslash ) ? 2 : 0 ) ; }
|
<vul-sep> continue ; <vul-start> case '/' : if ( open ) open = 0 ; <vul-end><vul-sep> bsquote = 1 ; <vul-start> string ++ ; continue ; } else if ( open && * string == '/' ) { <vul-end><vul-sep>
|
3
|
CWE-352 static void doGet ( HttpRequest req , HttpResponse res ) { set_content_type ( res , "text/html" ) ; if ( ACTION ( HOME ) ) { LOCK ( Run . mutex ) do_home ( res ) ; END_LOCK ; <vul-start> } else if ( ACTION ( RUN ) ) { handle_run ( req , res ) ; <vul-end> } else if ( ACTION ( TEST ) ) { is_monit_running ( res ) ; <vul-start> } else if ( ACTION ( VIEWLOG ) ) { do_viewlog ( req , res ) ; <vul-end> } else if ( ACTION ( ABOUT ) ) { do_about ( res ) ; } else if ( ACTION ( FAVICON ) ) { printFavicon ( res ) ; } else if ( ACTION ( PING ) ) { do_ping ( res ) ; } else if ( ACTION ( GETID ) ) { do_getid ( res ) ; <vul-start> } else if ( ACTION ( STATUS ) ) { print_status ( req , res , 1 ) ; } else if ( ACTION ( STATUS2 ) ) { print_status ( req , res , 2 ) ; } else if ( ACTION ( SUMMARY ) ) { print_summary ( req , res ) ; } else if ( ACTION ( REPORT ) ) { _printReport ( req , res ) ; } else if ( ACTION ( DOACTION ) ) { handle_do_action ( req , res ) ; <vul-end> } else { <vul-start> handle_action ( req , res ) ; <vul-end> } }
|
<vul-sep> END_LOCK ; <vul-start> } else if ( ACTION ( RUNTIME ) ) { handle_runtime ( req , res ) ; <vul-end><vul-sep> is_monit_running ( res ) ; <vul-start><vul-end><vul-sep> do_getid ( res ) ; <vul-start><vul-end><vul-sep> } else { <vul-start> handle_service ( req , res ) ; <vul-end><vul-sep>
|
4
|
CWE-254 void test_parser ( void ) { <vul-start> int i , retval ; bzrtpPacket_t * zrtpPacket ; bzrtpContext_t * context87654321 = bzrtp_createBzrtpContext ( 0x87654321 ) ; bzrtpContext_t * context12345678 = bzrtp_createBzrtpContext ( 0x12345678 ) ; memcpy ( context12345678 -> channelContext [ 0 ] -> selfH [ 0 ] , H12345678 [ 0 ] , 32 ) ; memcpy ( context12345678 -> channelContext [ 0 ] -> selfH [ 1 ] , H12345678 [ 1 ] , 32 ) ; memcpy ( context12345678 -> channelContext [ 0 ] -> selfH [ 2 ] , H12345678 [ 2 ] , 32 ) ; memcpy ( context12345678 -> channelContext [ 0 ] -> selfH [ 3 ] , H12345678 [ 3 ] , 32 ) ; memcpy ( context87654321 -> channelContext [ 0 ] -> selfH [ 0 ] , H87654321 [ 0 ] , 32 ) ; memcpy ( context87654321 -> channelContext [ 0 ] -> selfH [ 1 ] , H87654321 [ 1 ] , 32 ) ; memcpy ( context87654321 -> channelContext [ 0 ] -> selfH [ 2 ] , H87654321 [ 2 ] , 32 ) ; memcpy ( context87654321 -> channelContext [ 0 ] -> selfH [ 3 ] , H87654321 [ 3 ] , 32 ) ; context87654321 -> channelContext [ 0 ] -> keyAgreementAlgo = ZRTP_KEYAGREEMENT_DH3k ; context12345678 -> channelContext [ 0 ] -> keyAgreementAlgo = ZRTP_KEYAGREEMENT_DH3k ; context87654321 -> channelContext [ 0 ] -> cipherAlgo = ZRTP_CIPHER_AES1 ; context12345678 -> channelContext [ 0 ] -> cipherAlgo = ZRTP_CIPHER_AES1 ; context87654321 -> channelContext [ 0 ] -> hashAlgo = ZRTP_HASH_S256 ; context12345678 -> channelContext [ 0 ] -> hashAlgo = ZRTP_HASH_S256 ; updateCryptoFunctionPointers ( context87654321 -> channelContext [ 0 ] ) ; updateCryptoFunctionPointers ( context12345678 -> channelContext [ 0 ] ) ; context87654321 -> channelContext [ 0 ] -> mackeyi = ( uint8_t * ) malloc ( 32 ) ; context12345678 -> channelContext [ 0 ] -> mackeyi = ( uint8_t * ) malloc ( 32 ) ; context87654321 -> channelContext [ 0 ] -> mackeyr = ( uint8_t * ) malloc ( 32 ) ; context12345678 -> channelContext [ 0 ] -> mackeyr = ( uint8_t * ) malloc ( 32 ) ; context87654321 -> channelContext [ 0 ] -> zrtpkeyi = ( uint8_t * ) malloc ( 16 ) ; context12345678 -> channelContext [ 0 ] -> zrtpkeyi = ( uint8_t * ) malloc ( 16 ) ; context87654321 -> channelContext [ 0 ] -> zrtpkeyr = ( uint8_t * ) malloc ( 16 ) ; context12345678 -> channelContext [ 0 ] -> zrtpkeyr = ( uint8_t * ) malloc ( 16 ) ; memcpy ( context12345678 -> channelContext [ 0 ] -> mackeyi , mackeyi , 32 ) ; memcpy ( context12345678 -> channelContext [ 0 ] -> mackeyr , mackeyr , 32 ) ; memcpy ( context12345678 -> channelContext [ 0 ] -> zrtpkeyi , zrtpkeyi , 16 ) ; memcpy ( context12345678 -> channelContext [ 0 ] -> zrtpkeyr , zrtpkeyr , 16 ) ; memcpy ( context87654321 -> channelContext [ 0 ] -> mackeyi , mackeyi , 32 ) ; memcpy ( context87654321 -> channelContext [ 0 ] -> mackeyr , mackeyr , 32 ) ; memcpy ( context87654321 -> channelContext [ 0 ] -> zrtpkeyi , zrtpkeyi , 16 ) ; memcpy ( context87654321 -> channelContext [ 0 ] -> zrtpkeyr , zrtpkeyr , 16 ) ; context12345678 -> channelContext [ 0 ] -> role = RESPONDER ; for ( i = 0 ; i < TEST_PACKET_NUMBER ; i ++ ) { uint8_t freePacketFlag = 1 ; zrtpPacket = bzrtp_packetCheck ( patternZRTPPackets [ i ] , patternZRTPMetaData [ i ] [ 0 ] , ( patternZRTPMetaData [ i ] [ 1 ] ) - 1 , & retval ) ; retval += bzrtp_packetParser ( ( patternZRTPMetaData [ i ] [ 2 ] == 0x87654321 ) ? context12345678 : context87654321 , ( patternZRTPMetaData [ i ] [ 2 ] == 0x87654321 ) ? context12345678 -> channelContext [ 0 ] : context87654321 -> channelContext [ 0 ] , patternZRTPPackets [ i ] , patternZRTPMetaData [ i ] [ 0 ] , zrtpPacket ) ; if ( zrtpPacket -> messageType == MSGTYPE_HELLO ) { if ( patternZRTPMetaData [ i ] [ 2 ] == 0x87654321 ) { context12345678 -> channelContext [ 0 ] -> peerPackets [ HELLO_MESSAGE_STORE_ID ] = zrtpPacket ; } else { context87654321 -> channelContext [ 0 ] -> peerPackets [ HELLO_MESSAGE_STORE_ID ] = zrtpPacket ; } freePacketFlag = 0 ; } if ( zrtpPacket -> messageType == MSGTYPE_COMMIT ) { if ( patternZRTPMetaData [ i ] [ 2 ] == 0x87654321 ) { context12345678 -> channelContext [ 0 ] -> peerPackets [ COMMIT_MESSAGE_STORE_ID ] = zrtpPacket ; } else { context87654321 -> channelContext [ 0 ] -> peerPackets [ COMMIT_MESSAGE_STORE_ID ] = zrtpPacket ; } freePacketFlag = 0 ; } if ( zrtpPacket -> messageType == MSGTYPE_DHPART1 || zrtpPacket -> messageType == MSGTYPE_DHPART2 ) { if ( patternZRTPMetaData [ i ] [ 2 ] == 0x87654321 ) { context12345678 -> channelContext [ 0 ] -> peerPackets [ DHPART_MESSAGE_STORE_ID ] = zrtpPacket ; } else { context87654321 -> channelContext [ 0 ] -> peerPackets [ DHPART_MESSAGE_STORE_ID ] = zrtpPacket ; } freePacketFlag = 0 ; } free ( zrtpPacket -> packetString ) ; retval = bzrtp_packetBuild ( ( patternZRTPMetaData [ i ] [ 2 ] == 0x12345678 ) ? context12345678 : context87654321 , ( patternZRTPMetaData [ i ] [ 2 ] == 0x12345678 ) ? context12345678 -> channelContext [ 0 ] : context87654321 -> channelContext [ 0 ] , zrtpPacket , patternZRTPMetaData [ i ] [ 1 ] ) ; if ( zrtpPacket -> packetString != NULL ) { CU_ASSERT_TRUE ( memcmp ( zrtpPacket -> packetString , patternZRTPPackets [ i ] , patternZRTPMetaData [ i ] [ 0 ] ) == 0 ) ; } else { CU_FAIL ( "Unable to build packet" ) ; } if ( freePacketFlag == 1 ) { bzrtp_freeZrtpPacket ( zrtpPacket ) ; } } bzrtp_destroyBzrtpContext ( context87654321 , 0x87654321 ) ; bzrtp_destroyBzrtpContext ( context12345678 , 0x12345678 ) ; <vul-end> }
|
<vul-sep> void test_parser ( void ) { <vul-start> test_parser_param ( 0 ) ; <vul-end><vul-sep>
|
5
|
CWE-552 static ssize_t _hostsock_sendto ( oe_fd_t * sock_ , const void * buf , size_t count , int flags , const struct oe_sockaddr * dest_addr , oe_socklen_t addrlen ) { ssize_t ret = - 1 ; sock_t * sock = _cast_sock ( sock_ ) ; oe_errno = 0 ; <vul-start> if ( ! sock || ( count && ! buf ) ) <vul-end> OE_RAISE_ERRNO ( OE_EINVAL ) ; if ( oe_syscall_sendto_ocall ( & ret , sock -> host_fd , buf , count , flags , ( struct oe_sockaddr * ) dest_addr , addrlen ) != OE_OK ) { OE_RAISE_ERRNO ( OE_EINVAL ) ; } <vul-start> <vul-end> done : return ret ; }
|
<vul-sep> oe_errno = 0 ; <vul-start> if ( ! sock || ( count && ! buf ) || count > OE_SSIZE_MAX ) <vul-end><vul-sep> } <vul-start> if ( ret > ( ssize_t ) count ) { ret = - 1 ; OE_RAISE_ERRNO ( OE_EINVAL ) ; } <vul-end><vul-sep>
|
6
|
NVD-CWE-Other # ifndef DEBUG freopen ( "/tmp/uu-server.log" , "w" , stderr ) ; # endif retval = krb5_init_context ( & context ) ; if ( retval ) { com_err ( argv [ 0 ] , retval , "while initializing krb5" ) ; exit ( 1 ) ; } # ifdef DEBUG { int one = 1 ; int acc ; struct servent * sp ; socklen_t namelen = sizeof ( f_inaddr ) ; if ( ( sock = socket ( PF_INET , SOCK_STREAM , 0 ) ) < 0 ) { com_err ( "uu-server" , errno , "creating socket" ) ; exit ( 3 ) ; } l_inaddr . sin_family = AF_INET ; l_inaddr . sin_addr . s_addr = 0 ; if ( argc == 2 ) { l_inaddr . sin_port = htons ( atoi ( argv [ 1 ] ) ) ; } else { if ( ! ( sp = getservbyname ( "uu-sample" , "tcp" ) ) ) { com_err ( "uu-server" , 0 , "can\'t find uu-sample/tcp service" ) ; exit ( 3 ) ; } l_inaddr . sin_port = sp -> s_port ; } ( void ) setsockopt ( sock , SOL_SOCKET , SO_REUSEADDR , ( char * ) & one , sizeof ( one ) ) ; if ( bind ( sock , ( struct sockaddr * ) & l_inaddr , sizeof ( l_inaddr ) ) ) { com_err ( "uu-server" , errno , "binding socket" ) ; exit ( 3 ) ; } if ( listen ( sock , 1 ) == - 1 ) { com_err ( "uu-server" , errno , "listening" ) ; exit ( 3 ) ; } printf ( "Server started\\n" ) ; fflush ( stdout ) ; if ( ( acc = accept ( sock , ( struct sockaddr * ) & f_inaddr , & namelen ) ) == - 1 ) { com_err ( "uu-server" , errno , "accepting" ) ; exit ( 3 ) ; } dup2 ( acc , 0 ) ; close ( sock ) ; sock = 0 ; } # endif retval = krb5_read_message ( context , ( krb5_pointer ) & sock , & pname_data ) ; <vul-start> if ( retval ) { <vul-end> com_err ( "uu-server" , retval , "reading pname" ) ; return 2 ; } retval = krb5_read_message ( context , ( krb5_pointer ) & sock , & tkt_data ) ; if ( retval ) { com_err ( "uu-server" , retval , "reading ticket data" ) ; return 2 ; } retval = krb5_cc_default ( context , & cc ) ; if ( retval ) { com_err ( "uu-server" , retval , "getting credentials cache" ) ; return 4 ; } memset ( & creds , 0 , sizeof ( creds ) ) ; retval = krb5_cc_get_principal ( context , cc , & creds . client ) ; if ( retval ) { com_err ( "uu-client" , retval , "getting principal name" ) ; return 6 ; } printf ( "uu-server: client principal is \\"%s\\".\\n" , pname_data . data ) ; retval = krb5_parse_name ( context , pname_data . data , & creds . server ) ; if ( retval ) { com_err ( "uu-server" , retval , "parsing client name" ) ; return 3 ; } creds . second_ticket = tkt_data ; printf ( "uu-server: client ticket is %d bytes.\\n" , creds . second_ticket . length ) ; retval = krb5_get_credentials ( context , KRB5_GC_USER_USER , cc , & creds , & new_creds ) ; if ( retval ) { com_err ( "uu-server" , retval , "getting user-user ticket" ) ; return 5 ; } # ifndef DEBUG l = sizeof ( f_inaddr ) ; if ( getpeername ( 0 , ( struct sockaddr * ) & f_inaddr , & l ) == - 1 ) { com_err ( "uu-server" , errno , "getting client address" ) ; return 6 ; } # endif l = sizeof ( l_inaddr ) ; if ( getsockname ( 0 , ( struct sockaddr * ) & l_inaddr , & l ) == - 1 ) { com_err ( "uu-server" , errno , "getting local address" ) ; return 6 ; } retval = krb5_auth_con_init ( context , & auth_context ) ; if ( retval ) {
|
<vul-sep> retval = krb5_read_message ( context , ( krb5_pointer ) & sock , & pname_data ) ; <vul-start> if ( retval || pname_data . length == 0 || pname_data . data [ pname_data . length - 1 ] != '\\0' ) { <vul-end><vul-sep>
|
7
|
CWE-125 static UINT parallel_process_irp_create ( PARALLEL_DEVICE * parallel , IRP * irp ) { char * path = NULL ; int status ; <vul-start> <vul-end> UINT32 PathLength ; <vul-start> Stream_Seek ( irp -> input , 28 ) ; <vul-end> Stream_Read_UINT32 ( irp -> input , PathLength ) ; <vul-start> status = ConvertFromUnicode ( CP_UTF8 , 0 , ( WCHAR * ) Stream_Pointer ( irp -> input ) , PathLength / 2 , & path , 0 , NULL , NULL ) ; <vul-end> if ( status < 1 ) if ( ! ( path = ( char * ) calloc ( 1 , 1 ) ) ) { WLog_ERR ( TAG , "calloc failed!" ) ; return CHANNEL_RC_NO_MEMORY ; } parallel -> id = irp -> devman -> id_sequence ++ ; parallel -> file = open ( parallel -> path , O_RDWR ) ; if ( parallel -> file < 0 ) { irp -> IoStatus = STATUS_ACCESS_DENIED ; parallel -> id = 0 ; } else { if ( fcntl ( parallel -> file , F_SETFL , O_NONBLOCK ) == - 1 ) { } } Stream_Write_UINT32 ( irp -> output , parallel -> id ) ; Stream_Write_UINT8 ( irp -> output , 0 ) ; free ( path ) ; return irp -> Complete ( irp ) ; }
|
<vul-sep> int status ; <vul-start> WCHAR * ptr ; <vul-end><vul-sep> UINT32 PathLength ; <vul-start> if ( ! Stream_SafeSeek ( irp -> input , 28 ) ) return ERROR_INVALID_DATA ; if ( Stream_GetRemainingLength ( irp -> input ) < 4 ) return ERROR_INVALID_DATA ; <vul-end><vul-sep> Stream_Read_UINT32 ( irp -> input , PathLength ) ; <vul-start> ptr = ( WCHAR * ) Stream_Pointer ( irp -> input ) ; if ( ! Stream_SafeSeek ( irp -> input , PathLength ) ) return ERROR_INVALID_DATA ; status = ConvertFromUnicode ( CP_UTF8 , 0 , ptr , PathLength / 2 , & path , 0 , NULL , NULL ) ; <vul-end><vul-sep>
|
8
|
CWE-284 { case VFF_MAPTYP_2_BYTE : value = 1.0 * ( ( short * ) viff_colormap ) [ i ] ; break ; case VFF_MAPTYP_4_BYTE : value = 1.0 * ( ( int * ) viff_colormap ) [ i ] ; break ; case VFF_MAPTYP_FLOAT : value = ( ( float * ) viff_colormap ) [ i ] ; break ; case VFF_MAPTYP_DOUBLE : value = ( ( double * ) viff_colormap ) [ i ] ; break ; default : value = 1.0 * viff_colormap [ i ] ; break ; } if ( i < ( ssize_t ) image -> colors ) { image -> colormap [ i ] . red = ScaleCharToQuantum ( ( unsigned char ) value ) ; image -> colormap [ i ] . green = ScaleCharToQuantum ( ( unsigned char ) value ) ; image -> colormap [ i ] . blue = ScaleCharToQuantum ( ( unsigned char ) value ) ; } else if ( i < ( ssize_t ) ( 2 * image -> colors ) ) image -> colormap [ i % image -> colors ] . green = ScaleCharToQuantum ( ( unsigned char ) value ) ; else if ( i < ( ssize_t ) ( 3 * image -> colors ) ) image -> colormap [ i % image -> colors ] . blue = ScaleCharToQuantum ( ( unsigned char ) value ) ; } viff_colormap = ( unsigned char * ) RelinquishMagickMemory ( viff_colormap ) ; break ; } default : ThrowReaderException ( CoderError , "ColormapTypeNotSupported" ) ; } image -> alpha_trait = viff_info . number_data_bands == 4 ? BlendPixelTrait : UndefinedPixelTrait ; image -> storage_class = ( viff_info . number_data_bands < 3 ? PseudoClass : DirectClass ) ; image -> columns = viff_info . rows ; image -> rows = viff_info . columns ; if ( ( image_info -> ping != MagickFalse ) && ( image_info -> number_scenes != 0 ) ) if ( image -> scene >= ( image_info -> scene + image_info -> number_scenes - 1 ) ) break ; status = SetImageExtent ( image , image -> columns , image -> rows , exception ) ; if ( status == MagickFalse ) return ( DestroyImageList ( image ) ) ; switch ( ( int ) viff_info . data_storage_type ) { case VFF_TYP_2_BYTE : bytes_per_pixel = 2 ; break ; case VFF_TYP_4_BYTE : bytes_per_pixel = 4 ; break ; case VFF_TYP_FLOAT : bytes_per_pixel = 4 ; break ; case VFF_TYP_DOUBLE : bytes_per_pixel = 8 ; break ; default : bytes_per_pixel = 1 ; break ; } if ( viff_info . data_storage_type == VFF_TYP_BIT ) <vul-start> <vul-end> max_packets = ( ( image -> columns + 7UL ) >> 3UL ) * image -> rows ; <vul-start> else <vul-end> max_packets = ( size_t ) ( number_pixels * viff_info . number_data_bands ) ; <vul-start> <vul-end> pixels = ( unsigned char * ) AcquireQuantumMemory ( MagickMax ( number_pixels , max_packets ) , bytes_per_pixel * sizeof ( * pixels ) ) ; if ( pixels == ( unsigned char * ) NULL ) ThrowReaderException ( ResourceLimitError , "MemoryAllocationFailed" ) ; count = ReadBlob ( image , bytes_per_pixel * max_packets , pixels ) ; lsb_first = 1 ; if ( * ( char * ) & lsb_first && ( ( viff_info . machine_dependency != VFF_DEP_DECORDER ) && ( viff_info . machine_dependency != VFF_DEP_NSORDER ) ) ) switch ( ( int ) viff_info . data_storage_type ) { case VFF_TYP_2_BYTE : { MSBOrderShort ( pixels , bytes_per_pixel * max_packets ) ; break ; } case VFF_TYP_4_BYTE : case VFF_TYP_FLOAT : { MSBOrderLong ( pixels , bytes_per_pixel * max_packets ) ; break ; } default : break ; } min_value = 0.0 ; scale_factor = 1.0 ; if ( ( viff_info . data_storage_type != VFF_TYP_1_BYTE ) && ( viff_info . map_scheme == VFF_MS_NONE ) ) { double max_value ; switch ( ( int ) viff_info . data_storage_type ) { case VFF_TYP_2_BYTE : value = 1.0 * ( ( short * ) pixels ) [ 0 ] ; break ; case VFF_TYP_4_BYTE : value = 1.0 * ( ( int * ) pixels ) [ 0 ] ; break ; case VFF_TYP_FLOAT : value = ( ( float * ) pixels ) [ 0 ] ; break ; case VFF_TYP_DOUBLE : value = ( ( double * ) pixels ) [ 0 ] ; break ; default : value = 1.0 * pixels [ 0 ] ; break ; } max_value = value ; min_value = value ; for ( i = 0 ; i < ( ssize_t ) max_packets ; i ++ ) { switch ( ( int ) viff_info . data_storage_type ) { case VFF_TYP_2_BYTE : value = 1.0 * ( ( short * ) pixels ) [ i ] ; break ; case VFF_TYP_4_BYTE : value = 1.0 * ( ( int * ) pixels ) [ i ] ; break ; case VFF_TYP_FLOAT : value = ( ( float * ) pixels ) [ i ] ; break ; case VFF_TYP_DOUBLE : value = ( ( double * ) pixels ) [ i ] ; break ; default : value = 1.0 * pixels [ i ] ; break ;
|
<vul-sep> if ( viff_info . data_storage_type == VFF_TYP_BIT ) <vul-start> { if ( CheckMemoryOverflow ( ( image -> columns + 7UL ) >> 3UL , image -> rows ) != MagickFalse ) ThrowReaderException ( ResourceLimitError , "MemoryAllocationFailed" ) ; <vul-end><vul-sep> max_packets = ( ( image -> columns + 7UL ) >> 3UL ) * image -> rows ; <vul-start> } else { if ( CheckMemoryOverflow ( number_pixels , viff_info . number_data_bands ) != MagickFalse ) ThrowReaderException ( ResourceLimitError , "MemoryAllocationFailed" ) ; <vul-end><vul-sep> max_packets = ( size_t ) ( number_pixels * viff_info . number_data_bands ) ; <vul-start> } <vul-end><vul-sep>
|
9
|
CWE-476 unsigned int dfl ; unsigned int port_no ; bool filtered ; int ret = 1 ; spin_lock_irqsave ( & i8042_lock , flags ) ; str = i8042_read_status ( ) ; if ( unlikely ( ~ str & I8042_STR_OBF ) ) { spin_unlock_irqrestore ( & i8042_lock , flags ) ; if ( irq ) dbg ( "Interrupt %d, without any data\\n" , irq ) ; ret = 0 ; goto out ; } data = i8042_read_data ( ) ; if ( i8042_mux_present && ( str & I8042_STR_AUXDATA ) ) { static unsigned long last_transmit ; static unsigned char last_str ; dfl = 0 ; if ( str & I8042_STR_MUXERR ) { dbg ( "MUX error, status is %02x, data is %02x\\n" , str , data ) ; switch ( data ) { default : if ( time_before ( jiffies , last_transmit + HZ / 10 ) ) { str = last_str ; break ; } case 0xfc : case 0xfd : case 0xfe : dfl = SERIO_TIMEOUT ; data = 0xfe ; break ; case 0xff : dfl = SERIO_PARITY ; data = 0xfe ; break ; } } port_no = I8042_MUX_PORT_NO + ( ( str >> 6 ) & 3 ) ; last_str = str ; last_transmit = jiffies ; } else { dfl = ( ( str & I8042_STR_PARITY ) ? SERIO_PARITY : 0 ) | ( ( str & I8042_STR_TIMEOUT && ! i8042_notimeout ) ? SERIO_TIMEOUT : 0 ) ; port_no = ( str & I8042_STR_AUXDATA ) ? I8042_AUX_PORT_NO : I8042_KBD_PORT_NO ; } port = & i8042_ports [ port_no ] ; serio = port -> exists ? port -> serio : NULL ; filter_dbg ( port -> driver_bound , data , "<- i8042 (interrupt, %d, %d%s%s)\\n" , port_no , irq , dfl & SERIO_PARITY ? ", bad parity" : "" , dfl & SERIO_TIMEOUT ? ", timeout" : "" ) ; filtered = i8042_filter ( data , str , serio ) ; spin_unlock_irqrestore ( & i8042_lock , flags ) ; <vul-start> if ( likely ( port -> exists && ! filtered ) ) <vul-end> serio_interrupt ( serio , data , dfl ) ; out : return IRQ_RETVAL ( ret ) ; }
|
<vul-sep> spin_unlock_irqrestore ( & i8042_lock , flags ) ; <vul-start> if ( likely ( serio && ! filtered ) ) <vul-end><vul-sep>
|
10
|
CWE-399 static int hugetlbfs_statfs ( struct dentry * dentry , struct kstatfs * buf ) { struct hugetlbfs_sb_info * sbinfo = HUGETLBFS_SB ( dentry -> d_sb ) ; struct hstate * h = hstate_inode ( dentry -> d_inode ) ; buf -> f_type = HUGETLBFS_MAGIC ; buf -> f_bsize = huge_page_size ( h ) ; if ( sbinfo ) { spin_lock ( & sbinfo -> stat_lock ) ; <vul-start> if ( sbinfo -> max_blocks >= 0 ) { buf -> f_blocks = sbinfo -> max_blocks ; buf -> f_bavail = buf -> f_bfree = sbinfo -> free_blocks ; <vul-end> buf -> f_files = sbinfo -> max_inodes ; buf -> f_ffree = sbinfo -> free_inodes ; } spin_unlock ( & sbinfo -> stat_lock ) ; } buf -> f_namelen = NAME_MAX ; return 0 ; }
|
<vul-sep> spin_lock ( & sbinfo -> stat_lock ) ; <vul-start> if ( sbinfo -> spool ) { long free_pages ; spin_lock ( & sbinfo -> spool -> lock ) ; buf -> f_blocks = sbinfo -> spool -> max_hpages ; free_pages = sbinfo -> spool -> max_hpages - sbinfo -> spool -> used_hpages ; buf -> f_bavail = buf -> f_bfree = free_pages ; spin_unlock ( & sbinfo -> spool -> lock ) ; <vul-end><vul-sep>
|
11
|
CWE-200 unsigned paravirt_patch_call ( void * insnbuf , const void * target , u16 tgt_clobbers , unsigned long addr , u16 site_clobbers , unsigned len ) { struct branch * b = insnbuf ; unsigned long delta = ( unsigned long ) target - ( addr + 5 ) ; <vul-start> if ( tgt_clobbers & ~ site_clobbers ) <vul-end> return len ; <vul-start> if ( len < 5 ) return len ; <vul-end> b -> opcode = 0xe8 ; b -> delta = delta ; BUILD_BUG_ON ( sizeof ( * b ) != 5 ) ; return 5 ; }
|
<vul-sep> unsigned long delta = ( unsigned long ) target - ( addr + 5 ) ; <vul-start> if ( len < 5 ) { # ifdef CONFIG_RETPOLINE WARN_ONCE ( "Failing to patch indirect CALL in %ps\\n" , ( void * ) addr ) ; # endif <vul-end><vul-sep> return len ; <vul-start> } <vul-end><vul-sep>
|
12
|
CWE-20 for ( i = 0 ; i < ( ssize_t ) stream_info -> offset_count ; i ++ ) stream_info -> offsets [ i ] += offset ; } read_info = CloneImageInfo ( image_info ) ; SetImageInfoBlob ( read_info , ( void * ) NULL , 0 ) ; images = NewImageList ( ) ; for ( scene = 0 ; scene < ( ssize_t ) number_scenes ; scene ++ ) { char filename [ MagickPathExtent ] ; const char * property ; FILE * file ; Image * jpeg_image ; int unique_file ; unsigned int tag ; tag = ( ( unsigned int ) ReadBlobLSBShort ( image ) << 16 ) | ReadBlobLSBShort ( image ) ; length = ( size_t ) ReadBlobLSBLong ( image ) ; if ( tag == 0xFFFEE0DD ) break ; if ( tag != 0xFFFEE000 ) { read_info = DestroyImageInfo ( read_info ) ; ThrowDCMException ( CorruptImageError , "ImproperImageHeader" ) ; } file = ( FILE * ) NULL ; unique_file = AcquireUniqueFileResource ( filename ) ; if ( unique_file != - 1 ) file = fdopen ( unique_file , "wb" ) ; if ( file == ( FILE * ) NULL ) { ( void ) RelinquishUniqueFileResource ( filename ) ; ThrowFileException ( exception , FileOpenError , "UnableToCreateTemporaryFile" , filename ) ; break ; } for ( c = EOF ; length != 0 ; length -- ) { c = ReadBlobByte ( image ) ; if ( c == EOF ) { ThrowFileException ( exception , CorruptImageError , "UnexpectedEndOfFile" , image -> filename ) ; break ; } <vul-start> ( void ) fputc ( c , file ) ; <vul-end> } ( void ) fclose ( file ) ; if ( c == EOF ) break ; ( void ) FormatLocaleString ( read_info -> filename , MagickPathExtent , "jpeg:%s" , filename ) ; if ( image -> compression == JPEG2000Compression ) ( void ) FormatLocaleString ( read_info -> filename , MagickPathExtent , "j2k:%s" , filename ) ; jpeg_image = ReadImage ( read_info , exception ) ; if ( jpeg_image != ( Image * ) NULL ) { ResetImagePropertyIterator ( image ) ; property = GetNextImageProperty ( image ) ; while ( property != ( const char * ) NULL ) { ( void ) SetImageProperty ( jpeg_image , property , GetImageProperty ( image , property , exception ) , exception ) ; property = GetNextImageProperty ( image ) ; } AppendImageToList ( & images , jpeg_image ) ; } ( void ) RelinquishUniqueFileResource ( filename ) ; } read_info = DestroyImageInfo ( read_info ) ; if ( stream_info -> offsets != ( ssize_t * ) NULL ) stream_info -> offsets = ( ssize_t * ) RelinquishMagickMemory ( stream_info -> offsets ) ; stream_info = ( DCMStreamInfo * ) RelinquishMagickMemory ( stream_info ) ; if ( info . scale != ( Quantum * ) NULL ) info . scale = ( Quantum * ) RelinquishMagickMemory ( info . scale ) ; if ( graymap != ( int * ) NULL ) graymap = ( int * ) RelinquishMagickMemory ( graymap ) ; if ( bluemap != ( int * ) NULL ) bluemap = ( int * ) RelinquishMagickMemory ( bluemap ) ; if ( greenmap != ( int * ) NULL ) greenmap = ( int * ) RelinquishMagickMemory ( greenmap ) ; if ( redmap != ( int * ) NULL ) redmap = ( int * ) RelinquishMagickMemory ( redmap ) ; image = DestroyImageList ( image ) ; return ( GetFirstImageInList ( images ) ) ; } if ( info . depth != ( 1UL * MAGICKCORE_QUANTUM_DEPTH ) ) { QuantumAny range ; length = ( size_t ) ( GetQuantumRange ( info . depth ) + 1 ) ; if ( length > ( size_t ) GetBlobSize ( image ) ) ThrowDCMException ( CorruptImageError , "InsufficientImageDataInFile" ) ; if ( info . scale != ( Quantum * ) NULL )
|
<vul-sep> } <vul-start> if ( fputc ( c , file ) != c ) break ; <vul-end><vul-sep>
|
13
|
CWE-119 static void y4m_convert_null ( y4m_input * _y4m , unsigned char * _dst , unsigned char * _aux ) { <vul-start> <vul-end> }
|
<vul-sep> unsigned char * _aux ) { <vul-start> ( void ) _y4m ; ( void ) _dst ; ( void ) _aux ; <vul-end><vul-sep>
|
14
|
CWE-400 cursor -> hashval ) { context -> dupcnt = 0 ; break ; } } if ( i == ichdr . count ) { trace_xfs_attr_list_notfound ( context ) ; return 0 ; } } else { entry = & entries [ 0 ] ; i = 0 ; } context -> resynch = 0 ; retval = 0 ; for ( ; i < ichdr . count ; entry ++ , i ++ ) { if ( be32_to_cpu ( entry -> hashval ) != cursor -> hashval ) { cursor -> hashval = be32_to_cpu ( entry -> hashval ) ; cursor -> offset = 0 ; } if ( entry -> flags & XFS_ATTR_INCOMPLETE ) continue ; if ( entry -> flags & XFS_ATTR_LOCAL ) { xfs_attr_leaf_name_local_t * name_loc = xfs_attr3_leaf_name_local ( leaf , i ) ; retval = context -> put_listent ( context , entry -> flags , name_loc -> nameval , ( int ) name_loc -> namelen , be16_to_cpu ( name_loc -> valuelen ) , & name_loc -> nameval [ name_loc -> namelen ] ) ; if ( retval ) return retval ; } else { xfs_attr_leaf_name_remote_t * name_rmt = xfs_attr3_leaf_name_remote ( leaf , i ) ; int valuelen = be32_to_cpu ( name_rmt -> valuelen ) ; if ( context -> put_value ) { xfs_da_args_t args ; memset ( ( char * ) & args , 0 , sizeof ( args ) ) ; args . geo = context -> dp -> i_mount -> m_attr_geo ; args . dp = context -> dp ; args . whichfork = XFS_ATTR_FORK ; args . valuelen = valuelen ; args . rmtvaluelen = valuelen ; args . value = kmem_alloc ( valuelen , KM_SLEEP | KM_NOFS ) ; args . rmtblkno = be32_to_cpu ( name_rmt -> valueblk ) ; args . rmtblkcnt = xfs_attr3_rmt_blocks ( args . dp -> i_mount , valuelen ) ; retval = xfs_attr_rmtval_get ( & args ) ; <vul-start> if ( retval ) return retval ; <vul-end> retval = context -> put_listent ( context , entry -> flags , name_rmt -> name , ( int ) name_rmt -> namelen , valuelen , args . value ) ; kmem_free ( args . value ) ; } else { retval = context -> put_listent ( context , entry -> flags , name_rmt -> name , ( int ) name_rmt -> namelen , valuelen , NULL ) ; } if ( retval ) return retval ; } if ( context -> seen_enough ) break ; cursor -> offset ++ ; } trace_xfs_attr_list_leaf_end ( context ) ; return retval ; }
|
<vul-sep> retval = xfs_attr_rmtval_get ( & args ) ; <vul-start> if ( ! retval ) <vul-end><vul-sep>
|
15
|
CWE-190 static void controloptions ( lua_State * L , int opt , const char * * fmt , Header * h ) { switch ( opt ) { case ' ' : return ; case '>' : h -> endian = BIG ; return ; case '<' : h -> endian = LITTLE ; return ; case '!' : { <vul-start> int a = getnum ( L , fmt , MAXALIGN ) ; <vul-end> if ( ! isp2 ( a ) ) luaL_error ( L , "alignment %d is not a power of 2" , a ) ; h -> align = a ; return ; } default : { const char * msg = lua_pushfstring ( L , "invalid format option \'%c\'" , opt ) ; luaL_argerror ( L , 1 , msg ) ; } } }
|
<vul-sep> case '!' : { <vul-start> int a = getnum ( fmt , MAXALIGN ) ; <vul-end><vul-sep>
|
16
|
CWE-119 break ; case R_BIN_WASM_VALUETYPE_f32 : snprintf ( op -> txt , R_ASM_BUFSIZE , "%s (result f32)" , opdef -> txt ) ; break ; case R_BIN_WASM_VALUETYPE_f64 : snprintf ( op -> txt , R_ASM_BUFSIZE , "%s (result f64)" , opdef -> txt ) ; break ; default : snprintf ( op -> txt , R_ASM_BUFSIZE , "%s (result ?)" , opdef -> txt ) ; break ; } op -> len += n ; } break ; case WASM_OP_BR : case WASM_OP_BRIF : case WASM_OP_CALL : { ut32 val = 0 ; size_t n = read_u32_leb128 ( buf + 1 , buf + buf_len , & val ) ; if ( ! ( n > 0 && n < buf_len ) ) goto err ; snprintf ( op -> txt , R_ASM_BUFSIZE , "%s %d" , opdef -> txt , val ) ; op -> len += n ; } break ; case WASM_OP_BRTABLE : { ut32 count = 0 , * table = NULL , def = 0 ; size_t n = read_u32_leb128 ( buf + 1 , buf + buf_len , & count ) ; if ( ! ( n > 0 && n < buf_len ) ) { goto err ; } if ( ! ( table = calloc ( count , sizeof ( ut32 ) ) ) ) { goto err ; } int i = 0 ; op -> len += n ; for ( i = 0 ; i < count ; i ++ ) { n = read_u32_leb128 ( buf + op -> len , buf + buf_len , & table [ i ] ) ; if ( ! ( op -> len + n <= buf_len ) ) { goto beach ; } op -> len += n ; } n = read_u32_leb128 ( buf + op -> len , buf + buf_len , & def ) ; if ( ! ( n > 0 && n + op -> len < buf_len ) ) { goto beach ; } op -> len += n ; snprintf ( op -> txt , R_ASM_BUFSIZE , "%s %d " , opdef -> txt , count ) ; <vul-start> for ( i = 0 ; i < count && strlen ( op -> txt ) + 10 < R_ASM_BUFSIZE ; i ++ ) { int optxtlen = strlen ( op -> txt ) ; snprintf ( op -> txt + optxtlen , R_ASM_BUFSIZE - optxtlen , "%d " , table [ i ] ) ; } snprintf ( op -> txt + strlen ( op -> txt ) , R_ASM_BUFSIZE , "%d" , def ) ; <vul-end> free ( table ) ; break ; beach : free ( table ) ; goto err ; } break ; case WASM_OP_CALLINDIRECT : { ut32 val = 0 , reserved = 0 ; size_t n = read_u32_leb128 ( buf + 1 , buf + buf_len , & val ) ; if ( ! ( n > 0 && n < buf_len ) ) goto err ; op -> len += n ; n = read_u32_leb128 ( buf + op -> len , buf + buf_len , & reserved ) ; if ( ! ( n == 1 && op -> len + n <= buf_len ) ) goto err ; reserved &= 0x1 ; snprintf ( op -> txt , R_ASM_BUFSIZE , "%s %d %d" , opdef -> txt , val , reserved ) ; op -> len += n ; } break ; case WASM_OP_GETLOCAL : case WASM_OP_SETLOCAL : case WASM_OP_TEELOCAL : case WASM_OP_GETGLOBAL : case WASM_OP_SETGLOBAL : { ut32 val = 0 ; size_t n = read_u32_leb128 ( buf + 1 , buf + buf_len , & val ) ; if ( ! ( n > 0 && n < buf_len ) ) goto err ; snprintf ( op -> txt , R_ASM_BUFSIZE , "%s %d" , opdef -> txt , val ) ; op -> len += n ; } break ; case WASM_OP_I32LOAD : case WASM_OP_I64LOAD : case WASM_OP_F32LOAD : case WASM_OP_F64LOAD : case WASM_OP_I32LOAD8S : case WASM_OP_I32LOAD8U : case WASM_OP_I32LOAD16S : case WASM_OP_I32LOAD16U : case WASM_OP_I64LOAD8S : case WASM_OP_I64LOAD8U : case WASM_OP_I64LOAD16S : case WASM_OP_I64LOAD16U : case WASM_OP_I64LOAD32S : case WASM_OP_I64LOAD32U : case WASM_OP_I32STORE : case WASM_OP_I64STORE : case WASM_OP_F32STORE :
|
<vul-sep> snprintf ( op -> txt , R_ASM_BUFSIZE , "%s %d " , opdef -> txt , count ) ; <vul-start> char * txt = op -> txt ; int txtLen = strlen ( op -> txt ) ; int txtLeft = R_ASM_BUFSIZE - txtLen ; txt += txtLen ; for ( i = 0 ; i < count && txtLen + 10 < R_ASM_BUFSIZE ; i ++ ) { snprintf ( txt , txtLeft , "%d " , table [ i ] ) ; txtLen = strlen ( txt ) ; txt += txtLen ; txtLeft -= txtLen ; } snprintf ( txt , txtLeft - 1 , "%d" , def ) ; <vul-end><vul-sep>
|
17
|
CWE-476 void dump_isom_sdp ( GF_ISOFile * file , char * inName , Bool is_final_name ) { const char * sdp ; u32 size , i ; FILE * dump ; if ( inName ) { char szBuf [ 1024 ] ; strcpy ( szBuf , inName ) ; if ( ! is_final_name ) { char * ext = strchr ( szBuf , '.' ) ; if ( ext ) ext [ 0 ] = 0 ; strcat ( szBuf , "_sdp.txt" ) ; } dump = gf_fopen ( szBuf , "wt" ) ; if ( ! dump ) { fprintf ( stderr , "Failed to open %s for dumping\\n" , szBuf ) ; return ; } } else { dump = stdout ; fprintf ( dump , "* File SDP content *\\n\\n" ) ; } gf_isom_sdp_get ( file , & sdp , & size ) ; <vul-start> <vul-end> fprintf ( dump , "%s" , sdp ) ; fprintf ( dump , "\\r\\n" ) ; for ( i = 0 ; i < gf_isom_get_track_count ( file ) ; i ++ ) { if ( gf_isom_get_media_type ( file , i + 1 ) != GF_ISOM_MEDIA_HINT ) continue ; gf_isom_sdp_track_get ( file , i + 1 , & sdp , & size ) ; fprintf ( dump , "%s" , sdp ) ; } fprintf ( dump , "\\n\\n" ) ; if ( inName ) gf_fclose ( dump ) ; }
|
<vul-sep> gf_isom_sdp_get ( file , & sdp , & size ) ; <vul-start> if ( sdp && size ) <vul-end><vul-sep>
|
18
|
CWE-119 if ( i < 0 ) return ( i ) ; if ( i == 0 ) { SSLerr ( SSL_F_DTLS1_READ_BYTES , SSL_R_SSL_HANDSHAKE_FAILURE ) ; return ( - 1 ) ; } } start : s -> rwstate = SSL_NOTHING ; rr = & ( s -> s3 -> rrec ) ; if ( s -> state == SSL_ST_OK && rr -> length == 0 ) { pitem * item ; item = pqueue_pop ( s -> d1 -> buffered_app_data . q ) ; if ( item ) { # ifndef OPENSSL_NO_SCTP if ( BIO_dgram_is_sctp ( SSL_get_rbio ( s ) ) ) { DTLS1_RECORD_DATA * rdata = ( DTLS1_RECORD_DATA * ) item -> data ; BIO_ctrl ( SSL_get_rbio ( s ) , BIO_CTRL_DGRAM_SCTP_SET_RCVINFO , sizeof ( rdata -> recordinfo ) , & rdata -> recordinfo ) ; } # endif dtls1_copy_record ( s , item ) ; OPENSSL_free ( item -> data ) ; pitem_free ( item ) ; } } if ( dtls1_handle_timeout ( s ) > 0 ) goto start ; if ( ( rr -> length == 0 ) || ( s -> rstate == SSL_ST_READ_BODY ) ) { ret = dtls1_get_record ( s ) ; if ( ret <= 0 ) { ret = dtls1_read_failed ( s , ret ) ; if ( ret <= 0 ) return ( ret ) ; else goto start ; } } if ( s -> d1 -> listen && rr -> type != SSL3_RT_HANDSHAKE ) { rr -> length = 0 ; goto start ; } if ( s -> s3 -> change_cipher_spec && ( rr -> type != SSL3_RT_HANDSHAKE ) ) { <vul-start> dtls1_buffer_record ( s , & ( s -> d1 -> buffered_app_data ) , rr -> seq_num ) ; <vul-end> rr -> length = 0 ; goto start ; } if ( s -> shutdown & SSL_RECEIVED_SHUTDOWN ) { rr -> length = 0 ; s -> rwstate = SSL_NOTHING ; return ( 0 ) ; } if ( type == rr -> type ) { if ( SSL_in_init ( s ) && ( type == SSL3_RT_APPLICATION_DATA ) && ( s -> enc_read_ctx == NULL ) ) { al = SSL_AD_UNEXPECTED_MESSAGE ; SSLerr ( SSL_F_DTLS1_READ_BYTES , SSL_R_APP_DATA_IN_HANDSHAKE ) ; goto f_err ; } if ( len <= 0 ) return ( len ) ; if ( ( unsigned int ) len > rr -> length ) n = rr -> length ; else n = ( unsigned int ) len ; memcpy ( buf , & ( rr -> data [ rr -> off ] ) , n ) ; if ( ! peek ) { rr -> length -= n ; rr -> off += n ; if ( rr -> length == 0 ) { s -> rstate = SSL_ST_READ_HEADER ; rr -> off = 0 ; } } # ifndef OPENSSL_NO_SCTP if ( BIO_dgram_is_sctp ( SSL_get_rbio ( s ) ) && rr -> type == SSL3_RT_APPLICATION_DATA && ( s -> state == DTLS1_SCTP_ST_SR_READ_SOCK || s -> state == DTLS1_SCTP_ST_CR_READ_SOCK ) ) { s -> rwstate = SSL_READING ; BIO_clear_retry_flags ( SSL_get_rbio ( s ) ) ; BIO_set_retry_read ( SSL_get_rbio ( s ) ) ; } if ( BIO_dgram_is_sctp ( SSL_get_rbio ( s ) ) && s -> d1 -> shutdown_received && ! BIO_dgram_sctp_msg_waiting ( SSL_get_rbio ( s ) ) ) { s -> shutdown |= SSL_RECEIVED_SHUTDOWN ; return ( 0 ) ; } # endif
|
<vul-sep> { <vul-start> if ( dtls1_buffer_record ( s , & ( s -> d1 -> buffered_app_data ) , rr -> seq_num ) < 0 ) { SSLerr ( SSL_F_DTLS1_READ_BYTES , ERR_R_INTERNAL_ERROR ) ; return - 1 ; } <vul-end><vul-sep>
|
19
|
nan <vul-start> void vp8_decoder_remove_threads ( VP8D_COMP * pbi ) { if ( pbi -> b_multithreaded_rd ) { <vul-end> int i ; pbi -> b_multithreaded_rd = 0 ; <vul-start> for ( i = 0 ; i < pbi -> allocated_decoding_thread_count ; i ++ ) { <vul-end> sem_post ( & pbi -> h_event_start_decoding [ i ] ) ; pthread_join ( pbi -> h_decoding_thread [ i ] , NULL ) ; } <vul-start> for ( i = 0 ; i < pbi -> allocated_decoding_thread_count ; i ++ ) { <vul-end> sem_destroy ( & pbi -> h_event_start_decoding [ i ] ) ; } sem_destroy ( & pbi -> h_event_end_decoding ) ; vpx_free ( pbi -> h_decoding_thread ) ; pbi -> h_decoding_thread = NULL ; vpx_free ( pbi -> h_event_start_decoding ) ; pbi -> h_event_start_decoding = NULL ; vpx_free ( pbi -> mb_row_di ) ; pbi -> mb_row_di = NULL ; vpx_free ( pbi -> de_thread_data ) ; pbi -> de_thread_data = NULL ; <vul-start> <vul-end> } }
|
<vul-sep> <vul-start>void vp8_decoder_remove_threads ( VP8D_COMP * pbi ) { if ( pbi -> b_multithreaded_rd ) { <vul-end><vul-sep> pbi -> b_multithreaded_rd = 0 ; <vul-start> for ( i = 0 ; i < pbi -> allocated_decoding_thread_count ; ++ i ) { <vul-end><vul-sep> } <vul-start> for ( i = 0 ; i < pbi -> allocated_decoding_thread_count ; ++ i ) { <vul-end><vul-sep> pbi -> de_thread_data = NULL ; <vul-start> vp8mt_de_alloc_temp_buffers ( pbi , pbi -> common . mb_rows ) ; <vul-end><vul-sep>
|
20
|
CWE-20 <vul-start> void f2fs_wait_discard_bios ( struct f2fs_sb_info * sbi ) <vul-end> { __issue_discard_cmd ( sbi , false ) ; __drop_discard_cmd ( sbi ) ; <vul-start> __wait_discard_cmd ( sbi , false ) ; <vul-end> }
|
<vul-sep> <vul-start>void f2fs_wait_discard_bios ( struct f2fs_sb_info * sbi , bool umount ) <vul-end><vul-sep> __drop_discard_cmd ( sbi ) ; <vul-start> __wait_discard_cmd ( sbi , ! umount ) ; <vul-end><vul-sep>
|
21
|
CWE-400 <vul-start> static int match ( Reinst * pc , const char * sp , const char * bol , int flags , Resub * out ) <vul-end> { Resub scratch ; <vul-start> <vul-end> int i ; Rune c ; <vul-start> <vul-end> for ( ; ; ) { switch ( pc -> opcode ) { case I_END : <vul-start> return 1 ; <vul-end> case I_JUMP : pc = pc -> x ; break ; case I_SPLIT : scratch = * out ; <vul-start> if ( match ( pc -> x , sp , bol , flags , & scratch ) ) { <vul-end> * out = scratch ; <vul-start> return 1 ; <vul-end> } pc = pc -> y ; break ; case I_PLA : <vul-start> if ( ! match ( pc -> x , sp , bol , flags , out ) ) return 0 ; <vul-end> pc = pc -> y ; break ; case I_NLA : scratch = * out ; <vul-start> if ( match ( pc -> x , sp , bol , flags , & scratch ) ) return 0 ; <vul-end> pc = pc -> y ; break ; case I_ANYNL : sp += chartorune ( & c , sp ) ; if ( c == 0 ) <vul-start> return 0 ; <vul-end> pc = pc + 1 ; break ; case I_ANY : sp += chartorune ( & c , sp ) ; if ( c == 0 ) <vul-start> return 0 ; <vul-end> if ( isnewline ( c ) ) <vul-start> return 0 ; <vul-end> pc = pc + 1 ; break ; case I_CHAR : sp += chartorune ( & c , sp ) ; if ( c == 0 ) <vul-start> return 0 ; <vul-end> if ( flags & REG_ICASE ) c = canon ( c ) ; if ( c != pc -> c ) <vul-start> return 0 ; <vul-end> pc = pc + 1 ; break ; case I_CCLASS : sp += chartorune ( & c , sp ) ; if ( c == 0 ) <vul-start> return 0 ; <vul-end> if ( flags & REG_ICASE ) { if ( ! incclasscanon ( pc -> cc , canon ( c ) ) ) <vul-start> return 0 ; <vul-end> } else { if ( ! incclass ( pc -> cc , c ) ) <vul-start> return 0 ; <vul-end> } pc = pc + 1 ; break ; case I_NCCLASS : sp += chartorune ( & c , sp ) ; if ( c == 0 ) <vul-start> return 0 ; <vul-end> if ( flags & REG_ICASE ) { if ( incclasscanon ( pc -> cc , canon ( c ) ) ) <vul-start> return 0 ; <vul-end> } else { if ( incclass ( pc -> cc , c ) ) <vul-start> return 0 ; <vul-end> } pc = pc + 1 ; break ; case I_REF : i = out -> sub [ pc -> n ] . ep - out -> sub [ pc -> n ] . sp ; if ( flags & REG_ICASE ) { if ( strncmpcanon ( sp , out -> sub [ pc -> n ] . sp , i ) ) <vul-start> return 0 ; <vul-end> } else { if ( strncmp ( sp , out -> sub [ pc -> n ] . sp , i ) ) <vul-start> return 0 ; <vul-end> } if ( i > 0 ) sp += i ; pc = pc + 1 ; break ; case I_BOL : if ( sp == bol && ! ( flags & REG_NOTBOL ) ) { pc = pc + 1 ; break ; } if ( flags & REG_NEWLINE ) { if ( sp > bol && isnewline ( sp [ - 1 ] ) ) { pc = pc + 1 ; break ; } } <vul-start> return 0 ; <vul-end> case I_EOL : if ( * sp == 0 ) { pc = pc + 1 ; break ; } if ( flags & REG_NEWLINE ) { if ( isnewline ( * sp ) ) { pc = pc + 1 ; break ; } } <vul-start> return 0 ; <vul-end> case I_WORD : i = sp > bol && iswordchar ( sp [ - 1 ] ) ; i ^= iswordchar ( sp [ 0 ] ) ; if ( ! i ) <vul-start> return 0 ; <vul-end> pc = pc + 1 ; break ; case I_NWORD : i = sp > bol && iswordchar ( sp [ - 1 ] ) ; i ^= iswordchar ( sp [ 0 ] ) ; if ( i ) <vul-start> return 0 ; <vul-end> pc = pc + 1 ; break ; case I_LPAR : out -> sub [ pc -> n ] . sp = sp ; pc = pc + 1 ; break ; case I_RPAR : out -> sub [ pc -> n ] . ep = sp ; pc = pc + 1 ; break ; default : <vul-start> return 0 ; <vul-end> } } }
|
<vul-sep> <vul-start>static int match ( Reinst * pc , const char * sp , const char * bol , int flags , Resub * out , int depth ) <vul-end><vul-sep> Resub scratch ; <vul-start> int result ; <vul-end><vul-sep> Rune c ; <vul-start> if ( depth > MAXREC ) return - 1 ; <vul-end><vul-sep> case I_END : <vul-start> return 0 ; <vul-end><vul-sep> scratch = * out ; <vul-start> result = match ( pc -> x , sp , bol , flags , & scratch , depth + 1 ) ; if ( result == - 1 ) return - 1 ; if ( result == 0 ) { <vul-end><vul-sep> * out = scratch ; <vul-start> return 0 ; <vul-end><vul-sep> case I_PLA : <vul-start> result = match ( pc -> x , sp , bol , flags , out , depth + 1 ) ; if ( result == - 1 ) return - 1 ; if ( result == 1 ) return 1 ; <vul-end><vul-sep> scratch = * out ; <vul-start> result = match ( pc -> x , sp , bol , flags , & scratch , depth + 1 ) ; if ( result == - 1 ) return - 1 ; if ( result == 0 ) return 1 ; <vul-end><vul-sep> if ( c == 0 ) <vul-start> return 1 ; <vul-end><vul-sep> if ( c == 0 ) <vul-start> return 1 ; <vul-end><vul-sep> if ( isnewline ( c ) ) <vul-start> return 1 ; <vul-end><vul-sep> if ( c == 0 ) <vul-start> return 1 ; <vul-end><vul-sep> if ( c != pc -> c ) <vul-start> return 1 ; <vul-end><vul-sep> if ( c == 0 ) <vul-start> return 1 ; <vul-end><vul-sep> if ( ! incclasscanon ( pc -> cc , canon ( c ) ) ) <vul-start> return 1 ; <vul-end><vul-sep> if ( ! incclass ( pc -> cc , c ) ) <vul-start> return 1 ; <vul-end><vul-sep> if ( c == 0 ) <vul-start> return 1 ; <vul-end><vul-sep> if ( incclasscanon ( pc -> cc , canon ( c ) ) ) <vul-start> return 1 ; <vul-end><vul-sep> if ( incclass ( pc -> cc , c ) ) <vul-start> return 1 ; <vul-end><vul-sep> if ( strncmpcanon ( sp , out -> sub [ pc -> n ] . sp , i ) ) <vul-start> return 1 ; <vul-end><vul-sep> if ( strncmp ( sp , out -> sub [ pc -> n ] . sp , i ) ) <vul-start> return 1 ; <vul-end><vul-sep> } <vul-start> return 1 ; <vul-end><vul-sep> } <vul-start> return 1 ; <vul-end><vul-sep> if ( ! i ) <vul-start> return 1 ; <vul-end><vul-sep> if ( i ) <vul-start> return 1 ; <vul-end><vul-sep> default : <vul-start> return 1 ; <vul-end><vul-sep>
|
22
|
CWE-119 <vul-start> static void write_ref_frames ( const VP9_COMP * cpi , vp9_writer * w ) { const VP9_COMMON * const cm = & cpi -> common ; const MACROBLOCKD * const xd = & cpi -> mb . e_mbd ; <vul-end> const MB_MODE_INFO * const mbmi = & xd -> mi [ 0 ] -> mbmi ; const int is_compound = has_second_ref ( mbmi ) ; const int segment_id = mbmi -> segment_id ; <vul-start> if ( vp9_segfeature_active ( & cm -> seg , segment_id , SEG_LVL_REF_FRAME ) ) { <vul-end> assert ( ! is_compound ) ; assert ( mbmi -> ref_frame [ 0 ] == <vul-start> vp9_get_segdata ( & cm -> seg , segment_id , SEG_LVL_REF_FRAME ) ) ; <vul-end> } else { if ( cm -> reference_mode == REFERENCE_MODE_SELECT ) { <vul-start> vp9_write ( w , is_compound , vp9_get_reference_mode_prob ( cm , xd ) ) ; <vul-end> } else { assert ( ! is_compound == ( cm -> reference_mode == SINGLE_REFERENCE ) ) ; } if ( is_compound ) { <vul-start> vp9_write ( w , mbmi -> ref_frame [ 0 ] == GOLDEN_FRAME , <vul-end> vp9_get_pred_prob_comp_ref_p ( cm , xd ) ) ; } else { const int bit0 = mbmi -> ref_frame [ 0 ] != LAST_FRAME ; <vul-start> vp9_write ( w , bit0 , vp9_get_pred_prob_single_ref_p1 ( cm , xd ) ) ; <vul-end> if ( bit0 ) { const int bit1 = mbmi -> ref_frame [ 0 ] != GOLDEN_FRAME ; <vul-start> vp9_write ( w , bit1 , vp9_get_pred_prob_single_ref_p2 ( cm , xd ) ) ; <vul-end> } } } }
|
<vul-sep> <vul-start>static void write_ref_frames ( const VP9_COMMON * cm , const MACROBLOCKD * xd , vpx_writer * w ) { <vul-end><vul-sep> const int segment_id = mbmi -> segment_id ; <vul-start> if ( segfeature_active ( & cm -> seg , segment_id , SEG_LVL_REF_FRAME ) ) { <vul-end><vul-sep> assert ( mbmi -> ref_frame [ 0 ] == <vul-start> get_segdata ( & cm -> seg , segment_id , SEG_LVL_REF_FRAME ) ) ; <vul-end><vul-sep> if ( cm -> reference_mode == REFERENCE_MODE_SELECT ) { <vul-start> vpx_write ( w , is_compound , vp9_get_reference_mode_prob ( cm , xd ) ) ; <vul-end><vul-sep> if ( is_compound ) { <vul-start> vpx_write ( w , mbmi -> ref_frame [ 0 ] == GOLDEN_FRAME , <vul-end><vul-sep> const int bit0 = mbmi -> ref_frame [ 0 ] != LAST_FRAME ; <vul-start> vpx_write ( w , bit0 , vp9_get_pred_prob_single_ref_p1 ( cm , xd ) ) ; <vul-end><vul-sep> const int bit1 = mbmi -> ref_frame [ 0 ] != GOLDEN_FRAME ; <vul-start> vpx_write ( w , bit1 , vp9_get_pred_prob_single_ref_p2 ( cm , xd ) ) ; <vul-end><vul-sep>
|
23
|
CWE-125 static void nfnetlink_rcv_batch ( struct sk_buff * skb , struct nlmsghdr * nlh , u_int16_t subsys_id ) { struct sk_buff * oskb = skb ; struct net * net = sock_net ( skb -> sk ) ; const struct nfnetlink_subsystem * ss ; const struct nfnl_callback * nc ; static LIST_HEAD ( err_list ) ; u32 status ; int err ; if ( subsys_id >= NFNL_SUBSYS_COUNT ) return netlink_ack ( skb , nlh , - EINVAL ) ; replay : status = 0 ; skb = netlink_skb_clone ( oskb , GFP_KERNEL ) ; if ( ! skb ) return netlink_ack ( oskb , nlh , - ENOMEM ) ; nfnl_lock ( subsys_id ) ; ss = nfnl_dereference_protected ( subsys_id ) ; if ( ! ss ) { # ifdef CONFIG_MODULES nfnl_unlock ( subsys_id ) ; request_module ( "nfnetlink-subsys-%d" , subsys_id ) ; nfnl_lock ( subsys_id ) ; ss = nfnl_dereference_protected ( subsys_id ) ; if ( ! ss ) # endif { nfnl_unlock ( subsys_id ) ; netlink_ack ( oskb , nlh , - EOPNOTSUPP ) ; return kfree_skb ( skb ) ; } } if ( ! ss -> commit || ! ss -> abort ) { nfnl_unlock ( subsys_id ) ; netlink_ack ( oskb , nlh , - EOPNOTSUPP ) ; return kfree_skb ( skb ) ; } while ( skb -> len >= nlmsg_total_size ( 0 ) ) { int msglen , type ; nlh = nlmsg_hdr ( skb ) ; err = 0 ; <vul-start> if ( nlmsg_len ( nlh ) < sizeof ( struct nfgenmsg ) || skb -> len < nlh -> nlmsg_len ) { err = - EINVAL ; goto ack ; <vul-end> } if ( ! ( nlh -> nlmsg_flags & NLM_F_REQUEST ) ) { err = - EINVAL ; goto ack ; } type = nlh -> nlmsg_type ; if ( type == NFNL_MSG_BATCH_BEGIN ) { nfnl_err_reset ( & err_list ) ; status |= NFNL_BATCH_FAILURE ; goto done ; } else if ( type == NFNL_MSG_BATCH_END ) { status |= NFNL_BATCH_DONE ; goto done ; } else if ( type < NLMSG_MIN_TYPE ) { err = - EINVAL ; goto ack ; } if ( NFNL_SUBSYS_ID ( type ) != subsys_id ) { err = - EINVAL ; goto ack ; } nc = nfnetlink_find_client ( type , ss ) ; if ( ! nc ) { err = - EINVAL ; goto ack ; } { int min_len = nlmsg_total_size ( sizeof ( struct nfgenmsg ) ) ; u_int8_t cb_id = NFNL_MSG_TYPE ( nlh -> nlmsg_type ) ; struct nlattr * cda [ ss -> cb [ cb_id ] . attr_count + 1 ] ; struct nlattr * attr = ( void * ) nlh + min_len ; int attrlen = nlh -> nlmsg_len - min_len ; err = nla_parse ( cda , ss -> cb [ cb_id ] . attr_count , attr , attrlen , ss -> cb [ cb_id ] . policy ) ; if ( err < 0 ) goto ack ; if ( nc -> call_batch ) { err = nc -> call_batch ( net , net -> nfnl , skb , nlh , ( const struct nlattr * * ) cda ) ; } if ( err == - EAGAIN ) { status |= NFNL_BATCH_REPLAY ; goto next ; } } ack : if ( nlh -> nlmsg_flags & NLM_F_ACK || err ) { if ( nfnl_err_add ( & err_list , nlh , err ) < 0 ) { nfnl_err_reset ( & err_list ) ; netlink_ack ( oskb , nlmsg_hdr ( oskb ) , - ENOMEM ) ;
|
<vul-sep> err = 0 ; <vul-start> if ( nlh -> nlmsg_len < NLMSG_HDRLEN || skb -> len < nlh -> nlmsg_len || nlmsg_len ( nlh ) < sizeof ( struct nfgenmsg ) ) { nfnl_err_reset ( & err_list ) ; status |= NFNL_BATCH_FAILURE ; goto done ; <vul-end><vul-sep>
|
24
|
CWE-326 int secure_check ( void * data ) { const at91_secure_header_t * header ; void * file ; <vul-start> <vul-end> if ( secure_decrypt ( data , sizeof ( * header ) , 0 ) ) <vul-start> return - 1 ; <vul-end> header = ( const at91_secure_header_t * ) data ; if ( header -> magic != AT91_SECURE_MAGIC ) <vul-start> return - 1 ; <vul-end> file = ( unsigned char * ) data + sizeof ( * header ) ; <vul-start> return secure_decrypt ( file , header -> file_size , 1 ) ; <vul-end> }
|
<vul-sep> void * file ; <vul-start> int ret = - 1 ; <vul-end><vul-sep> if ( secure_decrypt ( data , sizeof ( * header ) , 0 ) ) <vul-start> goto secure_wipe_keys ; <vul-end><vul-sep> if ( header -> magic != AT91_SECURE_MAGIC ) <vul-start> goto secure_wipe_keys ; <vul-end><vul-sep> file = ( unsigned char * ) data + sizeof ( * header ) ; <vul-start> ret = secure_decrypt ( file , header -> file_size , 1 ) ; secure_wipe_keys : wipe_keys ( ) ; return ret ; <vul-end><vul-sep>
|
25
|
CWE-190 int jas_stream_gobble ( jas_stream_t * stream , int n ) { int m ; <vul-start> <vul-end> m = n ; for ( m = n ; m > 0 ; -- m ) { if ( jas_stream_getc ( stream ) == EOF ) { return n - m ; } } return n ; }
|
<vul-sep> int m ; <vul-start> if ( n < 0 ) { jas_deprecated ( "negative count for jas_stream_gobble" ) ; } <vul-end><vul-sep>
|
26
|
CWE-476 rdpCredssp * credssp_new ( freerdp * instance , rdpTransport * transport , rdpSettings * settings ) { rdpCredssp * credssp ; credssp = ( rdpCredssp * ) malloc ( sizeof ( rdpCredssp ) ) ; ZeroMemory ( credssp , sizeof ( rdpCredssp ) ) ; if ( credssp != NULL ) { HKEY hKey ; LONG status ; DWORD dwType ; DWORD dwSize ; credssp -> instance = instance ; credssp -> settings = settings ; credssp -> server = settings -> ServerMode ; credssp -> transport = transport ; credssp -> send_seq_num = 0 ; credssp -> recv_seq_num = 0 ; ZeroMemory ( & credssp -> negoToken , sizeof ( SecBuffer ) ) ; ZeroMemory ( & credssp -> pubKeyAuth , sizeof ( SecBuffer ) ) ; ZeroMemory ( & credssp -> authInfo , sizeof ( SecBuffer ) ) ; <vul-start> <vul-end> if ( credssp -> server ) { status = RegOpenKeyEx ( HKEY_LOCAL_MACHINE , _T ( "Software\\\\FreeRDP\\\\Server" ) , 0 , KEY_READ | KEY_WOW64_64KEY , & hKey ) ; if ( status == ERROR_SUCCESS ) { status = RegQueryValueEx ( hKey , _T ( "SspiModule" ) , NULL , & dwType , NULL , & dwSize ) ; if ( status == ERROR_SUCCESS ) { credssp -> SspiModule = ( LPTSTR ) malloc ( dwSize + sizeof ( TCHAR ) ) ; status = RegQueryValueEx ( hKey , _T ( "SspiModule" ) , NULL , & dwType , ( BYTE * ) credssp -> SspiModule , & dwSize ) ; if ( status == ERROR_SUCCESS ) { _tprintf ( _T ( "Using SSPI Module: %s\\n" ) , credssp -> SspiModule ) ; RegCloseKey ( hKey ) ; } } } } } return credssp ; }
|
<vul-sep> ZeroMemory ( & credssp -> authInfo , sizeof ( SecBuffer ) ) ; <vul-start> SecInvalidateHandle ( & credssp -> context ) ; <vul-end><vul-sep>
|
27
|
CWE-284 bool semaphore_try_wait ( semaphore_t * semaphore ) { assert ( semaphore != NULL ) ; assert ( semaphore -> fd != INVALID_FD ) ; <vul-start> int flags = fcntl ( semaphore -> fd , F_GETFL ) ; <vul-end> if ( flags == - 1 ) { LOG_ERROR ( "%s unable to get flags for semaphore fd: %s" , __func__ , strerror ( errno ) ) ; return false ; } <vul-start> if ( fcntl ( semaphore -> fd , F_SETFL , flags | O_NONBLOCK ) == - 1 ) { <vul-end> LOG_ERROR ( "%s unable to set O_NONBLOCK for semaphore fd: %s" , __func__ , strerror ( errno ) ) ; return false ; } eventfd_t value ; if ( eventfd_read ( semaphore -> fd , & value ) == - 1 ) return false ; <vul-start> if ( fcntl ( semaphore -> fd , F_SETFL , flags ) == - 1 ) <vul-end> LOG_ERROR ( "%s unable to resetore flags for semaphore fd: %s" , __func__ , strerror ( errno ) ) ; return true ; }
|
<vul-sep> assert ( semaphore -> fd != INVALID_FD ) ; <vul-start> int flags = TEMP_FAILURE_RETRY ( fcntl ( semaphore -> fd , F_GETFL ) ) ; <vul-end><vul-sep> } <vul-start> if ( TEMP_FAILURE_RETRY ( fcntl ( semaphore -> fd , F_SETFL , flags | O_NONBLOCK ) ) == - 1 ) { <vul-end><vul-sep> return false ; <vul-start> if ( TEMP_FAILURE_RETRY ( fcntl ( semaphore -> fd , F_SETFL , flags ) ) == - 1 ) <vul-end><vul-sep>
|
28
|
CWE-119 <vul-start> void usage_exit ( ) { <vul-end> int i ; fprintf ( stderr , "Usage: %s <options> filename\\n\\n" "Options:\\n" , exec_name ) ; arg_show_usage ( stderr , all_args ) ; # if CONFIG_VP8_DECODER fprintf ( stderr , "\\nVP8 Postprocessing Options:\\n" ) ; arg_show_usage ( stderr , vp8_pp_args ) ; # endif fprintf ( stderr , "\\nOutput File Patterns:\\n\\n" " The -o argument specifies the name of the file(s) to " "write to. If the\\n argument does not include any escape " "characters, the output will be\\n written to a single file. " "Otherwise, the filename will be calculated by\\n expanding " "the following escape characters:\\n" ) ; fprintf ( stderr , "\\n\\t%%w - Frame width" "\\n\\t%%h - Frame height" "\\n\\t%%<n> - Frame number, zero padded to <n> places (1..9)" "\\n\\n Pattern arguments are only supported in conjunction " "with the --yv12 and\\n --i420 options. If the -o option is " "not specified, the output will be\\n directed to stdout.\\n" ) ; fprintf ( stderr , "\\nIncluded decoders:\\n\\n" ) ; for ( i = 0 ; i < get_vpx_decoder_count ( ) ; ++ i ) { const VpxInterface * const decoder = get_vpx_decoder_by_index ( i ) ; fprintf ( stderr , " %-6s - %s\\n" , <vul-start> decoder -> name , vpx_codec_iface_name ( decoder -> interface ( ) ) ) ; <vul-end> } exit ( EXIT_FAILURE ) ; }
|
<vul-sep> <vul-start>void usage_exit ( void ) { <vul-end><vul-sep> fprintf ( stderr , " %-6s - %s\\n" , <vul-start> decoder -> name , vpx_codec_iface_name ( decoder -> codec_interface ( ) ) ) ; <vul-end><vul-sep>
|
29
|
CWE-787 char * gf_text_get_utf8_line ( char * szLine , u32 lineSize , FILE * txt_in , s32 unicode_type ) { u32 i , j , len ; char * sOK ; char szLineConv [ 1024 ] ; unsigned short * sptr ; memset ( szLine , 0 , sizeof ( char ) * lineSize ) ; sOK = fgets ( szLine , lineSize , txt_in ) ; if ( ! sOK ) return NULL ; if ( unicode_type <= 1 ) { j = 0 ; len = ( u32 ) strlen ( szLine ) ; <vul-start> for ( i = 0 ; i < len ; i ++ ) { <vul-end> if ( ! unicode_type && ( szLine [ i ] & 0x80 ) ) { if ( ( szLine [ i + 1 ] & 0xc0 ) != 0x80 ) { <vul-start> <vul-end> szLineConv [ j ] = 0xc0 | ( ( szLine [ i ] >> 6 ) & 0x3 ) ; j ++ ; szLine [ i ] &= 0xbf ; } <vul-start> <vul-end> else if ( ( szLine [ i ] & 0xe0 ) == 0xc0 ) { <vul-start> <vul-end> szLineConv [ j ] = szLine [ i ] ; i ++ ; j ++ ; } <vul-start> <vul-end> else if ( ( szLine [ i ] & 0xf0 ) == 0xe0 ) { <vul-start> <vul-end> szLineConv [ j ] = szLine [ i ] ; i ++ ; j ++ ; szLineConv [ j ] = szLine [ i ] ; i ++ ; j ++ ; } <vul-start> <vul-end> else if ( ( szLine [ i ] & 0xf8 ) == 0xf0 ) { <vul-start> <vul-end> szLineConv [ j ] = szLine [ i ] ; i ++ ; j ++ ; szLineConv [ j ] = szLine [ i ] ; i ++ ; j ++ ; szLineConv [ j ] = szLine [ i ] ; i ++ ; j ++ ; <vul-start> <vul-end> } else { i += 1 ; continue ; } } <vul-start> <vul-end> szLineConv [ j ] = szLine [ i ] ; <vul-start> j ++ ; <vul-end> } <vul-start> <vul-end> szLineConv [ j ] = 0 ; strcpy ( szLine , szLineConv ) ; return sOK ; } # ifdef GPAC_BIG_ENDIAN if ( unicode_type == 3 ) { # else if ( unicode_type == 2 ) { # endif i = 0 ; while ( 1 ) { char c ; if ( ! szLine [ i ] && ! szLine [ i + 1 ] ) break ; c = szLine [ i + 1 ] ; szLine [ i + 1 ] = szLine [ i ] ; szLine [ i ] = c ; i += 2 ; } } sptr = ( u16 * ) szLine ; i = ( u32 ) gf_utf8_wcstombs ( szLineConv , 1024 , ( const unsigned short * * ) & sptr ) ; if ( i >= ( u32 ) ARRAY_LENGTH ( szLineConv ) ) return NULL ; szLineConv [ i ] = 0 ; strcpy ( szLine , szLineConv ) ; if ( unicode_type == 3 ) fgetc ( txt_in ) ; return sOK ; }
|
<vul-sep> len = ( u32 ) strlen ( szLine ) ; <vul-start> for ( i = 0 ; i < len && j < sizeof ( szLineConv ) - 1 ; i ++ , j ++ ) { <vul-end><vul-sep> if ( ( szLine [ i + 1 ] & 0xc0 ) != 0x80 ) { <vul-start> if ( j + 1 < sizeof ( szLineConv ) - 1 ) { <vul-end><vul-sep> } <vul-start> else break ; } <vul-end><vul-sep> else if ( ( szLine [ i ] & 0xe0 ) == 0xc0 ) { <vul-start> if ( j + 1 < sizeof ( szLineConv ) - 1 && i + 1 < len ) { <vul-end><vul-sep> } <vul-start> else { break ; } } <vul-end><vul-sep> else if ( ( szLine [ i ] & 0xf0 ) == 0xe0 ) { <vul-start> if ( j + 2 < sizeof ( szLineConv ) - 1 && i + 2 < len ) { <vul-end><vul-sep> } <vul-start> else { break ; } } <vul-end><vul-sep> else if ( ( szLine [ i ] & 0xf8 ) == 0xf0 ) { <vul-start> if ( j + 3 < sizeof ( szLineConv ) - 1 && i + 3 < len ) { <vul-end><vul-sep> j ++ ; <vul-start> } else { break ; } <vul-end><vul-sep> } <vul-start> if ( j < sizeof ( szLineConv ) - 1 && i < len ) <vul-end><vul-sep> szLineConv [ j ] = szLine [ i ] ; <vul-start><vul-end><vul-sep> } <vul-start> if ( j >= sizeof ( szLineConv ) ) szLineConv [ sizeof ( szLineConv ) - 1 ] = 0 ; else <vul-end><vul-sep>
|
30
|
CWE-835 static int lldp_private_8021_print ( netdissect_options * ndo , const u_char * tptr , u_int tlv_len ) { int subtype , hexdump = FALSE ; u_int sublen ; u_int tval ; <vul-start> uint8_t i ; <vul-end> if ( tlv_len < 4 ) { return hexdump ; } subtype = * ( tptr + 3 ) ; ND_PRINT ( ( ndo , "\\n\\t %s Subtype (%u)" , tok2str ( lldp_8021_subtype_values , "unknown" , subtype ) , subtype ) ) ; switch ( subtype ) { case LLDP_PRIVATE_8021_SUBTYPE_PORT_VLAN_ID : if ( tlv_len < 6 ) { return hexdump ; } ND_PRINT ( ( ndo , "\\n\\t port vlan id (PVID): %u" , EXTRACT_16BITS ( tptr + 4 ) ) ) ; break ; case LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_VLAN_ID : if ( tlv_len < 7 ) { return hexdump ; } ND_PRINT ( ( ndo , "\\n\\t port and protocol vlan id (PPVID): %u, flags [%s] (0x%02x)" , EXTRACT_16BITS ( tptr + 5 ) , bittok2str ( lldp_8021_port_protocol_id_values , "none" , * ( tptr + 4 ) ) , * ( tptr + 4 ) ) ) ; break ; case LLDP_PRIVATE_8021_SUBTYPE_VLAN_NAME : if ( tlv_len < 6 ) { return hexdump ; } ND_PRINT ( ( ndo , "\\n\\t vlan id (VID): %u" , EXTRACT_16BITS ( tptr + 4 ) ) ) ; if ( tlv_len < 7 ) { return hexdump ; } sublen = * ( tptr + 6 ) ; if ( tlv_len < 7 + sublen ) { return hexdump ; } ND_PRINT ( ( ndo , "\\n\\t vlan name: " ) ) ; safeputs ( ndo , tptr + 7 , sublen ) ; break ; case LLDP_PRIVATE_8021_SUBTYPE_PROTOCOL_IDENTITY : if ( tlv_len < 5 ) { return hexdump ; } sublen = * ( tptr + 4 ) ; if ( tlv_len < 5 + sublen ) { return hexdump ; } ND_PRINT ( ( ndo , "\\n\\t protocol identity: " ) ) ; safeputs ( ndo , tptr + 5 , sublen ) ; break ;
|
<vul-sep> u_int tval ; <vul-start> u_int i ; <vul-end><vul-sep>
|
31
|
CWE-119 static int test_candidate_kf ( VP8_COMP * cpi , FIRSTPASS_STATS * last_frame , FIRSTPASS_STATS * this_frame , FIRSTPASS_STATS * next_frame ) { int is_viable_kf = 0 ; if ( ( this_frame -> pcnt_second_ref < 0.10 ) && ( next_frame -> pcnt_second_ref < 0.10 ) && ( ( this_frame -> pcnt_inter < 0.05 ) || ( ( ( this_frame -> pcnt_inter - this_frame -> pcnt_neutral ) < .25 ) && ( ( this_frame -> intra_error / DOUBLE_DIVIDE_CHECK ( this_frame -> coded_error ) ) < 2.5 ) && ( ( fabs ( last_frame -> coded_error - this_frame -> coded_error ) / DOUBLE_DIVIDE_CHECK ( this_frame -> coded_error ) > .40 ) || ( fabs ( last_frame -> intra_error - this_frame -> intra_error ) / DOUBLE_DIVIDE_CHECK ( this_frame -> intra_error ) > .40 ) || ( ( next_frame -> intra_error / DOUBLE_DIVIDE_CHECK ( next_frame -> coded_error ) ) > 3.5 ) ) ) ) ) { int i ; FIRSTPASS_STATS * start_pos ; FIRSTPASS_STATS local_next_frame ; double boost_score = 0.0 ; double old_boost_score = 0.0 ; double decay_accumulator = 1.0 ; double next_iiratio ; <vul-start> vpx_memcpy ( & local_next_frame , next_frame , sizeof ( * next_frame ) ) ; <vul-end> start_pos = cpi -> twopass . stats_in ; for ( i = 0 ; i < 16 ; i ++ ) { next_iiratio = ( IIKFACTOR1 * local_next_frame . intra_error / DOUBLE_DIVIDE_CHECK ( local_next_frame . coded_error ) ) ; if ( next_iiratio > RMAX ) next_iiratio = RMAX ; if ( local_next_frame . pcnt_inter > 0.85 ) decay_accumulator = decay_accumulator * local_next_frame . pcnt_inter ; else decay_accumulator = decay_accumulator * ( ( 0.85 + local_next_frame . pcnt_inter ) / 2.0 ) ; boost_score += ( decay_accumulator * next_iiratio ) ; if ( ( local_next_frame . pcnt_inter < 0.05 ) || ( next_iiratio < 1.5 ) || ( ( ( local_next_frame . pcnt_inter - local_next_frame . pcnt_neutral ) < 0.20 ) && ( next_iiratio < 3.0 ) ) || ( ( boost_score - old_boost_score ) < 0.5 ) || ( local_next_frame . intra_error < 200 ) ) { break ; } old_boost_score = boost_score ; if ( EOF == input_stats ( cpi , & local_next_frame ) ) break ; } if ( boost_score > 5.0 && ( i > 3 ) ) is_viable_kf = 1 ; else { reset_fpf_position ( cpi , start_pos ) ; is_viable_kf = 0 ; } } return is_viable_kf ; }
|
<vul-sep> double next_iiratio ; <vul-start> memcpy ( & local_next_frame , next_frame , sizeof ( * next_frame ) ) ; <vul-end><vul-sep>
|
32
|
CWE-119 static void write_modes ( VP9_COMP * cpi , <vul-start> const TileInfo * const tile , vp9_writer * w , TOKENEXTRA * * tok , TOKENEXTRA * tok_end ) { <vul-end> int mi_row , mi_col ; <vul-start> <vul-end> for ( mi_row = tile -> mi_row_start ; mi_row < tile -> mi_row_end ; mi_row += MI_BLOCK_SIZE ) { <vul-start> vp9_zero ( cpi -> mb . e_mbd . left_seg_context ) ; <vul-end> for ( mi_col = tile -> mi_col_start ; mi_col < tile -> mi_col_end ; mi_col += MI_BLOCK_SIZE ) write_modes_sb ( cpi , tile , w , tok , tok_end , mi_row , mi_col , BLOCK_64X64 ) ; } }
|
<vul-sep> static void write_modes ( VP9_COMP * cpi , <vul-start> const TileInfo * const tile , vpx_writer * w , TOKENEXTRA * * tok , const TOKENEXTRA * const tok_end ) { const VP9_COMMON * const cm = & cpi -> common ; MACROBLOCKD * const xd = & cpi -> td . mb . e_mbd ; <vul-end><vul-sep> int mi_row , mi_col ; <vul-start> set_partition_probs ( cm , xd ) ; <vul-end><vul-sep> mi_row += MI_BLOCK_SIZE ) { <vul-start> vp9_zero ( xd -> left_seg_context ) ; <vul-end><vul-sep>
|
33
|
CWE-20 error_t mqttSnClientSubscribe ( MqttSnClientContext * context , const char_t * topicName , MqttSnQosLevel qos ) { error_t error ; systime_t time ; if ( context == NULL || topicName == NULL ) return ERROR_INVALID_PARAMETER ; error = NO_ERROR ; while ( ! error ) { time = osGetSystemTime ( ) ; if ( context -> state == MQTT_SN_CLIENT_STATE_ACTIVE ) { mqttSnClientGenerateMessageId ( context ) ; context -> startTime = time ; error = mqttSnClientSendSubscribe ( context , topicName , qos ) ; } else if ( context -> state == MQTT_SN_CLIENT_STATE_SENDING_REQ ) { if ( timeCompare ( time , context -> startTime + context -> timeout ) >= 0 ) { context -> state = MQTT_SN_CLIENT_STATE_DISCONNECTING ; error = ERROR_TIMEOUT ; } else if ( timeCompare ( time , context -> retransmitStartTime + MQTT_SN_CLIENT_RETRY_TIMEOUT ) >= 0 ) { error = mqttSnClientSendSubscribe ( context , topicName , qos ) ; } else { error = mqttSnClientProcessEvents ( context , MQTT_SN_CLIENT_TICK_INTERVAL ) ; } } else if ( context -> state == MQTT_SN_CLIENT_STATE_RESP_RECEIVED ) { context -> state = MQTT_SN_CLIENT_STATE_ACTIVE ; if ( context -> msgType == MQTT_SN_MSG_TYPE_SUBACK ) { if ( context -> returnCode == MQTT_SN_RETURN_CODE_ACCEPTED ) { <vul-start> if ( strchr ( topicName , '#' ) == NULL && strchr ( topicName , '+' ) == NULL ) <vul-end> { error = mqttSnClientAddTopic ( context , topicName , context -> topicId ) ; } break ; } else { error = ERROR_REQUEST_REJECTED ; } } else { error = ERROR_UNEXPECTED_RESPONSE ; } } else { error = ERROR_NOT_CONNECTED ; } } return error ; }
|
<vul-sep> { <vul-start> if ( osStrchr ( topicName , '#' ) == NULL && osStrchr ( topicName , '+' ) == NULL ) <vul-end><vul-sep>
|
34
|
CWE-119 static RD_BOOL mcs_recv_connect_response ( STREAM mcs_data ) { UNUSED ( mcs_data ) ; uint8 result ; <vul-start> int length ; <vul-end> STREAM s ; <vul-start> <vul-end> RD_BOOL is_fastpath ; uint8 fastpath_hdr ; logger ( Protocol , Debug , "%s()" , __func__ ) ; s = iso_recv ( & is_fastpath , & fastpath_hdr ) ; if ( s == NULL ) return False ; <vul-start> <vul-end> ber_parse_header ( s , MCS_CONNECT_RESPONSE , & length ) ; ber_parse_header ( s , BER_TAG_RESULT , & length ) ; in_uint8 ( s , result ) ; if ( result != 0 ) { logger ( Protocol , Error , "mcs_recv_connect_response(), result=%d" , result ) ; return False ; } ber_parse_header ( s , BER_TAG_INTEGER , & length ) ; in_uint8s ( s , length ) ; <vul-start> <vul-end> mcs_parse_domain_params ( s ) ; ber_parse_header ( s , BER_TAG_OCTET_STRING , & length ) ; sec_process_mcs_data ( s ) ; return s_check_end ( s ) ; }
|
<vul-sep> uint8 result ; <vul-start> uint32 length ; <vul-end><vul-sep> STREAM s ; <vul-start> struct stream packet ; <vul-end><vul-sep> return False ; <vul-start> packet = * s ; <vul-end><vul-sep> in_uint8s ( s , length ) ; <vul-start> if ( ! s_check_rem ( s , length ) ) { rdp_protocol_error ( "mcs_recv_connect_response(), consume connect id from stream would overrun" , & packet ) ; } <vul-end><vul-sep>
|
35
|
CWE-189 Datum txid_current_snapshot ( PG_FUNCTION_ARGS ) { TxidSnapshot * snap ; uint32 nxip , i , size ; TxidEpoch state ; Snapshot cur ; cur = GetActiveSnapshot ( ) ; if ( cur == NULL ) elog ( ERROR , "no active snapshot set" ) ; load_xid_epoch ( & state ) ; <vul-start> <vul-end> nxip = cur -> xcnt ; size = TXID_SNAPSHOT_SIZE ( nxip ) ; snap = palloc ( size ) ; SET_VARSIZE ( snap , size ) ; snap -> xmin = convert_xid ( cur -> xmin , & state ) ; snap -> xmax = convert_xid ( cur -> xmax , & state ) ; snap -> nxip = nxip ; for ( i = 0 ; i < nxip ; i ++ ) snap -> xip [ i ] = convert_xid ( cur -> xip [ i ] , & state ) ; sort_snapshot ( snap ) ; PG_RETURN_POINTER ( snap ) ; }
|
<vul-sep> load_xid_epoch ( & state ) ; <vul-start> StaticAssertStmt ( MAX_BACKENDS * 2 <= TXID_SNAPSHOT_MAX_NXIP , "possible overflow in txid_current_snapshot()" ) ; <vul-end><vul-sep>
|
36
|
CWE-119 <vul-start> static double get_prediction_decay_rate ( const VP9_COMMON * cm , <vul-end> const FIRSTPASS_STATS * next_frame ) { <vul-start> const double mb_sr_err_diff = ( next_frame -> sr_coded_error - next_frame -> coded_error ) / cm -> MBs ; const double second_ref_decay = mb_sr_err_diff <= 512.0 ? fclamp ( pow ( 1.0 - ( mb_sr_err_diff / 512.0 ) , 0.5 ) , 0.85 , 1.0 ) : 0.85 ; return MIN ( second_ref_decay , next_frame -> pcnt_inter ) ; <vul-end> }
|
<vul-sep> <vul-start>static double get_prediction_decay_rate ( const VP9_COMP * cpi , <vul-end><vul-sep> const FIRSTPASS_STATS * next_frame ) { <vul-start> const double sr_decay_rate = get_sr_decay_rate ( cpi , next_frame ) ; const double zero_motion_factor = ( 0.95 * pow ( ( next_frame -> pcnt_inter - next_frame -> pcnt_motion ) , ZM_POWER_FACTOR ) ) ; return MAX ( zero_motion_factor , ( sr_decay_rate + ( ( 1.0 - sr_decay_rate ) * zero_motion_factor ) ) ) ; <vul-end><vul-sep>
|
37
|
CWE-190 int bmp_validate ( jas_stream_t * in ) { int n ; int i ; <vul-start> uchar buf [ 2 ] ; <vul-end> assert ( JAS_STREAM_MAXPUTBACK >= 2 ) ; if ( ( n = jas_stream_read ( in , ( char * ) buf , 2 ) ) < 0 ) { return - 1 ; } for ( i = n - 1 ; i >= 0 ; -- i ) { if ( jas_stream_ungetc ( in , buf [ i ] ) == EOF ) { return - 1 ; } } if ( n < 2 ) { return - 1 ; } if ( buf [ 0 ] == ( BMP_MAGIC & 0xff ) && buf [ 1 ] == ( BMP_MAGIC >> 8 ) ) { return 0 ; } return - 1 ; }
|
<vul-sep> int i ; <vul-start> jas_uchar buf [ 2 ] ; <vul-end><vul-sep>
|
38
|
CWE-416 } ep = { 0 } ; ut8 sep [ 2 * sizeof ( ut64 ) ] = { 0 } ; sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "main" , 0 ) ; if ( ! is_first_thread ) { bprintf ( "Error: LC_MAIN with other threads\\n" ) ; return false ; } if ( off + 8 > bin -> size || off + sizeof ( ep ) > bin -> size ) { bprintf ( "invalid command size for main\\n" ) ; return false ; } r_buf_read_at ( bin -> b , off + 8 , sep , 2 * sizeof ( ut64 ) ) ; ep . eo = r_read_ble64 ( & sep [ 0 ] , bin -> big_endian ) ; ep . ss = r_read_ble64 ( & sep [ 8 ] , bin -> big_endian ) ; bin -> entry = ep . eo ; bin -> main_cmd = lc ; sdb_num_set ( bin -> kv , "mach0.entry.offset" , off + 8 , 0 ) ; sdb_num_set ( bin -> kv , "stacksize" , ep . ss , 0 ) ; is_first_thread = false ; } break ; case LC_UNIXTHREAD : sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "unixthread" , 0 ) ; if ( ! is_first_thread ) { bprintf ( "Error: LC_UNIXTHREAD with other threads\\n" ) ; return false ; } case LC_THREAD : sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "thread" , 0 ) ; if ( ! parse_thread ( bin , & lc , off , is_first_thread ) ) { bprintf ( "Cannot parse thread\\n" ) ; return false ; } is_first_thread = false ; break ; case LC_LOAD_DYLIB : case LC_LOAD_WEAK_DYLIB : sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "load_dylib" , 0 ) ; bin -> nlibs ++ ; if ( ! parse_dylib ( bin , off ) ) { bprintf ( "Cannot parse dylib\\n" ) ; bin -> nlibs -- ; return false ; } break ; case LC_DYLD_INFO : case LC_DYLD_INFO_ONLY : { ut8 dyldi [ sizeof ( struct dyld_info_command ) ] = { 0 } ; sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "dyld_info" , 0 ) ; <vul-start> bin -> dyld_info = malloc ( sizeof ( struct dyld_info_command ) ) ; <vul-end> if ( off + sizeof ( struct dyld_info_command ) > bin -> size ) { bprintf ( "Cannot parse dyldinfo\\n" ) ; <vul-start> free ( bin -> dyld_info ) ; <vul-end> return false ; } if ( r_buf_read_at ( bin -> b , off , dyldi , sizeof ( struct dyld_info_command ) ) == - 1 ) { free ( bin -> dyld_info ) ; bin -> dyld_info = NULL ; bprintf ( "Error: read (LC_DYLD_INFO) at 0x%08" PFMT64x "\\n" , off ) ; } else { bin -> dyld_info -> cmd = r_read_ble32 ( & dyldi [ 0 ] , bin -> big_endian ) ; bin -> dyld_info -> cmdsize = r_read_ble32 ( & dyldi [ 4 ] , bin -> big_endian ) ; bin -> dyld_info -> rebase_off = r_read_ble32 ( & dyldi [ 8 ] , bin -> big_endian ) ; bin -> dyld_info -> rebase_size = r_read_ble32 ( & dyldi [ 12 ] , bin -> big_endian ) ; bin -> dyld_info -> bind_off = r_read_ble32 ( & dyldi [ 16 ] , bin -> big_endian ) ; bin -> dyld_info -> bind_size = r_read_ble32 ( & dyldi [ 20 ] , bin -> big_endian ) ; bin -> dyld_info -> weak_bind_off = r_read_ble32 ( & dyldi [ 24 ] , bin -> big_endian ) ; bin -> dyld_info -> weak_bind_size = r_read_ble32 ( & dyldi [ 28 ] , bin -> big_endian ) ; bin -> dyld_info -> lazy_bind_off = r_read_ble32 ( & dyldi [ 32 ] , bin -> big_endian ) ; bin -> dyld_info -> lazy_bind_size = r_read_ble32 ( & dyldi [ 36 ] , bin -> big_endian ) ; bin -> dyld_info -> export_off = r_read_ble32 ( & dyldi [ 40 ] , bin -> big_endian ) ; bin -> dyld_info -> export_size = r_read_ble32 ( & dyldi [ 44 ] , bin -> big_endian ) ; } } <vul-start> <vul-end> break ; case LC_CODE_SIGNATURE : parse_signature ( bin , off ) ; sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "signature" , 0 ) ; break ; case LC_SOURCE_VERSION : sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "version" , 0 ) ; break ; case LC_SEGMENT_SPLIT_INFO : sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "split_info" , 0 ) ; break ; case LC_FUNCTION_STARTS : sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "function_starts" , 0 ) ; if ( ! parse_function_starts ( bin , off ) ) { bprintf ( "Cannot parse LC_FUNCTION_STARTS\\n" ) ; } break ; case LC_REEXPORT_DYLIB : sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "dylib" , 0 ) ; break ; default : break ; } } return true ; }
|
<vul-sep> sdb_set ( bin -> kv , sdb_fmt ( 0 , "mach0_cmd_%d.cmd" , i ) , "dyld_info" , 0 ) ; <vul-start> bin -> dyld_info = calloc ( 1 , sizeof ( struct dyld_info_command ) ) ; if ( bin -> dyld_info ) { <vul-end><vul-sep> bprintf ( "Cannot parse dyldinfo\\n" ) ; <vul-start> R_FREE ( bin -> dyld_info ) ; <vul-end><vul-sep> } <vul-start> } <vul-end><vul-sep>
|
39
|
CWE-20 static int _snd_timer_stop ( struct snd_timer_instance * timeri , int keep_flag , int event ) { struct snd_timer * timer ; unsigned long flags ; if ( snd_BUG_ON ( ! timeri ) ) return - ENXIO ; if ( timeri -> flags & SNDRV_TIMER_IFLG_SLAVE ) { if ( ! keep_flag ) { spin_lock_irqsave ( & slave_active_lock , flags ) ; timeri -> flags &= ~ SNDRV_TIMER_IFLG_RUNNING ; <vul-start> <vul-end> spin_unlock_irqrestore ( & slave_active_lock , flags ) ; } goto __end ; } timer = timeri -> timer ; if ( ! timer ) return - EINVAL ; spin_lock_irqsave ( & timer -> lock , flags ) ; list_del_init ( & timeri -> ack_list ) ; list_del_init ( & timeri -> active_list ) ; if ( ( timeri -> flags & SNDRV_TIMER_IFLG_RUNNING ) && ! ( -- timer -> running ) ) { timer -> hw . stop ( timer ) ; if ( timer -> flags & SNDRV_TIMER_FLG_RESCHED ) { timer -> flags &= ~ SNDRV_TIMER_FLG_RESCHED ; snd_timer_reschedule ( timer , 0 ) ; if ( timer -> flags & SNDRV_TIMER_FLG_CHANGE ) { timer -> flags &= ~ SNDRV_TIMER_FLG_CHANGE ; timer -> hw . start ( timer ) ; } } } if ( ! keep_flag ) timeri -> flags &= ~ ( SNDRV_TIMER_IFLG_RUNNING | SNDRV_TIMER_IFLG_START ) ; spin_unlock_irqrestore ( & timer -> lock , flags ) ; __end : if ( event != SNDRV_TIMER_EVENT_RESOLUTION ) snd_timer_notify1 ( timeri , event ) ; return 0 ; }
|
<vul-sep> timeri -> flags &= ~ SNDRV_TIMER_IFLG_RUNNING ; <vul-start> list_del_init ( & timeri -> ack_list ) ; list_del_init ( & timeri -> active_list ) ; <vul-end><vul-sep>
|
40
|
CWE-120 static int mwifiex_update_vs_ie ( const u8 * ies , int ies_len , struct mwifiex_ie * * ie_ptr , u16 mask , unsigned int oui , u8 oui_type ) { struct ieee_types_header * vs_ie ; struct mwifiex_ie * ie = * ie_ptr ; const u8 * vendor_ie ; vendor_ie = cfg80211_find_vendor_ie ( oui , oui_type , ies , ies_len ) ; if ( vendor_ie ) { if ( ! * ie_ptr ) { * ie_ptr = kzalloc ( sizeof ( struct mwifiex_ie ) , GFP_KERNEL ) ; if ( ! * ie_ptr ) return - ENOMEM ; ie = * ie_ptr ; } vs_ie = ( struct ieee_types_header * ) vendor_ie ; <vul-start> <vul-end> memcpy ( ie -> ie_buffer + le16_to_cpu ( ie -> ie_length ) , vs_ie , vs_ie -> len + 2 ) ; le16_unaligned_add_cpu ( & ie -> ie_length , vs_ie -> len + 2 ) ; ie -> mgmt_subtype_mask = cpu_to_le16 ( mask ) ; ie -> ie_index = cpu_to_le16 ( MWIFIEX_AUTO_IDX_MASK ) ; } * ie_ptr = ie ; return 0 ; }
|
<vul-sep> vs_ie = ( struct ieee_types_header * ) vendor_ie ; <vul-start> if ( le16_to_cpu ( ie -> ie_length ) + vs_ie -> len + 2 > IEEE_MAX_IE_SIZE ) return - EINVAL ; <vul-end><vul-sep>
|
41
|
CWE-436 static gssize find_auth_end ( FlatpakProxyClient * client , Buffer * buffer ) { <vul-start> guchar * match ; int i ; if ( client -> auth_end_offset > 0 ) <vul-end> { <vul-start> gsize left = strlen ( AUTH_END_STRING ) - client -> auth_end_offset ; gsize to_match = MIN ( left , buffer -> pos ) ; if ( memcmp ( buffer -> data , & AUTH_END_STRING [ client -> auth_end_offset ] , to_match ) == 0 ) <vul-end> { <vul-start> client -> auth_end_offset += to_match ; if ( client -> auth_end_offset == strlen ( AUTH_END_STRING ) ) return to_match ; return - 1 ; <vul-end> } <vul-start> client -> auth_end_offset = - 1 ; } match = memmem ( buffer , buffer -> pos , AUTH_END_STRING , strlen ( AUTH_END_STRING ) ) ; if ( match != NULL ) return match - buffer -> data + strlen ( AUTH_END_STRING ) ; for ( i = MIN ( strlen ( AUTH_END_STRING ) - 1 , buffer -> pos ) ; i > 0 ; i -- ) <vul-end> { <vul-start> if ( memcmp ( buffer -> data + buffer -> pos - i , AUTH_END_STRING , i ) == 0 ) { client -> auth_end_offset = i ; break ; <vul-end> } } <vul-start> return - 1 ; <vul-end> }
|
<vul-sep> { <vul-start> goffset offset = 0 ; gsize original_size = client -> auth_buffer -> len ; g_byte_array_append ( client -> auth_buffer , buffer -> data , buffer -> pos ) ; while ( TRUE ) <vul-end><vul-sep> { <vul-start> guint8 * line_start = client -> auth_buffer -> data + offset ; gsize remaining_data = client -> auth_buffer -> len - offset ; guint8 * line_end ; line_end = memmem ( line_start , remaining_data , AUTH_LINE_SENTINEL , strlen ( AUTH_LINE_SENTINEL ) ) ; if ( line_end ) <vul-end><vul-sep> { <vul-start> offset = ( line_end + strlen ( AUTH_LINE_SENTINEL ) - line_start ) ; if ( ! auth_line_is_valid ( line_start , line_end ) ) return FIND_AUTH_END_ABORT ; * line_end = 0 ; if ( auth_line_is_begin ( line_start ) ) return offset - original_size ; <vul-end><vul-sep> } <vul-start> else <vul-end><vul-sep> { <vul-start> g_byte_array_remove_range ( client -> auth_buffer , 0 , offset ) ; if ( client -> auth_buffer -> len >= 16 * 1024 ) return FIND_AUTH_END_ABORT ; return FIND_AUTH_END_CONTINUE ; <vul-end><vul-sep> } <vul-start><vul-end><vul-sep>
|
42
|
CWE-399 static void perf_event_comm_output ( struct perf_event * event , struct perf_comm_event * comm_event ) { struct perf_output_handle handle ; struct perf_sample_data sample ; int size = comm_event -> event_id . header . size ; int ret ; perf_event_header__init_id ( & comm_event -> event_id . header , & sample , event ) ; ret = perf_output_begin ( & handle , event , <vul-start> comm_event -> event_id . header . size , 0 , 0 ) ; <vul-end> if ( ret ) goto out ; comm_event -> event_id . pid = perf_event_pid ( event , comm_event -> task ) ; comm_event -> event_id . tid = perf_event_tid ( event , comm_event -> task ) ; perf_output_put ( & handle , comm_event -> event_id ) ; __output_copy ( & handle , comm_event -> comm , comm_event -> comm_size ) ; perf_event__output_id_sample ( event , & handle , & sample ) ; perf_output_end ( & handle ) ; out : comm_event -> event_id . header . size = size ; }
|
<vul-sep> ret = perf_output_begin ( & handle , event , <vul-start> comm_event -> event_id . header . size , 0 ) ; <vul-end><vul-sep>
|
43
|
CWE-119 static vpx_codec_err_t parse_options ( SvcContext * svc_ctx , const char * options ) { char * input_string ; char * option_name ; char * option_value ; char * input_ptr ; <vul-start> int is_keyframe_qaunt_set = 0 ; <vul-end> vpx_codec_err_t res = VPX_CODEC_OK ; <vul-start> <vul-end> if ( options == NULL ) return VPX_CODEC_OK ; input_string = strdup ( options ) ; option_name = strtok_r ( input_string , "=" , & input_ptr ) ; while ( option_name != NULL ) { option_value = strtok_r ( NULL , " " , & input_ptr ) ; if ( option_value == NULL ) { svc_log ( svc_ctx , SVC_LOG_ERROR , "option missing value: %s\\n" , option_name ) ; res = VPX_CODEC_INVALID_PARAM ; break ; } <vul-start> if ( strcmp ( "encoding-mode" , option_name ) == 0 ) { res = set_option_encoding_mode ( svc_ctx , option_value ) ; <vul-end> if ( res != VPX_CODEC_OK ) break ; <vul-start> } else if ( strcmp ( "layers" , option_name ) == 0 ) { svc_ctx -> spatial_layers = atoi ( option_value ) ; } else if ( strcmp ( "scale-factors" , option_name ) == 0 ) { res = parse_scale_factors ( svc_ctx , option_value ) ; <vul-end> if ( res != VPX_CODEC_OK ) break ; <vul-start> } else if ( strcmp ( "quantizers" , option_name ) == 0 ) { res = parse_quantizer_values ( svc_ctx , option_value , 0 ) ; <vul-end> if ( res != VPX_CODEC_OK ) break ; <vul-start> if ( ! is_keyframe_qaunt_set ) { SvcInternal * const si = get_svc_internal ( svc_ctx ) ; memcpy ( get_svc_internal ( svc_ctx ) -> quantizer_keyframe , si -> quantizer , sizeof ( si -> quantizer ) ) ; } } else if ( strcmp ( "quantizers-keyframe" , option_name ) == 0 ) { res = parse_quantizer_values ( svc_ctx , option_value , 1 ) ; <vul-end> if ( res != VPX_CODEC_OK ) break ; <vul-start> is_keyframe_qaunt_set = 1 ; <vul-end> } else { svc_log ( svc_ctx , SVC_LOG_ERROR , "invalid option: %s\\n" , option_name ) ; res = VPX_CODEC_INVALID_PARAM ; break ; } option_name = strtok_r ( NULL , "=" , & input_ptr ) ; } free ( input_string ) ; <vul-start> <vul-end> return res ; }
|
<vul-sep> char * input_ptr ; <vul-start> SvcInternal_t * const si = get_svc_internal ( svc_ctx ) ; <vul-end><vul-sep> vpx_codec_err_t res = VPX_CODEC_OK ; <vul-start> int i , alt_ref_enabled = 0 ; <vul-end><vul-sep> } <vul-start> if ( strcmp ( "spatial-layers" , option_name ) == 0 ) { svc_ctx -> spatial_layers = atoi ( option_value ) ; } else if ( strcmp ( "temporal-layers" , option_name ) == 0 ) { svc_ctx -> temporal_layers = atoi ( option_value ) ; } else if ( strcmp ( "scale-factors" , option_name ) == 0 ) { res = parse_layer_options_from_string ( svc_ctx , SCALE_FACTOR , option_value , si -> svc_params . scaling_factor_num , si -> svc_params . scaling_factor_den ) ; <vul-end><vul-sep> if ( res != VPX_CODEC_OK ) break ; <vul-start> } else if ( strcmp ( "max-quantizers" , option_name ) == 0 ) { res = parse_layer_options_from_string ( svc_ctx , QUANTIZER , option_value , si -> svc_params . max_quantizers , NULL ) ; <vul-end><vul-sep> if ( res != VPX_CODEC_OK ) break ; <vul-start> } else if ( strcmp ( "min-quantizers" , option_name ) == 0 ) { res = parse_layer_options_from_string ( svc_ctx , QUANTIZER , option_value , si -> svc_params . min_quantizers , NULL ) ; <vul-end><vul-sep> if ( res != VPX_CODEC_OK ) break ; <vul-start> } else if ( strcmp ( "auto-alt-refs" , option_name ) == 0 ) { res = parse_layer_options_from_string ( svc_ctx , AUTO_ALT_REF , option_value , si -> enable_auto_alt_ref , NULL ) ; <vul-end><vul-sep> if ( res != VPX_CODEC_OK ) break ; <vul-start> } else if ( strcmp ( "bitrates" , option_name ) == 0 ) { res = parse_layer_options_from_string ( svc_ctx , BITRATE , option_value , si -> bitrates , NULL ) ; if ( res != VPX_CODEC_OK ) break ; } else if ( strcmp ( "multi-frame-contexts" , option_name ) == 0 ) { si -> use_multiple_frame_contexts = atoi ( option_value ) ; <vul-end><vul-sep> free ( input_string ) ; <vul-start> for ( i = 0 ; i < svc_ctx -> spatial_layers ; ++ i ) { if ( si -> svc_params . max_quantizers [ i ] > MAX_QUANTIZER || si -> svc_params . max_quantizers [ i ] < 0 || si -> svc_params . min_quantizers [ i ] > si -> svc_params . max_quantizers [ i ] || si -> svc_params . min_quantizers [ i ] < 0 ) res = VPX_CODEC_INVALID_PARAM ; } if ( si -> use_multiple_frame_contexts && ( svc_ctx -> spatial_layers > 3 || svc_ctx -> spatial_layers * svc_ctx -> temporal_layers > 4 ) ) res = VPX_CODEC_INVALID_PARAM ; for ( i = 0 ; i < svc_ctx -> spatial_layers ; ++ i ) alt_ref_enabled += si -> enable_auto_alt_ref [ i ] ; if ( alt_ref_enabled > REF_FRAMES - svc_ctx -> spatial_layers ) { svc_log ( svc_ctx , SVC_LOG_ERROR , "svc: auto alt ref: Maxinum %d(REF_FRAMES - layers) layers could" "enabled auto alt reference frame, but % layers are enabled\\n" , REF_FRAMES - svc_ctx -> spatial_layers , alt_ref_enabled ) ; res = VPX_CODEC_INVALID_PARAM ; } <vul-end><vul-sep>
|
44
|
CWE-476 static void i8042_stop ( struct serio * serio ) { struct i8042_port * port = serio -> port_data ; <vul-start> <vul-end> port -> exists = false ; <vul-start> <vul-end> synchronize_irq ( I8042_AUX_IRQ ) ; synchronize_irq ( I8042_KBD_IRQ ) ; <vul-start> port -> serio = NULL ; <vul-end> }
|
<vul-sep> struct i8042_port * port = serio -> port_data ; <vul-start> spin_lock_irq ( & i8042_lock ) ; <vul-end><vul-sep> port -> exists = false ; <vul-start> port -> serio = NULL ; spin_unlock_irq ( & i8042_lock ) ; <vul-end><vul-sep> synchronize_irq ( I8042_KBD_IRQ ) ; <vul-start><vul-end><vul-sep>
|
45
|
CWE-190 # endif # if ZEND_DEBUG zend_mm_change_huge_block_size ( heap , ptr , new_size , real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC ) ; # else zend_mm_change_huge_block_size ( heap , ptr , new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC ) ; # endif return ptr ; } } else { # if ZEND_MM_LIMIT if ( UNEXPECTED ( heap -> real_size + ( new_size - old_size ) > heap -> limit ) ) { if ( zend_mm_gc ( heap ) && heap -> real_size + ( new_size - old_size ) <= heap -> limit ) { } else if ( heap -> overflow == 0 ) { # if ZEND_DEBUG zend_mm_safe_error ( heap , "Allowed memory size of %zu bytes exhausted at %s:%d (tried to allocate %zu bytes)" , heap -> limit , __zend_filename , __zend_lineno , size ) ; # else zend_mm_safe_error ( heap , "Allowed memory size of %zu bytes exhausted (tried to allocate %zu bytes)" , heap -> limit , size ) ; # endif return NULL ; } } # endif if ( zend_mm_chunk_extend ( heap , ptr , old_size , new_size ) ) { # if ZEND_MM_STAT || ZEND_MM_LIMIT heap -> real_size += new_size - old_size ; # endif # if ZEND_MM_STAT heap -> real_peak = MAX ( heap -> real_peak , heap -> real_size ) ; heap -> size += new_size - old_size ; heap -> peak = MAX ( heap -> peak , heap -> size ) ; # endif # if ZEND_DEBUG zend_mm_change_huge_block_size ( heap , ptr , new_size , real_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC ) ; # else zend_mm_change_huge_block_size ( heap , ptr , new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC ) ; # endif return ptr ; } } } } else { zend_mm_chunk * chunk = ( zend_mm_chunk * ) ZEND_MM_ALIGNED_BASE ( ptr , ZEND_MM_CHUNK_SIZE ) ; int page_num = ( int ) ( page_offset / ZEND_MM_PAGE_SIZE ) ; zend_mm_page_info info = chunk -> map [ page_num ] ; # if ZEND_DEBUG size_t real_size = size ; size = ZEND_MM_ALIGNED_SIZE ( size ) + ZEND_MM_ALIGNED_SIZE ( sizeof ( zend_mm_debug_info ) ) ; # endif ZEND_MM_CHECK ( chunk -> heap == heap , "zend_mm_heap corrupted" ) ; if ( info & ZEND_MM_IS_SRUN ) { <vul-start> int old_bin_num , bin_num ; old_bin_num = ZEND_MM_SRUN_BIN_NUM ( info ) ; <vul-end> old_size = bin_data_size [ old_bin_num ] ; <vul-start> bin_num = ZEND_MM_SMALL_SIZE_TO_BIN ( size ) ; <vul-end> if ( old_bin_num == bin_num ) { # if ZEND_DEBUG dbg = zend_mm_get_debug_info ( heap , ptr ) ; dbg -> size = real_size ; dbg -> filename = __zend_filename ; dbg -> orig_filename = __zend_orig_filename ; dbg -> lineno = __zend_lineno ; dbg -> orig_lineno = __zend_orig_lineno ; # endif return ptr ; <vul-start> <vul-end> } } else { ZEND_MM_CHECK ( ZEND_MM_ALIGNED_OFFSET ( page_offset , ZEND_MM_PAGE_SIZE ) == 0 , "zend_mm_heap corrupted" ) ; old_size = ZEND_MM_LRUN_PAGES ( info ) * ZEND_MM_PAGE_SIZE ; if ( size > ZEND_MM_MAX_SMALL_SIZE && size <= ZEND_MM_MAX_LARGE_SIZE ) { new_size = ZEND_MM_ALIGNED_SIZE_EX ( size , ZEND_MM_PAGE_SIZE ) ; if ( new_size == old_size ) { # if ZEND_DEBUG dbg = zend_mm_get_debug_info ( heap , ptr ) ; dbg -> size = real_size ; dbg -> filename = __zend_filename ; dbg -> orig_filename = __zend_orig_filename ; dbg -> lineno = __zend_lineno ; dbg -> orig_lineno = __zend_orig_lineno ; # endif return ptr ; } else if ( new_size < old_size ) { int new_pages_count = ( int ) ( new_size / ZEND_MM_PAGE_SIZE ) ; int rest_pages_count = ( int ) ( ( old_size - new_size ) / ZEND_MM_PAGE_SIZE ) ; # if ZEND_MM_STAT heap -> size -= rest_pages_count * ZEND_MM_PAGE_SIZE ; # endif chunk -> map [ page_num ] = ZEND_MM_LRUN ( new_pages_count ) ; chunk -> free_pages += rest_pages_count ; zend_mm_bitset_reset_range ( chunk -> free_map , page_num + new_pages_count , rest_pages_count ) ; # if ZEND_DEBUG dbg = zend_mm_get_debug_info ( heap , ptr ) ; dbg -> size = real_size ; dbg -> filename = __zend_filename ; dbg -> orig_filename = __zend_orig_filename ; dbg -> lineno = __zend_lineno ; dbg -> orig_lineno = __zend_orig_lineno ; # endif return ptr ; } else { int new_pages_count = ( int ) ( new_size / ZEND_MM_PAGE_SIZE ) ; int old_pages_count = ( int ) ( old_size / ZEND_MM_PAGE_SIZE ) ; if ( page_num + new_pages_count <= ZEND_MM_PAGES && zend_mm_bitset_is_free_range ( chunk -> free_map , page_num + old_pages_count , new_pages_count - old_pages_count ) ) { # if ZEND_MM_STAT do { size_t size = heap -> size + ( new_size - old_size ) ; size_t peak = MAX ( heap -> peak , size ) ; heap -> size = size ; heap -> peak = peak ; } while ( 0 ) ; # endif chunk -> free_pages -= new_pages_count - old_pages_count ; zend_mm_bitset_set_range ( chunk -> free_map , page_num + old_pages_count , new_pages_count - old_pages_count ) ; chunk -> map [ page_num ] = ZEND_MM_LRUN ( new_pages_count ) ;
|
<vul-sep> if ( info & ZEND_MM_IS_SRUN ) { <vul-start> int old_bin_num = ZEND_MM_SRUN_BIN_NUM ( info ) ; <vul-end><vul-sep> old_size = bin_data_size [ old_bin_num ] ; <vul-start> if ( size <= ZEND_MM_MAX_SMALL_SIZE ) { int bin_num = ZEND_MM_SMALL_SIZE_TO_BIN ( size ) ; <vul-end><vul-sep> return ptr ; <vul-start> } <vul-end><vul-sep>
|
46
|
CWE-399 int cib_remote_perform_op ( cib_t * cib , const char * op , const char * host , const char * section , xmlNode * data , xmlNode * * output_data , int call_options , const char * name ) { int rc = pcmk_ok ; <vul-start> <vul-end> xmlNode * op_msg = NULL ; xmlNode * op_reply = NULL ; cib_remote_opaque_t * private = cib -> variant_opaque ; <vul-start> if ( sync_timer == NULL ) { sync_timer = calloc ( 1 , sizeof ( struct timer_rec_s ) ) ; } <vul-end> if ( cib -> state == cib_disconnected ) { return - ENOTCONN ; } if ( output_data != NULL ) { * output_data = NULL ; } if ( op == NULL ) { crm_err ( "No operation specified" ) ; return - EINVAL ; } cib -> call_id ++ ; if ( cib -> call_id < 1 ) { cib -> call_id = 1 ; } op_msg = cib_create_op ( cib -> call_id , private -> callback . token , op , host , section , data , call_options , NULL ) ; if ( op_msg == NULL ) { return - EPROTO ; } crm_trace ( "Sending %s message to CIB service" , op ) ; <vul-start> <vul-end> crm_send_remote_msg ( private -> command . session , op_msg , private -> command . encrypted ) ; <vul-start> <vul-end> free_xml ( op_msg ) ; if ( ( call_options & cib_discard_reply ) ) { crm_trace ( "Discarding reply" ) ; return pcmk_ok ; } else if ( ! ( call_options & cib_sync_call ) ) { return cib -> call_id ; } crm_trace ( "Waiting for a syncronous reply" ) ; <vul-start> if ( cib -> call_timeout > 0 ) { timer_expired = FALSE ; sync_timer -> call_id = cib -> call_id ; sync_timer -> timeout = cib -> call_timeout * 1000 ; sync_timer -> ref = g_timeout_add ( sync_timer -> timeout , cib_timeout_handler , sync_timer ) ; } while ( timer_expired == FALSE ) { <vul-end> int reply_id = - 1 ; int msg_id = cib -> call_id ; <vul-start> op_reply = crm_recv_remote_msg ( private -> command . session , private -> command . encrypted ) ; if ( op_reply == NULL ) { <vul-end> break ; } crm_element_value_int ( op_reply , F_CIB_CALLID , & reply_id ) ; <vul-start> CRM_CHECK ( reply_id > 0 , free_xml ( op_reply ) ; if ( sync_timer -> ref > 0 ) { g_source_remove ( sync_timer -> ref ) ; sync_timer -> ref = 0 ; } return - ENOMSG ) ; <vul-end> if ( reply_id == msg_id ) { break ; } else if ( reply_id < msg_id ) { crm_debug ( "Received old reply: %d (wanted %d)" , reply_id , msg_id ) ; crm_log_xml_trace ( op_reply , "Old reply" ) ; } else if ( ( reply_id - 10000 ) > msg_id ) { crm_debug ( "Received old reply: %d (wanted %d)" , reply_id , msg_id ) ; crm_log_xml_trace ( op_reply , "Old reply" ) ; } else { crm_err ( "Received a __future__ reply:" " %d (wanted %d)" , reply_id , msg_id ) ; } free_xml ( op_reply ) ; op_reply = NULL ; <vul-start> <vul-end> } <vul-start> if ( sync_timer -> ref > 0 ) { g_source_remove ( sync_timer -> ref ) ; sync_timer -> ref = 0 ; } if ( timer_expired ) { return - ETIME ; } if ( op_reply == NULL ) { <vul-end> crm_err ( "No reply message - empty" ) ; return - ENOMSG ; } crm_trace ( "Syncronous reply received" ) ; if ( crm_element_value_int ( op_reply , F_CIB_RC , & rc ) != 0 ) { rc = - EPROTO ; } if ( rc == - pcmk_err_diff_resync ) { rc = pcmk_ok ; } if ( rc == pcmk_ok || rc == - EPERM ) { crm_log_xml_debug ( op_reply , "passed" ) ; } else { crm_err ( "Call failed: %s" , pcmk_strerror ( rc ) ) ; crm_log_xml_warn ( op_reply , "failed" ) ; } if ( output_data == NULL ) { } else if ( ! ( call_options & cib_discard_reply ) ) { xmlNode * tmp = get_message_xml ( op_reply , F_CIB_CALLDATA ) ; if ( tmp == NULL ) { crm_trace ( "No output in reply to \\"%s\\" command %d" , op , cib -> call_id - 1 ) ; } else { * output_data = copy_xml ( tmp ) ; } } free_xml ( op_reply ) ; return rc ; }
|
<vul-sep> int rc = pcmk_ok ; <vul-start> int disconnected = 0 ; int remaining_time = 0 ; time_t start_time ; <vul-end><vul-sep> cib_remote_opaque_t * private = cib -> variant_opaque ; <vul-start><vul-end><vul-sep> crm_trace ( "Sending %s message to CIB service" , op ) ; <vul-start> if ( ! ( call_options & cib_sync_call ) ) { crm_send_remote_msg ( private -> callback . session , op_msg , private -> command . encrypted ) ; } else { <vul-end><vul-sep> crm_send_remote_msg ( private -> command . session , op_msg , private -> command . encrypted ) ; <vul-start> } <vul-end><vul-sep> crm_trace ( "Waiting for a syncronous reply" ) ; <vul-start> start_time = time ( NULL ) ; remaining_time = cib -> call_timeout ? cib -> call_timeout : 60 ; while ( remaining_time > 0 && ! disconnected ) { <vul-end><vul-sep> int msg_id = cib -> call_id ; <vul-start> crm_recv_remote_msg ( private -> command . session , & private -> command . recv_buf , private -> command . encrypted , remaining_time * 1000 , & disconnected ) ; op_reply = crm_parse_remote_buffer ( & private -> command . recv_buf ) ; if ( ! op_reply ) { <vul-end><vul-sep> crm_element_value_int ( op_reply , F_CIB_CALLID , & reply_id ) ; <vul-start><vul-end><vul-sep> op_reply = NULL ; <vul-start> remaining_time = time ( NULL ) - start_time ; <vul-end><vul-sep> } <vul-start> if ( disconnected ) { crm_err ( "Disconnected while waiting for reply." ) ; return - ENOTCONN ; } else if ( op_reply == NULL ) { <vul-end><vul-sep>
|
47
|
CWE-200 static void parse_cfg ( int flags , int argc , const char * * argv , cfg_t * cfg ) { <vul-start> <vul-end> int i ; memset ( cfg , 0 , sizeof ( cfg_t ) ) ; cfg -> debug_file = stderr ; for ( i = 0 ; i < argc ; i ++ ) { if ( strncmp ( argv [ i ] , "max_devices=" , 12 ) == 0 ) sscanf ( argv [ i ] , "max_devices=%u" , & cfg -> max_devs ) ; if ( strcmp ( argv [ i ] , "manual" ) == 0 ) cfg -> manual = 1 ; if ( strcmp ( argv [ i ] , "debug" ) == 0 ) cfg -> debug = 1 ; if ( strcmp ( argv [ i ] , "nouserok" ) == 0 ) cfg -> nouserok = 1 ; if ( strcmp ( argv [ i ] , "openasuser" ) == 0 ) cfg -> openasuser = 1 ; if ( strcmp ( argv [ i ] , "alwaysok" ) == 0 ) cfg -> alwaysok = 1 ; if ( strcmp ( argv [ i ] , "interactive" ) == 0 ) cfg -> interactive = 1 ; if ( strcmp ( argv [ i ] , "cue" ) == 0 ) cfg -> cue = 1 ; if ( strcmp ( argv [ i ] , "nodetect" ) == 0 ) cfg -> nodetect = 1 ; if ( strncmp ( argv [ i ] , "authfile=" , 9 ) == 0 ) cfg -> auth_file = argv [ i ] + 9 ; if ( strncmp ( argv [ i ] , "authpending_file=" , 17 ) == 0 ) cfg -> authpending_file = argv [ i ] + 17 ; if ( strncmp ( argv [ i ] , "origin=" , 7 ) == 0 ) cfg -> origin = argv [ i ] + 7 ; if ( strncmp ( argv [ i ] , "appid=" , 6 ) == 0 ) cfg -> appid = argv [ i ] + 6 ; if ( strncmp ( argv [ i ] , "prompt=" , 7 ) == 0 ) cfg -> prompt = argv [ i ] + 7 ; if ( strncmp ( argv [ i ] , "debug_file=" , 11 ) == 0 ) { const char * filename = argv [ i ] + 11 ; if ( strncmp ( filename , "stdout" , 6 ) == 0 ) { cfg -> debug_file = stdout ; } else if ( strncmp ( filename , "stderr" , 6 ) == 0 ) { cfg -> debug_file = stderr ; } else if ( strncmp ( filename , "syslog" , 6 ) == 0 ) { cfg -> debug_file = ( FILE * ) - 1 ; } else { <vul-start> struct stat st ; FILE * file ; if ( lstat ( filename , & st ) == 0 ) { if ( S_ISREG ( st . st_mode ) ) { file = fopen ( filename , "a" ) ; <vul-end> if ( file != NULL ) { cfg -> debug_file = file ; <vul-start> } <vul-end> } } } } } if ( cfg -> debug ) { D ( cfg -> debug_file , "called." ) ; D ( cfg -> debug_file , "flags %d argc %d" , flags , argc ) ; for ( i = 0 ; i < argc ; i ++ ) { D ( cfg -> debug_file , "argv[%d]=%s" , i , argv [ i ] ) ; } D ( cfg -> debug_file , "max_devices=%d" , cfg -> max_devs ) ; D ( cfg -> debug_file , "debug=%d" , cfg -> debug ) ; D ( cfg -> debug_file , "interactive=%d" , cfg -> interactive ) ; D ( cfg -> debug_file , "cue=%d" , cfg -> cue ) ; D ( cfg -> debug_file , "nodetect=%d" , cfg -> nodetect ) ; D ( cfg -> debug_file , "manual=%d" , cfg -> manual ) ; D ( cfg -> debug_file , "nouserok=%d" , cfg -> nouserok ) ; D ( cfg -> debug_file , "openasuser=%d" , cfg -> openasuser ) ; D ( cfg -> debug_file , "alwaysok=%d" , cfg -> alwaysok ) ; D ( cfg -> debug_file , "authfile=%s" , cfg -> auth_file ? cfg -> auth_file : "(null)" ) ; D ( cfg -> debug_file , "authpending_file=%s" , cfg -> authpending_file ? cfg -> authpending_file : "(null)" ) ; D ( cfg -> debug_file , "origin=%s" , cfg -> origin ? cfg -> origin : "(null)" ) ; D ( cfg -> debug_file , "appid=%s" , cfg -> appid ? cfg -> appid : "(null)" ) ; D ( cfg -> debug_file , "prompt=%s" , cfg -> prompt ? cfg -> prompt : "(null)" ) ; } <vul-start> <vul-end> }
|
<vul-sep> static void parse_cfg ( int flags , int argc , const char * * argv , cfg_t * cfg ) { <vul-start> struct stat st ; FILE * file = NULL ; int fd = - 1 ; <vul-end><vul-sep> else { <vul-start> fd = open ( filename , O_WRONLY | O_APPEND | O_CLOEXEC | O_NOFOLLOW | O_NOCTTY ) ; if ( fd >= 0 && ( fstat ( fd , & st ) == 0 ) && S_ISREG ( st . st_mode ) ) { file = fdopen ( fd , "a" ) ; <vul-end><vul-sep> cfg -> debug_file = file ; <vul-start> cfg -> is_custom_debug_file = 1 ; file = NULL ; fd = - 1 ; <vul-end><vul-sep> } <vul-start> if ( fd != - 1 ) close ( fd ) ; if ( file != NULL ) fclose ( file ) ; <vul-end><vul-sep>
|
48
|
CWE-119 <vul-start> static MB_PREDICTION_MODE read_intra_mode_uv ( VP9_COMMON * cm , vp9_reader * r , MB_PREDICTION_MODE y_mode ) { const MB_PREDICTION_MODE uv_mode = read_intra_mode ( r , cm -> fc . uv_mode_prob [ y_mode ] ) ; if ( ! cm -> frame_parallel_decoding_mode ) ++ cm -> counts . uv_mode [ y_mode ] [ uv_mode ] ; <vul-end> return uv_mode ; }
|
<vul-sep> <vul-start>static PREDICTION_MODE read_intra_mode_uv ( VP9_COMMON * cm , MACROBLOCKD * xd , vpx_reader * r , PREDICTION_MODE y_mode ) { const PREDICTION_MODE uv_mode = read_intra_mode ( r , cm -> fc -> uv_mode_prob [ y_mode ] ) ; FRAME_COUNTS * counts = xd -> counts ; if ( counts ) ++ counts -> uv_mode [ y_mode ] [ uv_mode ] ; <vul-end><vul-sep>
|
49
|
CWE-119 static __u8 * sp_report_fixup ( struct hid_device * hdev , __u8 * rdesc , unsigned int * rsize ) { <vul-start> if ( * rsize >= 107 && rdesc [ 104 ] == 0x26 && rdesc [ 105 ] == 0x80 && <vul-end> rdesc [ 106 ] == 0x03 ) { hid_info ( hdev , "fixing up Sunplus Wireless Desktop report descriptor\\n" ) ; rdesc [ 105 ] = rdesc [ 110 ] = 0x03 ; rdesc [ 106 ] = rdesc [ 111 ] = 0x21 ; } return rdesc ; }
|
<vul-sep> { <vul-start> if ( * rsize >= 112 && rdesc [ 104 ] == 0x26 && rdesc [ 105 ] == 0x80 && <vul-end><vul-sep>
|
50
|
CWE-401 struct sk_buff * ack_skb ; struct { struct i2400m_l3l4_hdr hdr ; struct i2400m_tlv_rf_operation sw_rf ; } __packed * cmd ; char strerr [ 32 ] ; d_fnstart ( 4 , dev , "(wimax_dev %p state %d)\\n" , wimax_dev , state ) ; result = - ENOMEM ; cmd = kzalloc ( sizeof ( * cmd ) , GFP_KERNEL ) ; if ( cmd == NULL ) goto error_alloc ; cmd -> hdr . type = cpu_to_le16 ( I2400M_MT_CMD_RF_CONTROL ) ; cmd -> hdr . length = sizeof ( cmd -> sw_rf ) ; cmd -> hdr . version = cpu_to_le16 ( I2400M_L3L4_VERSION ) ; cmd -> sw_rf . hdr . type = cpu_to_le16 ( I2400M_TLV_RF_OPERATION ) ; cmd -> sw_rf . hdr . length = cpu_to_le16 ( sizeof ( cmd -> sw_rf . status ) ) ; switch ( state ) { case WIMAX_RF_OFF : cmd -> sw_rf . status = cpu_to_le32 ( 2 ) ; break ; case WIMAX_RF_ON : cmd -> sw_rf . status = cpu_to_le32 ( 1 ) ; break ; default : BUG ( ) ; } ack_skb = i2400m_msg_to_dev ( i2400m , cmd , sizeof ( * cmd ) ) ; result = PTR_ERR ( ack_skb ) ; if ( IS_ERR ( ack_skb ) ) { dev_err ( dev , "Failed to issue \'RF Control\' command: %d\\n" , result ) ; goto error_msg_to_dev ; } result = i2400m_msg_check_status ( wimax_msg_data ( ack_skb ) , strerr , sizeof ( strerr ) ) ; if ( result < 0 ) { dev_err ( dev , "\'RF Control\' (0x%04x) command failed: %d - %s\\n" , I2400M_MT_CMD_RF_CONTROL , result , strerr ) ; goto error_cmd ; } result = wait_event_timeout ( i2400m -> state_wq , i2400m_radio_is ( i2400m , state ) , 5 * HZ ) ; if ( result == 0 ) result = - ETIMEDOUT ; if ( result < 0 ) dev_err ( dev , "Error waiting for device to toggle RF state: " "%d\\n" , result ) ; result = 0 ; error_cmd : <vul-start> kfree ( cmd ) ; <vul-end> kfree_skb ( ack_skb ) ; error_msg_to_dev : error_alloc : d_fnend ( 4 , dev , "(wimax_dev %p state %d) = %d\\n" , wimax_dev , state , result ) ; <vul-start> <vul-end> return result ; }
|
<vul-sep> error_cmd : <vul-start><vul-end><vul-sep> wimax_dev , state , result ) ; <vul-start> kfree ( cmd ) ; <vul-end><vul-sep>
|
51
|
CWE-264 static int perf_event_read_group ( struct perf_event * event , u64 read_format , char __user * buf ) { struct perf_event * leader = event -> group_leader , * sub ; <vul-start> int n = 0 , size = 0 , ret = - EFAULT ; <vul-end> struct perf_event_context * ctx = leader -> ctx ; <vul-start> <vul-end> u64 values [ 5 ] ; <vul-start> u64 count , enabled , running ; mutex_lock ( & ctx -> mutex ) ; <vul-end> count = perf_event_read_value ( leader , & enabled , & running ) ; values [ n ++ ] = 1 + leader -> nr_siblings ; if ( read_format & PERF_FORMAT_TOTAL_TIME_ENABLED ) values [ n ++ ] = enabled ; if ( read_format & PERF_FORMAT_TOTAL_TIME_RUNNING ) values [ n ++ ] = running ; values [ n ++ ] = count ; if ( read_format & PERF_FORMAT_ID ) values [ n ++ ] = primary_event_id ( leader ) ; size = n * sizeof ( u64 ) ; if ( copy_to_user ( buf , values , size ) ) <vul-start> goto unlock ; <vul-end> ret = size ; list_for_each_entry ( sub , & leader -> sibling_list , group_entry ) { n = 0 ; values [ n ++ ] = perf_event_read_value ( sub , & enabled , & running ) ; if ( read_format & PERF_FORMAT_ID ) values [ n ++ ] = primary_event_id ( sub ) ; size = n * sizeof ( u64 ) ; if ( copy_to_user ( buf + ret , values , size ) ) { <vul-start> ret = - EFAULT ; goto unlock ; <vul-end> } ret += size ; } <vul-start> unlock : mutex_unlock ( & ctx -> mutex ) ; <vul-end> return ret ; }
|
<vul-sep> struct perf_event * leader = event -> group_leader , * sub ; <vul-start><vul-end><vul-sep> struct perf_event_context * ctx = leader -> ctx ; <vul-start> int n = 0 , size = 0 , ret ; u64 count , enabled , running ; <vul-end><vul-sep> u64 values [ 5 ] ; <vul-start> lockdep_assert_held ( & ctx -> mutex ) ; <vul-end><vul-sep> if ( copy_to_user ( buf , values , size ) ) <vul-start> return - EFAULT ; <vul-end><vul-sep> if ( copy_to_user ( buf + ret , values , size ) ) { <vul-start> return - EFAULT ; <vul-end><vul-sep> } <vul-start><vul-end><vul-sep>
|
52
|
CWE-284 bool config_save ( const config_t * config , const char * filename ) { assert ( config != NULL ) ; assert ( filename != NULL ) ; assert ( * filename != '\\0' ) ; <vul-start> char * temp_filename = osi_calloc ( strlen ( filename ) + 5 ) ; if ( ! temp_filename ) { LOG_ERROR ( "%s unable to allocate memory for filename." , __func__ ) ; return false ; <vul-end> } <vul-start> strcpy ( temp_filename , filename ) ; strcat ( temp_filename , ".new" ) ; FILE * fp = fopen ( temp_filename , "wt" ) ; <vul-end> if ( ! fp ) { LOG_ERROR ( "%s unable to write file \'%s\': %s" , __func__ , temp_filename , strerror ( errno ) ) ; goto error ; } for ( const list_node_t * node = list_begin ( config -> sections ) ; node != list_end ( config -> sections ) ; node = list_next ( node ) ) { const section_t * section = ( const section_t * ) list_node ( node ) ; <vul-start> fprintf ( fp , "[%s]\\n" , section -> name ) ; <vul-end> for ( const list_node_t * enode = list_begin ( section -> entries ) ; enode != list_end ( section -> entries ) ; enode = list_next ( enode ) ) { const entry_t * entry = ( const entry_t * ) list_node ( enode ) ; <vul-start> fprintf ( fp , "%s = %s\\n" , entry -> key , entry -> value ) ; <vul-end> } <vul-start> if ( list_next ( node ) != list_end ( config -> sections ) ) fputc ( '\\n' , fp ) ; <vul-end> } <vul-start> fflush ( fp ) ; fclose ( fp ) ; <vul-end> if ( chmod ( temp_filename , S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP ) == - 1 ) { LOG_ERROR ( "%s unable to change file permissions \'%s\': %s" , __func__ , filename , strerror ( errno ) ) ; goto error ; } if ( rename ( temp_filename , filename ) == - 1 ) { LOG_ERROR ( "%s unable to commit file \'%s\': %s" , __func__ , filename , strerror ( errno ) ) ; goto error ; } <vul-start> <vul-end> osi_free ( temp_filename ) ; <vul-start> <vul-end> return true ; <vul-start> error : ; <vul-end> unlink ( temp_filename ) ; <vul-start> <vul-end> osi_free ( temp_filename ) ; <vul-start> <vul-end> return false ; }
|
<vul-sep> assert ( * filename != '\\0' ) ; <vul-start> int dir_fd = - 1 ; FILE * fp = NULL ; static const char * temp_file_ext = ".new" ; const int filename_len = strlen ( filename ) ; const int temp_filename_len = filename_len + strlen ( temp_file_ext ) + 1 ; char * temp_filename = osi_calloc ( temp_filename_len ) ; snprintf ( temp_filename , temp_filename_len , "%s%s" , filename , temp_file_ext ) ; char * temp_dirname = osi_strdup ( filename ) ; const char * directoryname = dirname ( temp_dirname ) ; if ( ! directoryname ) { LOG_ERROR ( "%s error extracting directory from \'%s\': %s" , __func__ , filename , strerror ( errno ) ) ; goto error ; <vul-end><vul-sep> } <vul-start> dir_fd = TEMP_FAILURE_RETRY ( open ( directoryname , O_RDONLY ) ) ; if ( dir_fd < 0 ) { LOG_ERROR ( "%s unable to open dir \'%s\': %s" , __func__ , directoryname , strerror ( errno ) ) ; goto error ; } fp = fopen ( temp_filename , "wt" ) ; <vul-end><vul-sep> const section_t * section = ( const section_t * ) list_node ( node ) ; <vul-start> if ( fprintf ( fp , "[%s]\\n" , section -> name ) < 0 ) { LOG_ERROR ( "%s unable to write to file \'%s\': %s" , __func__ , temp_filename , strerror ( errno ) ) ; goto error ; } <vul-end><vul-sep> const entry_t * entry = ( const entry_t * ) list_node ( enode ) ; <vul-start> if ( fprintf ( fp , "%s = %s\\n" , entry -> key , entry -> value ) < 0 ) { LOG_ERROR ( "%s unable to write to file \'%s\': %s" , __func__ , temp_filename , strerror ( errno ) ) ; goto error ; <vul-end><vul-sep> } <vul-start><vul-end><vul-sep> } <vul-start> if ( list_next ( node ) != list_end ( config -> sections ) ) { if ( fputc ( '\\n' , fp ) == EOF ) { LOG_ERROR ( "%s unable to write to file \'%s\': %s" , __func__ , temp_filename , strerror ( errno ) ) ; goto error ; } } } if ( fsync ( fileno ( fp ) ) < 0 ) { LOG_WARN ( "%s unable to fsync file \'%s\': %s" , __func__ , temp_filename , strerror ( errno ) ) ; } if ( fclose ( fp ) == EOF ) { LOG_ERROR ( "%s unable to close file \'%s\': %s" , __func__ , temp_filename , strerror ( errno ) ) ; goto error ; } fp = NULL ; <vul-end><vul-sep> } <vul-start> if ( fsync ( dir_fd ) < 0 ) { LOG_WARN ( "%s unable to fsync dir \'%s\': %s" , __func__ , directoryname , strerror ( errno ) ) ; } if ( close ( dir_fd ) < 0 ) { LOG_ERROR ( "%s unable to close dir \'%s\': %s" , __func__ , directoryname , strerror ( errno ) ) ; goto error ; } <vul-end><vul-sep> osi_free ( temp_filename ) ; <vul-start> osi_free ( temp_dirname ) ; <vul-end><vul-sep> return true ; <vul-start> error : <vul-end><vul-sep> unlink ( temp_filename ) ; <vul-start> if ( fp ) fclose ( fp ) ; if ( dir_fd != - 1 ) close ( dir_fd ) ; <vul-end><vul-sep> osi_free ( temp_filename ) ; <vul-start> osi_free ( temp_dirname ) ; <vul-end><vul-sep>
|
53
|
CWE-20 error_t enc28j60UpdateMacAddrFilter ( NetInterface * interface ) { uint_t i ; uint_t k ; uint32_t crc ; uint8_t hashTable [ 8 ] ; MacFilterEntry * entry ; TRACE_DEBUG ( "Updating MAC filter...\\r\\n" ) ; osMemset ( hashTable , 0 , sizeof ( hashTable ) ) ; for ( i = 0 ; i < MAC_ADDR_FILTER_SIZE ; i ++ ) { entry = & interface -> macAddrFilter [ i ] ; if ( entry -> refCount > 0 ) { crc = enc28j60CalcCrc ( & entry -> addr , sizeof ( MacAddr ) ) ; k = ( crc >> 23 ) & 0x3F ; hashTable [ k / 8 ] |= ( 1 << ( k % 8 ) ) ; } } <vul-start> enc28j60WriteReg ( interface , ENC28J60_REG_EHT0 , hashTable [ 0 ] ) ; enc28j60WriteReg ( interface , ENC28J60_REG_EHT1 , hashTable [ 1 ] ) ; enc28j60WriteReg ( interface , ENC28J60_REG_EHT2 , hashTable [ 2 ] ) ; enc28j60WriteReg ( interface , ENC28J60_REG_EHT3 , hashTable [ 3 ] ) ; enc28j60WriteReg ( interface , ENC28J60_REG_EHT4 , hashTable [ 4 ] ) ; enc28j60WriteReg ( interface , ENC28J60_REG_EHT5 , hashTable [ 5 ] ) ; enc28j60WriteReg ( interface , ENC28J60_REG_EHT6 , hashTable [ 6 ] ) ; enc28j60WriteReg ( interface , ENC28J60_REG_EHT7 , hashTable [ 7 ] ) ; TRACE_DEBUG ( " EHT0 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_REG_EHT0 ) ) ; TRACE_DEBUG ( " EHT1 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_REG_EHT1 ) ) ; TRACE_DEBUG ( " EHT2 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_REG_EHT2 ) ) ; TRACE_DEBUG ( " EHT3 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_REG_EHT3 ) ) ; TRACE_DEBUG ( " EHT0 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_REG_EHT4 ) ) ; TRACE_DEBUG ( " EHT1 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_REG_EHT5 ) ) ; TRACE_DEBUG ( " EHT2 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_REG_EHT6 ) ) ; TRACE_DEBUG ( " EHT3 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_REG_EHT7 ) ) ; <vul-end> return NO_ERROR ; }
|
<vul-sep> } <vul-start> enc28j60WriteReg ( interface , ENC28J60_EHT0 , hashTable [ 0 ] ) ; enc28j60WriteReg ( interface , ENC28J60_EHT1 , hashTable [ 1 ] ) ; enc28j60WriteReg ( interface , ENC28J60_EHT2 , hashTable [ 2 ] ) ; enc28j60WriteReg ( interface , ENC28J60_EHT3 , hashTable [ 3 ] ) ; enc28j60WriteReg ( interface , ENC28J60_EHT4 , hashTable [ 4 ] ) ; enc28j60WriteReg ( interface , ENC28J60_EHT5 , hashTable [ 5 ] ) ; enc28j60WriteReg ( interface , ENC28J60_EHT6 , hashTable [ 6 ] ) ; enc28j60WriteReg ( interface , ENC28J60_EHT7 , hashTable [ 7 ] ) ; TRACE_DEBUG ( " EHT0 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_EHT0 ) ) ; TRACE_DEBUG ( " EHT1 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_EHT1 ) ) ; TRACE_DEBUG ( " EHT2 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_EHT2 ) ) ; TRACE_DEBUG ( " EHT3 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_EHT3 ) ) ; TRACE_DEBUG ( " EHT0 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_EHT4 ) ) ; TRACE_DEBUG ( " EHT1 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_EHT5 ) ) ; TRACE_DEBUG ( " EHT2 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_EHT6 ) ) ; TRACE_DEBUG ( " EHT3 = %02" PRIX8 "\\r\\n" , enc28j60ReadReg ( interface , ENC28J60_EHT7 ) ) ; <vul-end><vul-sep>
|
54
|
CWE-119 <vul-start> static void <vul-end> fpAcc ( TIFF * tif , uint8 * cp0 , tmsize_t cc ) { tmsize_t stride = PredictorState ( tif ) -> stride ; uint32 bps = tif -> tif_dir . td_bitspersample / 8 ; tmsize_t wc = cc / bps ; tmsize_t count = cc ; uint8 * cp = ( uint8 * ) cp0 ; uint8 * tmp = ( uint8 * ) _TIFFmalloc ( cc ) ; <vul-start> assert ( ( cc % ( bps * stride ) ) == 0 ) ; <vul-end> if ( ! tmp ) <vul-start> return ; <vul-end> while ( count > stride ) { REPEAT4 ( stride , cp [ stride ] = ( unsigned char ) ( ( cp [ stride ] + cp [ 0 ] ) & 0xff ) ; cp ++ ) count -= stride ; } _TIFFmemcpy ( tmp , cp0 , cc ) ; cp = ( uint8 * ) cp0 ; for ( count = 0 ; count < wc ; count ++ ) { uint32 byte ; for ( byte = 0 ; byte < bps ; byte ++ ) { # if WORDS_BIGENDIAN cp [ bps * count + byte ] = tmp [ byte * wc + count ] ; # else cp [ bps * count + byte ] = tmp [ ( bps - byte - 1 ) * wc + count ] ; # endif } } _TIFFfree ( tmp ) ; <vul-start> <vul-end> }
|
<vul-sep> <vul-start>static int <vul-end><vul-sep> uint8 * tmp = ( uint8 * ) _TIFFmalloc ( cc ) ; <vul-start> if ( cc % ( bps * stride ) != 0 ) { TIFFErrorExt ( tif -> tif_clientdata , "fpAcc" , "%s" , "cc%(bps*stride))!=0" ) ; return 0 ; } <vul-end><vul-sep> if ( ! tmp ) <vul-start> return 0 ; <vul-end><vul-sep> _TIFFfree ( tmp ) ; <vul-start> return 1 ; <vul-end><vul-sep>
|
55
|
CWE-119 for ( idx = 0 ; idx < ps_dec -> ps_cur_slice -> u1_num_ref_idx_lx_active [ 1 ] ; idx ++ ) { UWORD8 u1_tmp_idx = idx << 1 ; ps_pic = ps_dec -> ps_ref_pic_buf_lx [ 1 ] [ idx ] ; ppv_map_ref_idx_to_poc_lx_t [ u1_tmp_idx ] = ( ps_pic -> pu1_buf1 ) ; ppv_map_ref_idx_to_poc_lx_b [ u1_tmp_idx + 1 ] = ( ps_pic -> pu1_buf1 ) ; ppv_map_ref_idx_to_poc_lx_b [ u1_tmp_idx ] = ( ps_pic -> pu1_buf1 ) + 1 ; ppv_map_ref_idx_to_poc_lx_t [ u1_tmp_idx + 1 ] = ( ps_pic -> pu1_buf1 ) + 1 ; } } if ( ps_dec -> u4_num_cores >= 3 ) { WORD32 num_entries ; WORD32 size ; num_entries = MIN ( MAX_FRAMES , ps_dec -> u4_num_ref_frames_at_init ) ; num_entries = 2 * ( ( 2 * num_entries ) + 1 ) ; size = num_entries * sizeof ( void * ) ; size += PAD_MAP_IDX_POC * sizeof ( void * ) ; memcpy ( ( void * ) ps_dec -> ps_parse_cur_slice -> ppv_map_ref_idx_to_poc , ps_dec -> ppv_map_ref_idx_to_poc , size ) ; } } if ( ps_dec -> ps_cur_slice -> u1_mbaff_frame_flag && ( ps_dec -> ps_cur_slice -> u1_field_pic_flag == 0 ) ) { ih264d_convert_frm_mbaff_list ( ps_dec ) ; } if ( ps_pps -> u1_wted_bipred_idc == 1 ) { ret = ih264d_parse_pred_weight_table ( ps_slice , ps_bitstrm ) ; if ( ret != OK ) return ret ; ih264d_form_pred_weight_matrix ( ps_dec ) ; ps_dec -> pu4_wt_ofsts = ps_dec -> pu4_wts_ofsts_mat ; } else if ( ps_pps -> u1_wted_bipred_idc == 2 ) { ps_slice -> u2_log2Y_crwd = 0x0505 ; ps_dec -> pu4_wt_ofsts = ps_dec -> pu4_wts_ofsts_mat ; ih264d_get_implicit_weights ( ps_dec ) ; } else ps_dec -> ps_cur_slice -> u2_log2Y_crwd = 0 ; ps_dec -> ps_parse_cur_slice -> u2_log2Y_crwd = ps_dec -> ps_cur_slice -> u2_log2Y_crwd ; if ( ps_slice -> u1_nal_ref_idc != 0 ) { if ( ! ps_dec -> ps_dpb_cmds -> u1_dpb_commands_read ) <vul-start> ps_dec -> u4_bitoffset = ih264d_read_mmco_commands ( ps_dec ) ; <vul-end> else ps_bitstrm -> u4_ofst += ps_dec -> u4_bitoffset ; } if ( ps_pps -> u1_entropy_coding_mode == CABAC ) { u4_temp = ih264d_uev ( pu4_bitstrm_ofst , pu4_bitstrm_buf ) ; if ( u4_temp > MAX_CABAC_INIT_IDC ) { return ERROR_INV_SLICE_HDR_T ; } ps_slice -> u1_cabac_init_idc = u4_temp ; COPYTHECONTEXT ( "SH: cabac_init_idc" , ps_slice -> u1_cabac_init_idc ) ; } i_temp = ps_pps -> u1_pic_init_qp + ih264d_sev ( pu4_bitstrm_ofst , pu4_bitstrm_buf ) ; if ( ( i_temp < 0 ) || ( i_temp > 51 ) ) { return ERROR_INV_RANGE_QP_T ; } ps_slice -> u1_slice_qp = i_temp ; COPYTHECONTEXT ( "SH: slice_qp_delta" , ( WORD8 ) ( ps_slice -> u1_slice_qp - ps_pps -> u1_pic_init_qp ) ) ; if ( ps_pps -> u1_deblocking_filter_parameters_present_flag == 1 ) { u4_temp = ih264d_uev ( pu4_bitstrm_ofst , pu4_bitstrm_buf ) ; if ( u4_temp > SLICE_BOUNDARY_DBLK_DISABLED ) { return ERROR_INV_SLICE_HDR_T ; } COPYTHECONTEXT ( "SH: disable_deblocking_filter_idc" , u4_temp ) ; ps_slice -> u1_disable_dblk_filter_idc = u4_temp ; if ( u4_temp != 1 ) { i_temp = ih264d_sev ( pu4_bitstrm_ofst , pu4_bitstrm_buf ) << 1 ; if ( ( MIN_DBLK_FIL_OFF > i_temp ) || ( i_temp > MAX_DBLK_FIL_OFF ) ) { return ERROR_INV_SLICE_HDR_T ; } ps_slice -> i1_slice_alpha_c0_offset = i_temp ; COPYTHECONTEXT ( "SH: slice_alpha_c0_offset_div2" , ps_slice -> i1_slice_alpha_c0_offset >> 1 ) ; i_temp = ih264d_sev ( pu4_bitstrm_ofst , pu4_bitstrm_buf ) << 1 ; if ( ( MIN_DBLK_FIL_OFF > i_temp ) || ( i_temp > MAX_DBLK_FIL_OFF ) ) { return ERROR_INV_SLICE_HDR_T ; } ps_slice -> i1_slice_beta_offset = i_temp ; COPYTHECONTEXT ( "SH: slice_beta_offset_div2" , ps_slice -> i1_slice_beta_offset >> 1 ) ;
|
<vul-sep> if ( ! ps_dec -> ps_dpb_cmds -> u1_dpb_commands_read ) <vul-start> { i_temp = ih264d_read_mmco_commands ( ps_dec ) ; if ( i_temp < 0 ) { return ERROR_DBP_MANAGER_T ; } ps_dec -> u4_bitoffset = i_temp ; } <vul-end><vul-sep>
|
56
|
CWE-295 void log_flush ( LOG_MODE new_mode ) { CRYPTO_THREAD_write_lock ( stunnel_locks [ LOCK_LOG_MODE ] ) ; <vul-start> if ( log_mode != LOG_MODE_CONFIGURED || new_mode != LOG_MODE_ERROR ) <vul-end> log_mode = new_mode ; if ( new_mode != LOG_MODE_BUFFER ) { CRYPTO_THREAD_write_lock ( stunnel_locks [ LOCK_LOG_BUFFER ] ) ; while ( head ) { struct LIST * tmp = head ; head = head -> next ; log_raw ( tmp -> opt , tmp -> level , tmp -> stamp , tmp -> id , tmp -> text ) ; str_free ( tmp ) ; } head = tail = NULL ; CRYPTO_THREAD_unlock ( stunnel_locks [ LOCK_LOG_BUFFER ] ) ; } CRYPTO_THREAD_unlock ( stunnel_locks [ LOCK_LOG_MODE ] ) ; }
|
<vul-sep> CRYPTO_THREAD_write_lock ( stunnel_locks [ LOCK_LOG_MODE ] ) ; <vul-start><vul-end><vul-sep>
|
57
|
CWE-119 static void tokenadd ( struct jv_parser * p , char c ) { assert ( p -> tokenpos <= p -> tokenlen ) ; <vul-start> if ( p -> tokenpos == p -> tokenlen ) { <vul-end> p -> tokenlen = p -> tokenlen * 2 + 256 ; p -> tokenbuf = jv_mem_realloc ( p -> tokenbuf , p -> tokenlen ) ; } assert ( p -> tokenpos < p -> tokenlen ) ; p -> tokenbuf [ p -> tokenpos ++ ] = c ; }
|
<vul-sep> assert ( p -> tokenpos <= p -> tokenlen ) ; <vul-start> if ( p -> tokenpos >= ( p -> tokenlen - 1 ) ) { <vul-end><vul-sep>
|
58
|
CWE-125 static void ttm_put_pages ( struct page * * pages , unsigned npages , int flags , enum ttm_caching_state cstate ) { struct ttm_page_pool * pool = ttm_get_pool ( flags , false , cstate ) ; # ifdef CONFIG_TRANSPARENT_HUGEPAGE struct ttm_page_pool * huge = ttm_get_pool ( flags , true , cstate ) ; # endif unsigned long irq_flags ; unsigned i ; if ( pool == NULL ) { i = 0 ; while ( i < npages ) { # ifdef CONFIG_TRANSPARENT_HUGEPAGE struct page * p = pages [ i ] ; # endif unsigned order = 0 , j ; if ( ! pages [ i ] ) { ++ i ; continue ; } # ifdef CONFIG_TRANSPARENT_HUGEPAGE if ( ! ( flags & TTM_PAGE_FLAG_DMA32 ) && ( npages - i ) >= HPAGE_PMD_NR ) { for ( j = 1 ; j < HPAGE_PMD_NR ; ++ j ) <vul-start> if ( p ++ != pages [ i + j ] ) <vul-end> break ; if ( j == HPAGE_PMD_NR ) order = HPAGE_PMD_ORDER ; } # endif if ( page_count ( pages [ i ] ) != 1 ) pr_err ( "Erroneous page count. Leaking pages.\\n" ) ; __free_pages ( pages [ i ] , order ) ; j = 1 << order ; while ( j ) { pages [ i ++ ] = NULL ; -- j ; } } return ; } i = 0 ; # ifdef CONFIG_TRANSPARENT_HUGEPAGE if ( huge ) { unsigned max_size , n2free ; spin_lock_irqsave ( & huge -> lock , irq_flags ) ; while ( ( npages - i ) >= HPAGE_PMD_NR ) { struct page * p = pages [ i ] ; unsigned j ; if ( ! p ) break ; for ( j = 1 ; j < HPAGE_PMD_NR ; ++ j ) <vul-start> if ( p ++ != pages [ i + j ] ) <vul-end> break ; if ( j != HPAGE_PMD_NR ) break ; list_add_tail ( & pages [ i ] -> lru , & huge -> list ) ; for ( j = 0 ; j < HPAGE_PMD_NR ; ++ j ) pages [ i ++ ] = NULL ; huge -> npages ++ ; } max_size = _manager -> options . max_size ; max_size /= HPAGE_PMD_NR ; if ( huge -> npages > max_size ) n2free = huge -> npages - max_size ; else n2free = 0 ; spin_unlock_irqrestore ( & huge -> lock , irq_flags ) ; if ( n2free ) ttm_page_pool_free ( huge , n2free , false ) ; } # endif spin_lock_irqsave ( & pool -> lock , irq_flags ) ; while ( i < npages ) { if ( pages [ i ] ) { if ( page_count ( pages [ i ] ) != 1 ) pr_err ( "Erroneous page count. Leaking pages.\\n" ) ; list_add_tail ( & pages [ i ] -> lru , & pool -> list ) ; pages [ i ] = NULL ; pool -> npages ++ ; } ++ i ; } npages = 0 ; if ( pool -> npages > _manager -> options . max_size ) { npages = pool -> npages - _manager -> options . max_size ; if ( npages < NUM_PAGES_TO_ALLOC ) npages = NUM_PAGES_TO_ALLOC ; } spin_unlock_irqrestore ( & pool -> lock , irq_flags ) ; if ( npages ) ttm_page_pool_free ( pool , npages , false ) ; }
|
<vul-sep> for ( j = 1 ; j < HPAGE_PMD_NR ; ++ j ) <vul-start> if ( ++ p != pages [ i + j ] ) <vul-end><vul-sep> for ( j = 1 ; j < HPAGE_PMD_NR ; ++ j ) <vul-start> if ( ++ p != pages [ i + j ] ) <vul-end><vul-sep>
|
59
|
CWE-200 static int raptor_rdfxml_parse_start ( raptor_parser * rdf_parser ) { raptor_uri * uri = rdf_parser -> base_uri ; raptor_rdfxml_parser * rdf_xml_parser ; rdf_xml_parser = ( raptor_rdfxml_parser * ) rdf_parser -> context ; if ( ! uri ) return 1 ; raptor_sax2_set_option ( rdf_xml_parser -> sax2 , RAPTOR_OPTION_NORMALIZE_LANGUAGE , NULL , RAPTOR_OPTIONS_GET_NUMERIC ( rdf_parser , RAPTOR_OPTION_NORMALIZE_LANGUAGE ) ) ; raptor_sax2_set_option ( rdf_xml_parser -> sax2 , RAPTOR_OPTION_NO_NET , NULL , RAPTOR_OPTIONS_GET_NUMERIC ( rdf_parser , RAPTOR_OPTION_NO_NET ) ) ; raptor_sax2_set_option ( rdf_xml_parser -> sax2 , RAPTOR_OPTION_NO_FILE , NULL , RAPTOR_OPTIONS_GET_NUMERIC ( rdf_parser , RAPTOR_OPTION_NO_FILE ) ) ; <vul-start> <vul-end> if ( rdf_parser -> uri_filter ) raptor_sax2_set_uri_filter ( rdf_xml_parser -> sax2 , rdf_parser -> uri_filter , rdf_parser -> uri_filter_user_data ) ; raptor_sax2_parse_start ( rdf_xml_parser -> sax2 , uri ) ; if ( rdf_xml_parser -> id_set ) { raptor_free_id_set ( rdf_xml_parser -> id_set ) ; rdf_xml_parser -> id_set = NULL ; } if ( RAPTOR_OPTIONS_GET_NUMERIC ( rdf_parser , RAPTOR_OPTION_CHECK_RDF_ID ) ) { rdf_xml_parser -> id_set = raptor_new_id_set ( rdf_parser -> world ) ; if ( ! rdf_xml_parser -> id_set ) return 1 ; } return 0 ; }
|
<vul-sep> RAPTOR_OPTIONS_GET_NUMERIC ( rdf_parser , RAPTOR_OPTION_NO_FILE ) ) ; <vul-start> raptor_sax2_set_option ( rdf_xml_parser -> sax2 , RAPTOR_OPTION_LOAD_EXTERNAL_ENTITIES , NULL , RAPTOR_OPTIONS_GET_NUMERIC ( rdf_parser , RAPTOR_OPTION_LOAD_EXTERNAL_ENTITIES ) ) ; <vul-end><vul-sep>
|
60
|
CWE-401 static ssize_t sof_dfsentry_write ( struct file * file , const char __user * buffer , size_t count , loff_t * ppos ) { # if IS_ENABLED ( CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST ) struct snd_sof_dfsentry * dfse = file -> private_data ; struct snd_sof_dev * sdev = dfse -> sdev ; unsigned long ipc_duration_ms = 0 ; bool flood_duration_test = false ; unsigned long ipc_count = 0 ; struct dentry * dentry ; int err ; # endif size_t size ; char * string ; int ret ; string = kzalloc ( count , GFP_KERNEL ) ; if ( ! string ) return - ENOMEM ; size = simple_write_to_buffer ( string , count , ppos , buffer , count ) ; ret = size ; # if IS_ENABLED ( CONFIG_SND_SOC_SOF_DEBUG_IPC_FLOOD_TEST ) dentry = file -> f_path . dentry ; if ( strcmp ( dentry -> d_name . name , "ipc_flood_count" ) && <vul-start> strcmp ( dentry -> d_name . name , "ipc_flood_duration_ms" ) ) return - EINVAL ; <vul-end> if ( ! strcmp ( dentry -> d_name . name , "ipc_flood_duration_ms" ) ) flood_duration_test = true ; if ( flood_duration_test ) ret = kstrtoul ( string , 0 , & ipc_duration_ms ) ; else ret = kstrtoul ( string , 0 , & ipc_count ) ; if ( ret < 0 ) goto out ; if ( flood_duration_test ) { if ( ! ipc_duration_ms ) { ret = size ; goto out ; } if ( ipc_duration_ms > MAX_IPC_FLOOD_DURATION_MS ) ipc_duration_ms = MAX_IPC_FLOOD_DURATION_MS ; } else { if ( ! ipc_count ) { ret = size ; goto out ; } if ( ipc_count > MAX_IPC_FLOOD_COUNT ) ipc_count = MAX_IPC_FLOOD_COUNT ; } ret = pm_runtime_get_sync ( sdev -> dev ) ; if ( ret < 0 ) { dev_err_ratelimited ( sdev -> dev , "error: debugfs write failed to resume %d\\n" , ret ) ; pm_runtime_put_noidle ( sdev -> dev ) ; goto out ; } ret = sof_debug_ipc_flood_test ( sdev , dfse , flood_duration_test , ipc_duration_ms , ipc_count ) ; pm_runtime_mark_last_busy ( sdev -> dev ) ; err = pm_runtime_put_autosuspend ( sdev -> dev ) ; if ( err < 0 ) dev_err_ratelimited ( sdev -> dev , "error: debugfs write failed to idle %d\\n" , err ) ; if ( ret >= 0 ) ret = size ; out : # endif kfree ( string ) ; return ret ; }
|
<vul-sep> if ( strcmp ( dentry -> d_name . name , "ipc_flood_count" ) && <vul-start> strcmp ( dentry -> d_name . name , "ipc_flood_duration_ms" ) ) { ret = - EINVAL ; goto out ; } <vul-end><vul-sep>
|
61
|
CWE-772 generic_ret * delete_policy_2_svc ( dpol_arg * arg , struct svc_req * rqstp ) { static generic_ret ret ; char * prime_arg ; <vul-start> gss_buffer_desc client_name , service_name ; <vul-end> OM_uint32 minor_stat ; kadm5_server_handle_t handle ; const char * errmsg = NULL ; xdr_free ( xdr_generic_ret , & ret ) ; if ( ( ret . code = new_server_handle ( arg -> api_version , rqstp , & handle ) ) ) goto exit_func ; if ( ( ret . code = check_handle ( ( void * ) handle ) ) ) goto exit_func ; ret . api_version = handle -> api_version ; if ( setup_gss_names ( rqstp , & client_name , & service_name ) < 0 ) { ret . code = KADM5_FAILURE ; goto exit_func ; } prime_arg = arg -> name ; if ( CHANGEPW_SERVICE ( rqstp ) || ! kadm5int_acl_check ( handle -> context , rqst2name ( rqstp ) , ACL_DELETE , NULL , NULL ) ) { log_unauth ( "kadm5_delete_policy" , prime_arg , & client_name , & service_name , rqstp ) ; ret . code = KADM5_AUTH_DELETE ; } else { ret . code = kadm5_delete_policy ( ( void * ) handle , arg -> name ) ; if ( ret . code != 0 ) errmsg = krb5_get_error_message ( handle -> context , ret . code ) ; log_done ( "kadm5_delete_policy" , ( ( prime_arg == NULL ) ? "(null)" : prime_arg ) , errmsg , & client_name , & service_name , rqstp ) ; if ( errmsg != NULL ) krb5_free_error_message ( handle -> context , errmsg ) ; } <vul-start> <vul-end> gss_release_buffer ( & minor_stat , & client_name ) ; gss_release_buffer ( & minor_stat , & service_name ) ; <vul-start> exit_func : <vul-end> free_server_handle ( handle ) ; return & ret ; }
|
<vul-sep> char * prime_arg ; <vul-start> gss_buffer_desc client_name = GSS_C_EMPTY_BUFFER ; gss_buffer_desc service_name = GSS_C_EMPTY_BUFFER ; <vul-end><vul-sep> } <vul-start> exit_func : <vul-end><vul-sep> gss_release_buffer ( & minor_stat , & service_name ) ; <vul-start><vul-end><vul-sep>
|
62
|
CWE-59 static int get_default_root ( pool * p , int allow_symlinks , char * * root ) { config_rec * c = NULL ; char * dir = NULL ; int res ; c = find_config ( main_server -> conf , CONF_PARAM , "DefaultRoot" , FALSE ) ; while ( c ) { pr_signals_handle ( ) ; if ( c -> argc < 2 ) { dir = c -> argv [ 0 ] ; break ; } res = pr_expr_eval_group_and ( ( ( char * * ) c -> argv ) + 1 ) ; if ( res ) { dir = c -> argv [ 0 ] ; break ; } c = find_config_next ( c , c -> next , CONF_PARAM , "DefaultRoot" , FALSE ) ; } if ( dir ) { char * new_dir ; new_dir = path_subst_uservar ( p , & dir ) ; if ( new_dir != NULL ) { dir = new_dir ; } if ( strncmp ( dir , "/" , 2 ) == 0 ) { dir = NULL ; } else { char * realdir ; int xerrno = 0 ; if ( allow_symlinks == FALSE ) { char * path , target_path [ PR_TUNABLE_PATH_MAX + 1 ] ; <vul-start> struct stat st ; <vul-end> size_t pathlen ; path = dir ; if ( * path != '/' ) { if ( * path == '~' ) { if ( pr_fs_interpolate ( dir , target_path , sizeof ( target_path ) - 1 ) < 0 ) { return - 1 ; } path = target_path ; } } pathlen = strlen ( path ) ; if ( pathlen > 1 && path [ pathlen - 1 ] == '/' ) { path [ pathlen - 1 ] = '\\0' ; } <vul-start> pr_fs_clear_cache ( ) ; res = pr_fsio_lstat ( path , & st ) ; <vul-end> if ( res < 0 ) { <vul-start> xerrno = errno ; pr_log_pri ( PR_LOG_WARNING , "error: unable to check %s: %s" , path , strerror ( xerrno ) ) ; errno = xerrno ; return - 1 ; <vul-end> } <vul-start> if ( S_ISLNK ( st . st_mode ) ) { pr_log_pri ( PR_LOG_WARNING , "error: DefaultRoot %s is a symlink (denied by AllowChrootSymlinks " "config)" , path ) ; <vul-end> errno = EPERM ; return - 1 ; } } PRIVS_USER realdir = dir_realpath ( p , dir ) ; xerrno = errno ; PRIVS_RELINQUISH if ( realdir ) { dir = realdir ; } else { char interp_dir [ PR_TUNABLE_PATH_MAX + 1 ] ; memset ( interp_dir , '\\0' , sizeof ( interp_dir ) ) ; ( void ) pr_fs_interpolate ( dir , interp_dir , sizeof ( interp_dir ) - 1 ) ; pr_log_pri ( PR_LOG_NOTICE , "notice: unable to use DefaultRoot \'%s\' [resolved to \'%s\']: %s" , dir , interp_dir , strerror ( xerrno ) ) ; errno = xerrno ; } } } * root = dir ; return 0 ; }
|
<vul-sep> char * path , target_path [ PR_TUNABLE_PATH_MAX + 1 ] ; <vul-start><vul-end><vul-sep> } <vul-start> res = is_symlink_path ( p , path , pathlen ) ; <vul-end><vul-sep> if ( res < 0 ) { <vul-start> if ( errno == EPERM ) { pr_log_pri ( PR_LOG_WARNING , "error: DefaultRoot %s is a symlink " "(denied by AllowChrootSymlinks config)" , path ) ; <vul-end><vul-sep> } <vul-start><vul-end><vul-sep>
|
63
|
CWE-125 static wStream * rdg_receive_packet ( rdpRdg * rdg ) { wStream * s ; const size_t header = sizeof ( RdgPacketHeader ) ; size_t packetLength ; assert ( header <= INT_MAX ) ; s = Stream_New ( NULL , 1024 ) ; if ( ! s ) return NULL ; if ( ! rdg_read_all ( rdg -> tlsOut , Stream_Buffer ( s ) , header ) ) { Stream_Free ( s , TRUE ) ; return NULL ; } Stream_Seek ( s , 4 ) ; Stream_Read_UINT32 ( s , packetLength ) ; <vul-start> if ( ( packetLength > INT_MAX ) || ! Stream_EnsureCapacity ( s , packetLength ) ) <vul-end> { Stream_Free ( s , TRUE ) ; return NULL ; } if ( ! rdg_read_all ( rdg -> tlsOut , Stream_Buffer ( s ) + header , ( int ) packetLength - ( int ) header ) ) { Stream_Free ( s , TRUE ) ; return NULL ; } Stream_SetLength ( s , packetLength ) ; return s ; }
|
<vul-sep> Stream_Read_UINT32 ( s , packetLength ) ; <vul-start> if ( ( packetLength > INT_MAX ) || ! Stream_EnsureCapacity ( s , packetLength ) || ( packetLength < header ) ) <vul-end><vul-sep>
|
64
|
CWE-189 Image * AutoResizeImage ( const Image * image , const char * option , MagickOffsetType * count , ExceptionInfo * exception ) { # define MAX_SIZES 16 char * q ; const char * p ; Image * resized , * images ; register ssize_t i ; size_t sizes [ MAX_SIZES ] = { 256 , 192 , 128 , 96 , 64 , 48 , 40 , 32 , 24 , 16 } ; images = NULL ; * count = 0 ; i = 0 ; p = option ; while ( * p != '\\0' && i < MAX_SIZES ) { size_t size ; while ( ( isspace ( ( int ) ( ( unsigned char ) * p ) ) != 0 ) ) p ++ ; size = ( size_t ) strtol ( p , & q , 10 ) ; <vul-start> if ( p == q || size < 16 || size > 256 ) <vul-end> return ( ( Image * ) NULL ) ; p = q ; sizes [ i ++ ] = size ; while ( ( isspace ( ( int ) ( ( unsigned char ) * p ) ) != 0 ) || ( * p == ',' ) ) p ++ ; } if ( i == 0 ) i = 10 ; * count = i ; for ( i = 0 ; i < * count ; i ++ ) { resized = ResizeImage ( image , sizes [ i ] , sizes [ i ] , image -> filter , exception ) ; if ( resized == ( Image * ) NULL ) return ( DestroyImageList ( images ) ) ; if ( images == ( Image * ) NULL ) images = resized ; else AppendImageToList ( & images , resized ) ; } return ( images ) ; }
|
<vul-sep> size = ( size_t ) strtol ( p , & q , 10 ) ; <vul-start> if ( ( p == q ) || ( size < 16 ) || ( size > 256 ) ) <vul-end><vul-sep>
|
65
|
NVD-CWE-Other bool_t xdr_krb5_tl_data ( XDR * xdrs , krb5_tl_data * * tl_data_head ) { krb5_tl_data * tl , * tl2 ; bool_t more ; unsigned int len ; switch ( xdrs -> x_op ) { case XDR_FREE : tl = tl2 = * tl_data_head ; while ( tl ) { tl2 = tl -> tl_data_next ; free ( tl -> tl_data_contents ) ; free ( tl ) ; tl = tl2 ; } <vul-start> <vul-end> break ; case XDR_ENCODE : tl = * tl_data_head ; while ( 1 ) { more = ( tl != NULL ) ; if ( ! xdr_bool ( xdrs , & more ) ) return FALSE ; if ( tl == NULL ) break ; if ( ! xdr_krb5_int16 ( xdrs , & tl -> tl_data_type ) ) return FALSE ; len = tl -> tl_data_length ; if ( ! xdr_bytes ( xdrs , ( char * * ) & tl -> tl_data_contents , & len , ~ 0 ) ) return FALSE ; tl = tl -> tl_data_next ; } break ; case XDR_DECODE : tl = NULL ; while ( 1 ) { if ( ! xdr_bool ( xdrs , & more ) ) return FALSE ; if ( more == FALSE ) break ; tl2 = ( krb5_tl_data * ) malloc ( sizeof ( krb5_tl_data ) ) ; if ( tl2 == NULL ) return FALSE ; memset ( tl2 , 0 , sizeof ( krb5_tl_data ) ) ; if ( ! xdr_krb5_int16 ( xdrs , & tl2 -> tl_data_type ) ) return FALSE ; if ( ! xdr_bytes ( xdrs , ( char * * ) & tl2 -> tl_data_contents , & len , ~ 0 ) ) return FALSE ; tl2 -> tl_data_length = len ; tl2 -> tl_data_next = tl ; tl = tl2 ; } * tl_data_head = tl ; break ; } return TRUE ; }
|
<vul-sep> } <vul-start> * tl_data_head = NULL ; <vul-end><vul-sep>
|
66
|
CWE-264 static int futex_requeue ( u32 __user * uaddr1 , unsigned int flags , u32 __user * uaddr2 , int nr_wake , int nr_requeue , u32 * cmpval , int requeue_pi ) { union futex_key key1 = FUTEX_KEY_INIT , key2 = FUTEX_KEY_INIT ; int drop_count = 0 , task_count = 0 , ret ; struct futex_pi_state * pi_state = NULL ; struct futex_hash_bucket * hb1 , * hb2 ; struct futex_q * this , * next ; if ( requeue_pi ) { <vul-start> <vul-end> if ( refill_pi_state_cache ( ) ) return - ENOMEM ; if ( nr_wake != 1 ) return - EINVAL ; } retry : if ( pi_state != NULL ) { free_pi_state ( pi_state ) ; pi_state = NULL ; } ret = get_futex_key ( uaddr1 , flags & FLAGS_SHARED , & key1 , VERIFY_READ ) ; if ( unlikely ( ret != 0 ) ) goto out ; ret = get_futex_key ( uaddr2 , flags & FLAGS_SHARED , & key2 , requeue_pi ? VERIFY_WRITE : VERIFY_READ ) ; if ( unlikely ( ret != 0 ) ) goto out_put_key1 ; <vul-start> <vul-end> hb1 = hash_futex ( & key1 ) ; hb2 = hash_futex ( & key2 ) ; retry_private : hb_waiters_inc ( hb2 ) ; double_lock_hb ( hb1 , hb2 ) ; if ( likely ( cmpval != NULL ) ) { u32 curval ; ret = get_futex_value_locked ( & curval , uaddr1 ) ; if ( unlikely ( ret ) ) { double_unlock_hb ( hb1 , hb2 ) ; hb_waiters_dec ( hb2 ) ; ret = get_user ( curval , uaddr1 ) ; if ( ret ) goto out_put_keys ; if ( ! ( flags & FLAGS_SHARED ) ) goto retry_private ; put_futex_key ( & key2 ) ; put_futex_key ( & key1 ) ; goto retry ; } if ( curval != * cmpval ) { ret = - EAGAIN ; goto out_unlock ; } } if ( requeue_pi && ( task_count - nr_wake < nr_requeue ) ) { ret = futex_proxy_trylock_atomic ( uaddr2 , hb1 , hb2 , & key1 , & key2 , & pi_state , nr_requeue ) ; if ( ret > 0 ) { WARN_ON ( pi_state ) ; drop_count ++ ; task_count ++ ; ret = lookup_pi_state ( ret , hb2 , & key2 , & pi_state , NULL ) ; } switch ( ret ) { case 0 : break ; case - EFAULT : double_unlock_hb ( hb1 , hb2 ) ; hb_waiters_dec ( hb2 ) ; put_futex_key ( & key2 ) ; put_futex_key ( & key1 ) ; ret = fault_in_user_writeable ( uaddr2 ) ; if ( ! ret ) goto retry ; goto out ; case - EAGAIN : double_unlock_hb ( hb1 , hb2 ) ; hb_waiters_dec ( hb2 ) ; put_futex_key ( & key2 ) ;
|
<vul-sep> if ( requeue_pi ) { <vul-start> if ( uaddr1 == uaddr2 ) return - EINVAL ; <vul-end><vul-sep> goto out_put_key1 ; <vul-start> if ( requeue_pi && match_futex ( & key1 , & key2 ) ) { ret = - EINVAL ; goto out_put_keys ; } <vul-end><vul-sep>
|
67
|
CWE-119 int vp8_decode_frame ( VP8D_COMP * pbi ) { vp8_reader * const bc = & pbi -> mbc [ 8 ] ; VP8_COMMON * const pc = & pbi -> common ; MACROBLOCKD * const xd = & pbi -> mb ; const unsigned char * data = pbi -> fragments . ptrs [ 0 ] ; const unsigned char * data_end = data + pbi -> fragments . sizes [ 0 ] ; ptrdiff_t first_partition_length_in_bytes ; int i , j , k , l ; const int * const mb_feature_data_bits = vp8_mb_feature_data_bits ; int corrupt_tokens = 0 ; int prev_independent_partitions = pbi -> independent_partitions ; YV12_BUFFER_CONFIG * yv12_fb_new = pbi -> dec_fb_ref [ INTRA_FRAME ] ; xd -> corrupted = 0 ; yv12_fb_new -> corrupted = 0 ; if ( data_end - data < 3 ) { if ( ! pbi -> ec_active ) { vpx_internal_error ( & pc -> error , VPX_CODEC_CORRUPT_FRAME , "Truncated packet" ) ; } pc -> frame_type = INTER_FRAME ; pc -> version = 0 ; pc -> show_frame = 1 ; first_partition_length_in_bytes = 0 ; } else { unsigned char clear_buffer [ 10 ] ; const unsigned char * clear = data ; if ( pbi -> decrypt_cb ) { <vul-start> int n = ( int ) ( data_end - data ) ; if ( n > 10 ) n = 10 ; <vul-end> pbi -> decrypt_cb ( pbi -> decrypt_state , data , clear_buffer , n ) ; clear = clear_buffer ; } pc -> frame_type = ( FRAME_TYPE ) ( clear [ 0 ] & 1 ) ; pc -> version = ( clear [ 0 ] >> 1 ) & 7 ; pc -> show_frame = ( clear [ 0 ] >> 4 ) & 1 ; first_partition_length_in_bytes = ( clear [ 0 ] | ( clear [ 1 ] << 8 ) | ( clear [ 2 ] << 16 ) ) >> 5 ; if ( ! pbi -> ec_active && ( data + first_partition_length_in_bytes > data_end || data + first_partition_length_in_bytes < data ) ) vpx_internal_error ( & pc -> error , VPX_CODEC_CORRUPT_FRAME , "Truncated packet or corrupt partition 0 length" ) ; data += 3 ; clear += 3 ; vp8_setup_version ( pc ) ; if ( pc -> frame_type == KEY_FRAME ) { if ( ! pbi -> ec_active || data + 3 < data_end ) { if ( clear [ 0 ] != 0x9d || clear [ 1 ] != 0x01 || clear [ 2 ] != 0x2a ) vpx_internal_error ( & pc -> error , VPX_CODEC_UNSUP_BITSTREAM , "Invalid frame sync code" ) ; } if ( ! pbi -> ec_active || data + 6 < data_end ) { pc -> Width = ( clear [ 3 ] | ( clear [ 4 ] << 8 ) ) & 0x3fff ; pc -> horiz_scale = clear [ 4 ] >> 6 ; pc -> Height = ( clear [ 5 ] | ( clear [ 6 ] << 8 ) ) & 0x3fff ; pc -> vert_scale = clear [ 6 ] >> 6 ; } data += 7 ; <vul-start> clear += 7 ; } else { vpx_memcpy ( & xd -> pre , yv12_fb_new , sizeof ( YV12_BUFFER_CONFIG ) ) ; vpx_memcpy ( & xd -> dst , yv12_fb_new , sizeof ( YV12_BUFFER_CONFIG ) ) ; <vul-end> } } if ( ( ! pbi -> decoded_key_frame && pc -> frame_type != KEY_FRAME ) ) { return - 1 ; } init_frame ( pbi ) ; if ( vp8dx_start_decode ( bc , data , ( unsigned int ) ( data_end - data ) , pbi -> decrypt_cb , pbi -> decrypt_state ) ) vpx_internal_error ( & pc -> error , VPX_CODEC_MEM_ERROR , "Failed to allocate bool decoder 0" ) ; if ( pc -> frame_type == KEY_FRAME ) { ( void ) vp8_read_bit ( bc ) ; pc -> clamp_type = ( CLAMP_TYPE ) vp8_read_bit ( bc ) ; } xd -> segmentation_enabled = ( unsigned char ) vp8_read_bit ( bc ) ; if ( xd -> segmentation_enabled ) { xd -> update_mb_segmentation_map = ( unsigned char ) vp8_read_bit ( bc ) ; xd -> update_mb_segmentation_data = ( unsigned char ) vp8_read_bit ( bc ) ; if ( xd -> update_mb_segmentation_data ) { xd -> mb_segement_abs_delta = ( unsigned char ) vp8_read_bit ( bc ) ; <vul-start> vpx_memset ( xd -> segment_feature_data , 0 , sizeof ( xd -> segment_feature_data ) ) ; <vul-end> for ( i = 0 ; i < MB_LVL_MAX ; i ++ ) { for ( j = 0 ; j < MAX_MB_SEGMENTS ; j ++ ) { if ( vp8_read_bit ( bc ) ) { xd -> segment_feature_data [ i ] [ j ] = ( signed char ) vp8_read_literal ( bc , mb_feature_data_bits [ i ] ) ; if ( vp8_read_bit ( bc ) ) xd -> segment_feature_data [ i ] [ j ] = - xd -> segment_feature_data [ i ] [ j ] ; } else xd -> segment_feature_data [ i ] [ j ] = 0 ; } } } if ( xd -> update_mb_segmentation_map ) { <vul-start> vpx_memset ( xd -> mb_segment_tree_probs , 255 , sizeof ( xd -> mb_segment_tree_probs ) ) ; <vul-end> for ( i = 0 ; i < MB_FEATURE_TREE_PROBS ; i ++ ) { if ( vp8_read_bit ( bc ) ) xd -> mb_segment_tree_probs [ i ] = ( vp8_prob ) vp8_read_literal ( bc , 8 ) ; } } } else { xd -> update_mb_segmentation_map = 0 ; xd -> update_mb_segmentation_data = 0 ; } pc -> filter_type = ( LOOPFILTERTYPE ) vp8_read_bit ( bc ) ; pc -> filter_level = vp8_read_literal ( bc , 6 ) ; pc -> sharpness_level = vp8_read_literal ( bc , 3 ) ; xd -> mode_ref_lf_delta_update = 0 ; xd -> mode_ref_lf_delta_enabled = ( unsigned char ) vp8_read_bit ( bc ) ; if ( xd -> mode_ref_lf_delta_enabled ) { xd -> mode_ref_lf_delta_update = ( unsigned char ) vp8_read_bit ( bc ) ; if ( xd -> mode_ref_lf_delta_update ) { for ( i = 0 ; i < MAX_REF_LF_DELTAS ; i ++ ) { if ( vp8_read_bit ( bc ) ) { xd -> ref_lf_deltas [ i ] = ( signed char ) vp8_read_literal ( bc , 6 ) ; if ( vp8_read_bit ( bc ) ) xd -> ref_lf_deltas [ i ] = xd -> ref_lf_deltas [ i ] * - 1 ; } } for ( i = 0 ; i < MAX_MODE_LF_DELTAS ; i ++ ) { if ( vp8_read_bit ( bc ) ) { xd -> mode_lf_deltas [ i ] = ( signed char ) vp8_read_literal ( bc , 6 ) ; if ( vp8_read_bit ( bc ) ) xd -> mode_lf_deltas [ i ] = xd -> mode_lf_deltas [ i ] * - 1 ; } } } } setup_token_decoder ( pbi , data + first_partition_length_in_bytes ) ; xd -> current_bc = & pbi -> mbc [ 0 ] ; { int Q , q_update ; Q = vp8_read_literal ( bc , 7 ) ; pc -> base_qindex = Q ; q_update = 0 ; pc -> y1dc_delta_q = get_delta_q ( bc , pc -> y1dc_delta_q , & q_update ) ; pc -> y2dc_delta_q = get_delta_q ( bc , pc -> y2dc_delta_q , & q_update ) ; pc -> y2ac_delta_q = get_delta_q ( bc , pc -> y2ac_delta_q , & q_update ) ; pc -> uvdc_delta_q = get_delta_q ( bc , pc -> uvdc_delta_q , & q_update ) ; pc -> uvac_delta_q = get_delta_q ( bc , pc -> uvac_delta_q , & q_update ) ; if ( q_update ) vp8cx_init_de_quantizer ( pbi ) ; vp8_mb_init_dequantizer ( pbi , & pbi -> mb ) ; } if ( pc -> frame_type != KEY_FRAME ) { pc -> refresh_golden_frame = vp8_read_bit ( bc ) ; # if CONFIG_ERROR_CONCEALMENT xd -> corrupted |= vp8dx_bool_error ( bc ) ; if ( pbi -> ec_active && xd -> corrupted ) pc -> refresh_golden_frame = 0 ; # endif pc -> refresh_alt_ref_frame = vp8_read_bit ( bc ) ; # if CONFIG_ERROR_CONCEALMENT xd -> corrupted |= vp8dx_bool_error ( bc ) ; if ( pbi -> ec_active && xd -> corrupted ) pc -> refresh_alt_ref_frame = 0 ; # endif pc -> copy_buffer_to_gf = 0 ; if ( ! pc -> refresh_golden_frame ) pc -> copy_buffer_to_gf = vp8_read_literal ( bc , 2 ) ; # if CONFIG_ERROR_CONCEALMENT xd -> corrupted |= vp8dx_bool_error ( bc ) ; if ( pbi -> ec_active && xd -> corrupted ) pc -> copy_buffer_to_gf = 0 ; # endif pc -> copy_buffer_to_arf = 0 ; if ( ! pc -> refresh_alt_ref_frame ) pc -> copy_buffer_to_arf = vp8_read_literal ( bc , 2 ) ; # if CONFIG_ERROR_CONCEALMENT xd -> corrupted |= vp8dx_bool_error ( bc ) ; if ( pbi -> ec_active && xd -> corrupted ) pc -> copy_buffer_to_arf = 0 ; # endif pc -> ref_frame_sign_bias [ GOLDEN_FRAME ] = vp8_read_bit ( bc ) ; pc -> ref_frame_sign_bias [ ALTREF_FRAME ] = vp8_read_bit ( bc ) ; } pc -> refresh_entropy_probs = vp8_read_bit ( bc ) ; # if CONFIG_ERROR_CONCEALMENT xd -> corrupted |= vp8dx_bool_error ( bc ) ; if ( pbi -> ec_active && xd -> corrupted ) pc -> refresh_entropy_probs = 0 ; # endif if ( pc -> refresh_entropy_probs == 0 ) { <vul-start> vpx_memcpy ( & pc -> lfc , & pc -> fc , sizeof ( pc -> fc ) ) ; <vul-end> } pc -> refresh_last_frame = pc -> frame_type == KEY_FRAME || vp8_read_bit ( bc ) ; # if CONFIG_ERROR_CONCEALMENT xd -> corrupted |= vp8dx_bool_error ( bc ) ; if ( pbi -> ec_active && xd -> corrupted ) pc -> refresh_last_frame = 1 ; # endif if ( 0 ) { FILE * z = fopen ( "decodestats.stt" , "a" ) ; fprintf ( z , "%6d F:%d,G:%d,A:%d,L:%d,Q:%d\\n" , pc -> current_video_frame , pc -> frame_type , pc -> refresh_golden_frame , pc -> refresh_alt_ref_frame , pc -> refresh_last_frame , pc -> base_qindex ) ; fclose ( z ) ; } { pbi -> independent_partitions = 1 ; for ( i = 0 ; i < BLOCK_TYPES ; i ++ ) for ( j = 0 ; j < COEF_BANDS ; j ++ ) for ( k = 0 ; k < PREV_COEF_CONTEXTS ; k ++ ) for ( l = 0 ; l < ENTROPY_NODES ; l ++ ) { vp8_prob * const p = pc -> fc . coef_probs [ i ] [ j ] [ k ] + l ; if ( vp8_read ( bc , vp8_coef_update_probs [ i ] [ j ] [ k ] [ l ] ) ) { * p = ( vp8_prob ) vp8_read_literal ( bc , 8 ) ; } if ( k > 0 && * p != pc -> fc . coef_probs [ i ] [ j ] [ k - 1 ] [ l ] ) pbi -> independent_partitions = 0 ; } } <vul-start> vpx_memset ( xd -> qcoeff , 0 , sizeof ( xd -> qcoeff ) ) ; <vul-end> vp8_decode_mode_mvs ( pbi ) ; # if CONFIG_ERROR_CONCEALMENT if ( pbi -> ec_active && pbi -> mvs_corrupt_from_mb < ( unsigned int ) pc -> mb_cols * pc -> mb_rows ) { vp8_estimate_missing_mvs ( pbi ) ; } # endif <vul-start> vpx_memset ( pc -> above_context , 0 , sizeof ( ENTROPY_CONTEXT_PLANES ) * pc -> mb_cols ) ; <vul-end> pbi -> frame_corrupt_residual = 0 ; # if CONFIG_MULTITHREAD if ( pbi -> b_multithreaded_rd && pc -> multi_token_partition != ONE_PARTITION ) { unsigned int thread ; vp8mt_decode_mb_rows ( pbi , xd ) ; vp8_yv12_extend_frame_borders ( yv12_fb_new ) ; for ( thread = 0 ; thread < pbi -> decoding_thread_count ; ++ thread ) corrupt_tokens |= pbi -> mb_row_di [ thread ] . mbd . corrupted ; } else # endif { decode_mb_rows ( pbi ) ; corrupt_tokens |= xd -> corrupted ; } yv12_fb_new -> corrupted = vp8dx_bool_error ( bc ) ; yv12_fb_new -> corrupted |= corrupt_tokens ; if ( ! pbi -> decoded_key_frame ) { if ( pc -> frame_type == KEY_FRAME && ! yv12_fb_new -> corrupted ) pbi -> decoded_key_frame = 1 ; else vpx_internal_error ( & pbi -> common . error , VPX_CODEC_CORRUPT_FRAME , "A stream must start with a complete key frame" ) ; } if ( pc -> refresh_entropy_probs == 0 ) { <vul-start> vpx_memcpy ( & pc -> fc , & pc -> lfc , sizeof ( pc -> fc ) ) ; <vul-end> pbi -> independent_partitions = prev_independent_partitions ; } # ifdef PACKET_TESTING { FILE * f = fopen ( "decompressor.VP8" , "ab" ) ; unsigned int size = pbi -> bc2 . pos + pbi -> bc . pos + 8 ; fwrite ( ( void * ) & size , 4 , 1 , f ) ; fwrite ( ( void * ) pbi -> Source , size , 1 , f ) ; fclose ( f ) ; } # endif return 0 ; }
|
<vul-sep> { <vul-start> int n = ( int ) MIN ( sizeof ( clear_buffer ) , data_end - data ) ; <vul-end><vul-sep> data += 7 ; <vul-start> } else { memcpy ( & xd -> pre , yv12_fb_new , sizeof ( YV12_BUFFER_CONFIG ) ) ; memcpy ( & xd -> dst , yv12_fb_new , sizeof ( YV12_BUFFER_CONFIG ) ) ; <vul-end><vul-sep> xd -> mb_segement_abs_delta = ( unsigned char ) vp8_read_bit ( bc ) ; <vul-start> memset ( xd -> segment_feature_data , 0 , sizeof ( xd -> segment_feature_data ) ) ; <vul-end><vul-sep> { <vul-start> memset ( xd -> mb_segment_tree_probs , 255 , sizeof ( xd -> mb_segment_tree_probs ) ) ; <vul-end><vul-sep> { <vul-start> memcpy ( & pc -> lfc , & pc -> fc , sizeof ( pc -> fc ) ) ; <vul-end><vul-sep> } <vul-start> memset ( xd -> qcoeff , 0 , sizeof ( xd -> qcoeff ) ) ; <vul-end><vul-sep> # endif <vul-start> memset ( pc -> above_context , 0 , sizeof ( ENTROPY_CONTEXT_PLANES ) * pc -> mb_cols ) ; <vul-end><vul-sep> { <vul-start> memcpy ( & pc -> fc , & pc -> lfc , sizeof ( pc -> fc ) ) ; <vul-end><vul-sep>
|
68
|
CWE-20 if ( copy_from_user ( & cpuid , cpuid_arg , sizeof cpuid ) ) goto out ; r = kvm_vcpu_ioctl_set_cpuid2 ( vcpu , & cpuid , cpuid_arg -> entries ) ; break ; } case KVM_GET_CPUID2 : { struct kvm_cpuid2 __user * cpuid_arg = argp ; struct kvm_cpuid2 cpuid ; r = - EFAULT ; if ( copy_from_user ( & cpuid , cpuid_arg , sizeof cpuid ) ) goto out ; r = kvm_vcpu_ioctl_get_cpuid2 ( vcpu , & cpuid , cpuid_arg -> entries ) ; if ( r ) goto out ; r = - EFAULT ; if ( copy_to_user ( cpuid_arg , & cpuid , sizeof cpuid ) ) goto out ; r = 0 ; break ; } case KVM_GET_MSRS : r = msr_io ( vcpu , argp , kvm_get_msr , 1 ) ; break ; case KVM_SET_MSRS : r = msr_io ( vcpu , argp , do_set_msr , 0 ) ; break ; case KVM_TPR_ACCESS_REPORTING : { struct kvm_tpr_access_ctl tac ; r = - EFAULT ; if ( copy_from_user ( & tac , argp , sizeof tac ) ) goto out ; r = vcpu_ioctl_tpr_access_reporting ( vcpu , & tac ) ; if ( r ) goto out ; r = - EFAULT ; if ( copy_to_user ( argp , & tac , sizeof tac ) ) goto out ; r = 0 ; break ; } ; case KVM_SET_VAPIC_ADDR : { struct kvm_vapic_addr va ; r = - EINVAL ; if ( ! irqchip_in_kernel ( vcpu -> kvm ) ) goto out ; r = - EFAULT ; if ( copy_from_user ( & va , argp , sizeof va ) ) goto out ; <vul-start> r = 0 ; kvm_lapic_set_vapic_addr ( vcpu , va . vapic_addr ) ; <vul-end> break ; } case KVM_X86_SETUP_MCE : { u64 mcg_cap ; r = - EFAULT ; if ( copy_from_user ( & mcg_cap , argp , sizeof mcg_cap ) ) goto out ; r = kvm_vcpu_ioctl_x86_setup_mce ( vcpu , mcg_cap ) ; break ; } case KVM_X86_SET_MCE : { struct kvm_x86_mce mce ; r = - EFAULT ; if ( copy_from_user ( & mce , argp , sizeof mce ) ) goto out ; r = kvm_vcpu_ioctl_x86_set_mce ( vcpu , & mce ) ; break ; } case KVM_GET_VCPU_EVENTS : { struct kvm_vcpu_events events ; kvm_vcpu_ioctl_x86_get_vcpu_events ( vcpu , & events ) ; r = - EFAULT ; if ( copy_to_user ( argp , & events , sizeof ( struct kvm_vcpu_events ) ) ) break ; r = 0 ; break ; } case KVM_SET_VCPU_EVENTS : { struct kvm_vcpu_events events ; r = - EFAULT ; if ( copy_from_user ( & events , argp , sizeof ( struct kvm_vcpu_events ) ) ) break ; r = kvm_vcpu_ioctl_x86_set_vcpu_events ( vcpu , & events ) ; break ; } case KVM_GET_DEBUGREGS : { struct kvm_debugregs dbgregs ; kvm_vcpu_ioctl_x86_get_debugregs ( vcpu , & dbgregs ) ; r = - EFAULT ; if ( copy_to_user ( argp , & dbgregs , sizeof ( struct kvm_debugregs ) ) ) break ; r = 0 ; break ; } case KVM_SET_DEBUGREGS : { struct kvm_debugregs dbgregs ; r = - EFAULT ; if ( copy_from_user ( & dbgregs , argp , sizeof ( struct kvm_debugregs ) ) )
|
<vul-sep> goto out ; <vul-start> r = kvm_lapic_set_vapic_addr ( vcpu , va . vapic_addr ) ; <vul-end><vul-sep>
|
69
|
CWE-476 const char * zSavedAuthContext = pParse -> zAuthContext ; Select * pParent ; Select * pSub ; Select * pSub1 ; SrcList * pSrc ; SrcList * pSubSrc ; int iParent ; int iNewParent = - 1 ; int isLeftJoin = 0 ; int i ; Expr * pWhere ; struct SrcList_item * pSubitem ; sqlite3 * db = pParse -> db ; assert ( p != 0 ) ; assert ( p -> pPrior == 0 ) ; if ( OptimizationDisabled ( db , SQLITE_QueryFlattener ) ) return 0 ; pSrc = p -> pSrc ; assert ( pSrc && iFrom >= 0 && iFrom < pSrc -> nSrc ) ; pSubitem = & pSrc -> a [ iFrom ] ; iParent = pSubitem -> iCursor ; pSub = pSubitem -> pSelect ; assert ( pSub != 0 ) ; # ifndef SQLITE_OMIT_WINDOWFUNC if ( p -> pWin || pSub -> pWin ) return 0 ; # endif pSubSrc = pSub -> pSrc ; assert ( pSubSrc ) ; if ( pSub -> pLimit && p -> pLimit ) return 0 ; if ( pSub -> pLimit && pSub -> pLimit -> pRight ) return 0 ; if ( ( p -> selFlags & SF_Compound ) != 0 && pSub -> pLimit ) { return 0 ; } if ( pSubSrc -> nSrc == 0 ) return 0 ; if ( pSub -> selFlags & SF_Distinct ) return 0 ; if ( pSub -> pLimit && ( pSrc -> nSrc > 1 || isAgg ) ) { return 0 ; } if ( p -> pOrderBy && pSub -> pOrderBy ) { return 0 ; } if ( isAgg && pSub -> pOrderBy ) return 0 ; if ( pSub -> pLimit && p -> pWhere ) return 0 ; if ( pSub -> pLimit && ( p -> selFlags & SF_Distinct ) != 0 ) { return 0 ; } if ( pSub -> selFlags & ( SF_Recursive ) ) { return 0 ; } if ( ( pSubitem -> fg . jointype & JT_OUTER ) != 0 ) { isLeftJoin = 1 ; <vul-start> if ( pSubSrc -> nSrc > 1 || isAgg || IsVirtual ( pSubSrc -> a [ 0 ] . pTab ) ) { <vul-end> return 0 ; } } # ifdef SQLITE_EXTRA_IFNULLROW else if ( iFrom > 0 && ! isAgg ) { isLeftJoin = - 1 ; } # endif if ( pSub -> pPrior ) { if ( pSub -> pOrderBy ) { return 0 ; } if ( isAgg || ( p -> selFlags & SF_Distinct ) != 0 || pSrc -> nSrc != 1 ) { return 0 ; } for ( pSub1 = pSub ; pSub1 ; pSub1 = pSub1 -> pPrior ) { testcase ( ( pSub1 -> selFlags & ( SF_Distinct | SF_Aggregate ) ) == SF_Distinct ) ; testcase ( ( pSub1 -> selFlags & ( SF_Distinct | SF_Aggregate ) ) == SF_Aggregate ) ; assert ( pSub -> pSrc != 0 ) ; assert ( pSub -> pEList -> nExpr == pSub1 -> pEList -> nExpr ) ; if ( ( pSub1 -> selFlags & ( SF_Distinct | SF_Aggregate ) ) != 0 || ( pSub1 -> pPrior && pSub1 -> op != TK_ALL ) || pSub1 -> pSrc -> nSrc < 1 ) { return 0 ; } testcase ( pSub1 -> pSrc -> nSrc > 1 ) ; } if ( p -> pOrderBy ) { int ii ; for ( ii = 0 ; ii < p -> pOrderBy -> nExpr ; ii ++ ) { if ( p -> pOrderBy -> a [ ii ] . u . x . iOrderByCol == 0 ) return 0 ; } } } assert ( ( p -> selFlags & SF_Recursive ) == 0 || pSub -> pPrior == 0 ) ; SELECTTRACE ( 1 , pParse , p , ( "flatten %u.%p from term %d\\n" , pSub -> selId , pSub , iFrom ) ) ; pParse -> zAuthContext = pSubitem -> zName ; TESTONLY ( i = ) sqlite3AuthCheck ( pParse , SQLITE_SELECT , 0 , 0 , 0 ) ; testcase ( i == SQLITE_DENY ) ; pParse -> zAuthContext = zSavedAuthContext ; for ( pSub = pSub -> pPrior ; pSub ; pSub = pSub -> pPrior ) { Select * pNew ; ExprList * pOrderBy = p -> pOrderBy ; Expr * pLimit = p -> pLimit ; Select * pPrior = p -> pPrior ; p -> pOrderBy = 0 ; p -> pSrc = 0 ; p -> pPrior = 0 ;
|
<vul-sep> isLeftJoin = 1 ; <vul-start> if ( pSubSrc -> nSrc > 1 || isAgg || IsVirtual ( pSubSrc -> a [ 0 ] . pTab ) || ( p -> selFlags & SF_Distinct ) != 0 ) { <vul-end><vul-sep>
|
70
|
CWE-119 static void down2_symeven ( const uint8_t * const input , int length , uint8_t * output ) { <vul-start> static const int16_t * filter = vp9_down2_symeven_half_filter ; <vul-end> const int filter_len_half = sizeof ( vp9_down2_symeven_half_filter ) / 2 ; int i , j ; uint8_t * optr = output ; int l1 = filter_len_half ; int l2 = ( length - filter_len_half ) ; l1 += ( l1 & 1 ) ; l2 += ( l2 & 1 ) ; if ( l1 > l2 ) { for ( i = 0 ; i < length ; i += 2 ) { int sum = ( 1 << ( FILTER_BITS - 1 ) ) ; for ( j = 0 ; j < filter_len_half ; ++ j ) { sum += ( input [ ( i - j < 0 ? 0 : i - j ) ] + input [ ( i + 1 + j >= length ? length - 1 : i + 1 + j ) ] ) * filter [ j ] ; } sum >>= FILTER_BITS ; * optr ++ = clip_pixel ( sum ) ; } } else { for ( i = 0 ; i < l1 ; i += 2 ) { int sum = ( 1 << ( FILTER_BITS - 1 ) ) ; for ( j = 0 ; j < filter_len_half ; ++ j ) { sum += ( input [ ( i - j < 0 ? 0 : i - j ) ] + input [ i + 1 + j ] ) * filter [ j ] ; } sum >>= FILTER_BITS ; * optr ++ = clip_pixel ( sum ) ; } for ( ; i < l2 ; i += 2 ) { int sum = ( 1 << ( FILTER_BITS - 1 ) ) ; for ( j = 0 ; j < filter_len_half ; ++ j ) { sum += ( input [ i - j ] + input [ i + 1 + j ] ) * filter [ j ] ; } sum >>= FILTER_BITS ; * optr ++ = clip_pixel ( sum ) ; } for ( ; i < length ; i += 2 ) { int sum = ( 1 << ( FILTER_BITS - 1 ) ) ; for ( j = 0 ; j < filter_len_half ; ++ j ) { sum += ( input [ i - j ] + input [ ( i + 1 + j >= length ? length - 1 : i + 1 + j ) ] ) * filter [ j ] ; } sum >>= FILTER_BITS ; * optr ++ = clip_pixel ( sum ) ; } } }
|
<vul-sep> uint8_t * output ) { <vul-start> const int16_t * filter = vp9_down2_symeven_half_filter ; <vul-end><vul-sep>
|
71
|
CWE-264 void vlan_setup ( struct net_device * dev ) { ether_setup ( dev ) ; dev -> priv_flags |= IFF_802_1Q_VLAN ; <vul-start> dev -> priv_flags &= ~ IFF_XMIT_DST_RELEASE ; <vul-end> dev -> tx_queue_len = 0 ; dev -> netdev_ops = & vlan_netdev_ops ; dev -> destructor = free_netdev ; dev -> ethtool_ops = & vlan_ethtool_ops ; memset ( dev -> broadcast , 0 , ETH_ALEN ) ; }
|
<vul-sep> dev -> priv_flags |= IFF_802_1Q_VLAN ; <vul-start> dev -> priv_flags &= ~ ( IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING ) ; <vul-end><vul-sep>
|
72
|
CWE-20 error_t webSocketParseHeaderField ( WebSocket * webSocket , char_t * line ) { char_t * separator ; char_t * name ; char_t * value ; WebSocketHandshakeContext * handshakeContext ; handshakeContext = & webSocket -> handshakeContext ; TRACE_DEBUG ( "%s" , line ) ; <vul-start> separator = strchr ( line , ':' ) ; <vul-end> if ( separator != NULL ) { * separator = '\\0' ; name = strTrimWhitespace ( line ) ; value = strTrimWhitespace ( separator + 1 ) ; if ( ! osStrcasecmp ( name , "Upgrade" ) ) { if ( ! osStrcasecmp ( value , "websocket" ) ) handshakeContext -> upgradeWebSocket = TRUE ; } else if ( ! osStrcasecmp ( name , "Connection" ) ) { webSocketParseConnectionField ( webSocket , value ) ; } else if ( ! osStrcasecmp ( name , "Sec-WebSocket-Key" ) ) { if ( webSocket -> endpoint == WS_ENDPOINT_SERVER ) { strSafeCopy ( handshakeContext -> clientKey , value , WEB_SOCKET_CLIENT_KEY_SIZE + 1 ) ; } } else if ( ! osStrcasecmp ( name , "Sec-WebSocket-Accept" ) ) { if ( webSocket -> endpoint == WS_ENDPOINT_CLIENT ) { strSafeCopy ( handshakeContext -> serverKey , value , WEB_SOCKET_SERVER_KEY_SIZE + 1 ) ; } } # if ( WEB_SOCKET_BASIC_AUTH_SUPPORT == ENABLED || WEB_SOCKET_DIGEST_AUTH_SUPPORT == ENABLED ) else if ( ! osStrcasecmp ( name , "WWW-Authenticate" ) ) { webSocketParseAuthenticateField ( webSocket , value ) ; } # endif else if ( ! osStrcasecmp ( name , "Content-Length" ) ) { handshakeContext -> contentLength = osStrtoul ( value , NULL , 10 ) ; } } return NO_ERROR ; }
|
<vul-sep> TRACE_DEBUG ( "%s" , line ) ; <vul-start> separator = osStrchr ( line , ':' ) ; <vul-end><vul-sep>
|
73
|
CWE-362 int inet_sk_rebuild_header ( struct sock * sk ) { struct inet_sock * inet = inet_sk ( sk ) ; struct rtable * rt = ( struct rtable * ) __sk_dst_check ( sk , 0 ) ; __be32 daddr ; <vul-start> <vul-end> int err ; if ( rt ) return 0 ; <vul-start> <vul-end> daddr = inet -> inet_daddr ; <vul-start> if ( inet -> opt && inet -> opt -> srr ) daddr = inet -> opt -> faddr ; <vul-end> rt = ip_route_output_ports ( sock_net ( sk ) , sk , daddr , inet -> inet_saddr , inet -> inet_dport , inet -> inet_sport , sk -> sk_protocol , RT_CONN_FLAGS ( sk ) , sk -> sk_bound_dev_if ) ; if ( ! IS_ERR ( rt ) ) { err = 0 ; sk_setup_caps ( sk , & rt -> dst ) ; } else { err = PTR_ERR ( rt ) ; sk -> sk_route_caps = 0 ; if ( ! sysctl_ip_dynaddr || sk -> sk_state != TCP_SYN_SENT || ( sk -> sk_userlocks & SOCK_BINDADDR_LOCK ) || ( err = inet_sk_reselect_saddr ( sk ) ) != 0 ) sk -> sk_err_soft = - err ; } return err ; }
|
<vul-sep> __be32 daddr ; <vul-start> struct ip_options_rcu * inet_opt ; <vul-end><vul-sep> return 0 ; <vul-start> rcu_read_lock ( ) ; inet_opt = rcu_dereference ( inet -> inet_opt ) ; <vul-end><vul-sep> daddr = inet -> inet_daddr ; <vul-start> if ( inet_opt && inet_opt -> opt . srr ) daddr = inet_opt -> opt . faddr ; rcu_read_unlock ( ) ; <vul-end><vul-sep>
|
74
|
CWE-119 void vp9_rc_compute_frame_size_bounds ( const VP9_COMP * cpi , <vul-start> int this_frame_target , <vul-end> int * frame_under_shoot_limit , int * frame_over_shoot_limit ) { <vul-start> if ( cpi -> oxcf . end_usage == USAGE_CONSTANT_QUALITY ) { <vul-end> * frame_under_shoot_limit = 0 ; * frame_over_shoot_limit = INT_MAX ; } else { <vul-start> int recode_tolerance = ( cpi -> sf . recode_tolerance * this_frame_target ) / 100 ; * frame_over_shoot_limit = this_frame_target + recode_tolerance ; * frame_under_shoot_limit = this_frame_target - recode_tolerance ; * frame_over_shoot_limit += 200 ; * frame_under_shoot_limit -= 200 ; if ( * frame_under_shoot_limit < 0 ) * frame_under_shoot_limit = 0 ; if ( * frame_over_shoot_limit > cpi -> rc . max_frame_bandwidth ) { * frame_over_shoot_limit = cpi -> rc . max_frame_bandwidth ; } <vul-end> } }
|
<vul-sep> void vp9_rc_compute_frame_size_bounds ( const VP9_COMP * cpi , <vul-start> int frame_target , <vul-end><vul-sep> int * frame_over_shoot_limit ) { <vul-start> if ( cpi -> oxcf . rc_mode == VPX_Q ) { <vul-end><vul-sep> } else { <vul-start> const int tolerance = ( cpi -> sf . recode_tolerance * frame_target ) / 100 ; * frame_under_shoot_limit = MAX ( frame_target - tolerance - 200 , 0 ) ; * frame_over_shoot_limit = MIN ( frame_target + tolerance + 200 , cpi -> rc . max_frame_bandwidth ) ; <vul-end><vul-sep>
|
75
|
CWE-362 # endif if ( skb -> protocol == htons ( ETH_P_IP ) ) { newsk = tcp_v4_syn_recv_sock ( sk , skb , req , dst ) ; if ( newsk == NULL ) return NULL ; newtcp6sk = ( struct tcp6_sock * ) newsk ; inet_sk ( newsk ) -> pinet6 = & newtcp6sk -> inet6 ; newinet = inet_sk ( newsk ) ; newnp = inet6_sk ( newsk ) ; newtp = tcp_sk ( newsk ) ; memcpy ( newnp , np , sizeof ( struct ipv6_pinfo ) ) ; ipv6_addr_set_v4mapped ( newinet -> inet_daddr , & newnp -> daddr ) ; ipv6_addr_set_v4mapped ( newinet -> inet_saddr , & newnp -> saddr ) ; ipv6_addr_copy ( & newnp -> rcv_saddr , & newnp -> saddr ) ; inet_csk ( newsk ) -> icsk_af_ops = & ipv6_mapped ; newsk -> sk_backlog_rcv = tcp_v4_do_rcv ; # ifdef CONFIG_TCP_MD5SIG newtp -> af_specific = & tcp_sock_ipv6_mapped_specific ; # endif newnp -> pktoptions = NULL ; newnp -> opt = NULL ; newnp -> mcast_oif = inet6_iif ( skb ) ; newnp -> mcast_hops = ipv6_hdr ( skb ) -> hop_limit ; tcp_sync_mss ( newsk , inet_csk ( newsk ) -> icsk_pmtu_cookie ) ; return newsk ; } treq = inet6_rsk ( req ) ; opt = np -> opt ; if ( sk_acceptq_is_full ( sk ) ) goto out_overflow ; if ( ! dst ) { dst = inet6_csk_route_req ( sk , req ) ; if ( ! dst ) goto out ; } newsk = tcp_create_openreq_child ( sk , req , skb ) ; if ( newsk == NULL ) goto out_nonewsk ; newsk -> sk_gso_type = SKB_GSO_TCPV6 ; __ip6_dst_store ( newsk , dst , NULL , NULL ) ; newtcp6sk = ( struct tcp6_sock * ) newsk ; inet_sk ( newsk ) -> pinet6 = & newtcp6sk -> inet6 ; newtp = tcp_sk ( newsk ) ; newinet = inet_sk ( newsk ) ; newnp = inet6_sk ( newsk ) ; memcpy ( newnp , np , sizeof ( struct ipv6_pinfo ) ) ; ipv6_addr_copy ( & newnp -> daddr , & treq -> rmt_addr ) ; ipv6_addr_copy ( & newnp -> saddr , & treq -> loc_addr ) ; ipv6_addr_copy ( & newnp -> rcv_saddr , & treq -> loc_addr ) ; newsk -> sk_bound_dev_if = treq -> iif ; <vul-start> newinet -> opt = NULL ; <vul-end> newnp -> ipv6_fl_list = NULL ; newnp -> rxopt . all = np -> rxopt . all ; newnp -> pktoptions = NULL ; if ( treq -> pktopts != NULL ) { newnp -> pktoptions = skb_clone ( treq -> pktopts , GFP_ATOMIC ) ; kfree_skb ( treq -> pktopts ) ; treq -> pktopts = NULL ; if ( newnp -> pktoptions ) skb_set_owner_r ( newnp -> pktoptions , newsk ) ; } newnp -> opt = NULL ; newnp -> mcast_oif = inet6_iif ( skb ) ; newnp -> mcast_hops = ipv6_hdr ( skb ) -> hop_limit ; if ( opt ) { newnp -> opt = ipv6_dup_options ( newsk , opt ) ; if ( opt != np -> opt ) sock_kfree_s ( sk , opt , opt -> tot_len ) ; } inet_csk ( newsk ) -> icsk_ext_hdr_len = 0 ; if ( newnp -> opt ) inet_csk ( newsk ) -> icsk_ext_hdr_len = ( newnp -> opt -> opt_nflen + newnp -> opt -> opt_flen ) ; tcp_mtup_init ( newsk ) ; tcp_sync_mss ( newsk , dst_mtu ( dst ) ) ; newtp -> advmss = dst_metric_advmss ( dst ) ; tcp_initialize_rcv_mss ( newsk ) ; newinet -> inet_daddr = newinet -> inet_saddr = LOOPBACK4_IPV6 ; newinet -> inet_rcv_saddr = LOOPBACK4_IPV6 ; # ifdef CONFIG_TCP_MD5SIG if ( ( key = tcp_v6_md5_do_lookup ( sk , & newnp -> daddr ) ) != NULL ) { char * newkey = kmemdup ( key -> key , key -> keylen , GFP_ATOMIC ) ; if ( newkey != NULL ) tcp_v6_md5_do_add ( newsk , & newnp -> daddr , newkey , key -> keylen ) ; } # endif if ( __inet_inherit_port ( sk , newsk ) < 0 ) { sock_put ( newsk ) ; goto out ; } __inet6_hash ( newsk , NULL ) ; return newsk ; out_overflow : NET_INC_STATS_BH ( sock_net ( sk ) , LINUX_MIB_LISTENOVERFLOWS ) ; out_nonewsk : if ( opt && opt != np -> opt ) sock_kfree_s ( sk , opt , opt -> tot_len ) ; dst_release ( dst ) ; out : NET_INC_STATS_BH ( sock_net ( sk ) , LINUX_MIB_LISTENDROPS ) ;
|
<vul-sep> newsk -> sk_bound_dev_if = treq -> iif ; <vul-start> newinet -> inet_opt = NULL ; <vul-end><vul-sep>
|
76
|
CWE-682 static int find_low_bit ( unsigned int x ) { int i ; for ( i = 0 ; i <= 31 ; i ++ ) { <vul-start> if ( x & ( 1 << i ) ) return i ; <vul-end> } return 0 ; }
|
<vul-sep> for ( i = 0 ; i <= 31 ; i ++ ) { <vul-start> if ( x & ( 1U << ( unsigned int ) i ) ) return i ; <vul-end><vul-sep>
|
77
|
CWE-787 int TIFFFlushData1 ( TIFF * tif ) { if ( tif -> tif_rawcc > 0 && tif -> tif_flags & TIFF_BUF4WRITE ) { if ( ! isFillOrder ( tif , tif -> tif_dir . td_fillorder ) && ( tif -> tif_flags & TIFF_NOBITREV ) == 0 ) TIFFReverseBits ( ( uint8 * ) tif -> tif_rawdata , tif -> tif_rawcc ) ; if ( ! TIFFAppendToStrip ( tif , isTiled ( tif ) ? tif -> tif_curtile : tif -> tif_curstrip , tif -> tif_rawdata , tif -> tif_rawcc ) ) <vul-start> <vul-end> return ( 0 ) ; <vul-start> <vul-end> tif -> tif_rawcc = 0 ; tif -> tif_rawcp = tif -> tif_rawdata ; } return ( 1 ) ; }
|
<vul-sep> tif -> tif_rawdata , tif -> tif_rawcc ) ) <vul-start> { tif -> tif_rawcc = 0 ; tif -> tif_rawcp = tif -> tif_rawdata ; <vul-end><vul-sep> return ( 0 ) ; <vul-start> } <vul-end><vul-sep>
|
78
|
CWE-119 void imap_quote_string ( char * dest , size_t dlen , const char * src , bool quote_backtick ) { const char * quote = "`\\"\\\\" ; if ( ! quote_backtick ) quote ++ ; char * pt = dest ; const char * s = src ; * pt ++ = \'"\' ; <vul-start> dlen -= 2 ; <vul-end> for ( ; * s && dlen ; s ++ ) { if ( strchr ( quote , * s ) ) { if ( dlen < 2 ) break ; dlen -= 2 ; * pt ++ = '\\\\' ; * pt ++ = * s ; } else { * pt ++ = * s ; dlen -- ; } } * pt ++ = \'"\' ; * pt = '\\0' ; }
|
<vul-sep> * pt ++ = \'"\' ; <vul-start> dlen -= 3 ; <vul-end><vul-sep>
|
79
|
CWE-20 void init_util ( void ) { filegen_register ( statsdir , "peerstats" , & peerstats ) ; filegen_register ( statsdir , "loopstats" , & loopstats ) ; filegen_register ( statsdir , "clockstats" , & clockstats ) ; filegen_register ( statsdir , "rawstats" , & rawstats ) ; filegen_register ( statsdir , "sysstats" , & sysstats ) ; filegen_register ( statsdir , "protostats" , & protostats ) ; <vul-start> # ifdef AUTOKEY <vul-end> filegen_register ( statsdir , "cryptostats" , & cryptostats ) ; <vul-start> # endif # ifdef DEBUG_TIMING <vul-end> filegen_register ( statsdir , "timingstats" , & timingstats ) ; <vul-start> # endif <vul-end> step_callback = & ntpd_time_stepped ; # ifdef DEBUG atexit ( & uninit_util ) ; # endif }
|
<vul-sep> filegen_register ( statsdir , "protostats" , & protostats ) ; <vul-start><vul-end><vul-sep> filegen_register ( statsdir , "cryptostats" , & cryptostats ) ; <vul-start><vul-end><vul-sep> filegen_register ( statsdir , "timingstats" , & timingstats ) ; <vul-start><vul-end><vul-sep>
|
80
|
CWE-119 static int catc_probe ( struct usb_interface * intf , const struct usb_device_id * id ) { struct device * dev = & intf -> dev ; struct usb_device * usbdev = interface_to_usbdev ( intf ) ; struct net_device * netdev ; struct catc * catc ; u8 broadcast [ ETH_ALEN ] ; <vul-start> int i , pktsz , ret ; <vul-end> if ( usb_set_interface ( usbdev , intf -> altsetting -> desc . bInterfaceNumber , 1 ) ) { dev_err ( dev , "Can\'t set altsetting 1.\\n" ) ; return - EIO ; } netdev = alloc_etherdev ( sizeof ( struct catc ) ) ; if ( ! netdev ) return - ENOMEM ; catc = netdev_priv ( netdev ) ; netdev -> netdev_ops = & catc_netdev_ops ; netdev -> watchdog_timeo = TX_TIMEOUT ; netdev -> ethtool_ops = & ops ; catc -> usbdev = usbdev ; catc -> netdev = netdev ; spin_lock_init ( & catc -> tx_lock ) ; spin_lock_init ( & catc -> ctrl_lock ) ; init_timer ( & catc -> timer ) ; catc -> timer . data = ( long ) catc ; catc -> timer . function = catc_stats_timer ; catc -> ctrl_urb = usb_alloc_urb ( 0 , GFP_KERNEL ) ; catc -> tx_urb = usb_alloc_urb ( 0 , GFP_KERNEL ) ; catc -> rx_urb = usb_alloc_urb ( 0 , GFP_KERNEL ) ; catc -> irq_urb = usb_alloc_urb ( 0 , GFP_KERNEL ) ; if ( ( ! catc -> ctrl_urb ) || ( ! catc -> tx_urb ) || ( ! catc -> rx_urb ) || ( ! catc -> irq_urb ) ) { dev_err ( & intf -> dev , "No free urbs available.\\n" ) ; ret = - ENOMEM ; goto fail_free ; } if ( le16_to_cpu ( usbdev -> descriptor . idVendor ) == 0x0423 && le16_to_cpu ( usbdev -> descriptor . idProduct ) == 0xa && le16_to_cpu ( catc -> usbdev -> descriptor . bcdDevice ) == 0x0130 ) { dev_dbg ( dev , "Testing for f5u011\\n" ) ; catc -> is_f5u011 = 1 ; atomic_set ( & catc -> recq_sz , 0 ) ; pktsz = RX_PKT_SZ ; } else { pktsz = RX_MAX_BURST * ( PKT_SZ + 2 ) ; } usb_fill_control_urb ( catc -> ctrl_urb , usbdev , usb_sndctrlpipe ( usbdev , 0 ) , NULL , NULL , 0 , catc_ctrl_done , catc ) ; usb_fill_bulk_urb ( catc -> tx_urb , usbdev , usb_sndbulkpipe ( usbdev , 1 ) , NULL , 0 , catc_tx_done , catc ) ; usb_fill_bulk_urb ( catc -> rx_urb , usbdev , usb_rcvbulkpipe ( usbdev , 1 ) , catc -> rx_buf , pktsz , catc_rx_done , catc ) ; usb_fill_int_urb ( catc -> irq_urb , usbdev , usb_rcvintpipe ( usbdev , 2 ) , catc -> irq_buf , 2 , catc_irq_done , catc , 1 ) ; if ( ! catc -> is_f5u011 ) { <vul-start> <vul-end> dev_dbg ( dev , "Checking memory size\\n" ) ; <vul-start> i = 0x12345678 ; catc_write_mem ( catc , 0x7a80 , & i , 4 ) ; i = 0x87654321 ; catc_write_mem ( catc , 0xfa80 , & i , 4 ) ; catc_read_mem ( catc , 0x7a80 , & i , 4 ) ; switch ( i ) { <vul-end> case 0x12345678 : catc_set_reg ( catc , TxBufCount , 8 ) ; catc_set_reg ( catc , RxBufCount , 32 ) ; dev_dbg ( dev , "64k Memory\\n" ) ; break ; default : dev_warn ( & intf -> dev , "Couldn\'t detect memory size, assuming 32k\\n" ) ; case 0x87654321 : catc_set_reg ( catc , TxBufCount , 4 ) ; catc_set_reg ( catc , RxBufCount , 16 ) ; dev_dbg ( dev , "32k Memory\\n" ) ; break ; } <vul-start> <vul-end> dev_dbg ( dev , "Getting MAC from SEEROM.\\n" ) ; catc_get_mac ( catc , netdev -> dev_addr ) ; dev_dbg ( dev , "Setting MAC into registers.\\n" ) ; for ( i = 0 ; i < 6 ; i ++ ) catc_set_reg ( catc , StationAddr0 - i , netdev -> dev_addr [ i ] ) ; dev_dbg ( dev , "Filling the multicast list.\\n" ) ; eth_broadcast_addr ( broadcast ) ; catc_multicast ( broadcast , catc -> multicast ) ; catc_multicast ( netdev -> dev_addr , catc -> multicast ) ; catc_write_mem ( catc , 0xfa80 , catc -> multicast , 64 ) ; dev_dbg ( dev , "Clearing error counters.\\n" ) ; for ( i = 0 ; i < 8 ; i ++ ) catc_set_reg ( catc , EthStats + i , 0 ) ; catc -> last_stats = jiffies ; dev_dbg ( dev , "Enabling.\\n" ) ; catc_set_reg ( catc , MaxBurst , RX_MAX_BURST ) ; catc_set_reg ( catc , OpModes , OpTxMerge | OpRxMerge | OpLenInclude | Op3MemWaits ) ; catc_set_reg ( catc , LEDCtrl , LEDLink ) ; catc_set_reg ( catc , RxUnit , RxEnable | RxPolarity | RxMultiCast ) ; } else { dev_dbg ( dev , "Performing reset\\n" ) ; catc_reset ( catc ) ; catc_get_mac ( catc , netdev -> dev_addr ) ; dev_dbg ( dev , "Setting RX Mode\\n" ) ; catc -> rxmode [ 0 ] = RxEnable | RxPolarity | RxMultiCast ; catc -> rxmode [ 1 ] = 0 ; f5u011_rxmode ( catc , catc -> rxmode ) ; } dev_dbg ( dev , "Init done.\\n" ) ; printk ( KERN_INFO "%s: %s USB Ethernet at usb-%s-%s, %pM.\\n" , netdev -> name , ( catc -> is_f5u011 ) ? "Belkin F5U011" : "CATC EL1210A NetMate" , usbdev -> bus -> bus_name , usbdev -> devpath , netdev -> dev_addr ) ; usb_set_intfdata ( intf , catc ) ; SET_NETDEV_DEV ( netdev , & intf -> dev ) ; ret = register_netdev ( netdev ) ; if ( ret ) goto fail_clear_intfdata ; return 0 ; fail_clear_intfdata : usb_set_intfdata ( intf , NULL ) ; fail_free : usb_free_urb ( catc -> ctrl_urb ) ; usb_free_urb ( catc -> tx_urb ) ; usb_free_urb ( catc -> rx_urb ) ; usb_free_urb ( catc -> irq_urb ) ; free_netdev ( netdev ) ; return ret ; }
|
<vul-sep> u8 broadcast [ ETH_ALEN ] ; <vul-start> int pktsz , ret ; <vul-end><vul-sep> if ( ! catc -> is_f5u011 ) { <vul-start> u32 * buf ; int i ; <vul-end><vul-sep> dev_dbg ( dev , "Checking memory size\\n" ) ; <vul-start> buf = kmalloc ( 4 , GFP_KERNEL ) ; if ( ! buf ) { ret = - ENOMEM ; goto fail_free ; } * buf = 0x12345678 ; catc_write_mem ( catc , 0x7a80 , buf , 4 ) ; * buf = 0x87654321 ; catc_write_mem ( catc , 0xfa80 , buf , 4 ) ; catc_read_mem ( catc , 0x7a80 , buf , 4 ) ; switch ( * buf ) { <vul-end><vul-sep> } <vul-start> kfree ( buf ) ; <vul-end><vul-sep>
|
End of preview. Expand
in Data Studio
No dataset card yet
- Downloads last month
- 21