Unnamed: 0
int64 0
535k
| source
stringlengths 50
89.8k
| target
stringlengths 23
37.7k
|
|---|---|---|
1,600 | CWE-000 CAResult_t CALEClientSendUnicastMessageImpl ( const char * address , const uint8_t * data , const uint32_t dataLen ) { OIC_LOG_V ( INFO , TAG , "CALEClientSendUnicastMessageImpl,<S2SV_blank>address:<S2SV_blank>%s,<S2SV_blank>data:<S2SV_blank>%p" , address , data ) ; VERIFY_NON_NULL ( address , TAG , "address<S2SV_blank>is<S2SV_blank>null" ) ; if ( ! g_jvm ) { OIC_LOG ( ERROR , TAG , "g_jvm<S2SV_blank>is<S2SV_blank>null" ) ; return CA_STATUS_FAILED ; } bool isAttached = false ; JNIEnv * env = NULL ; jint res = ( * g_jvm ) -> GetEnv ( g_jvm , ( void * * ) & env , JNI_VERSION_1_6 ) ; if ( JNI_OK != res ) { res = ( * g_jvm ) -> AttachCurrentThread ( g_jvm , & env , NULL ) ; if ( JNI_OK != res ) { OIC_LOG ( ERROR , TAG , "AttachCurrentThread<S2SV_blank>has<S2SV_blank>failed" ) ; return CA_STATUS_FAILED ; } isAttached = true ; } oc_mutex_lock ( g_threadSendMutex ) ; CALEClientSetSendFinishFlag ( false ) ; CAResult_t ret = CALEClientIsThereScannedDevices ( env , address ) ; if ( CA_STATUS_OK != ret ) { OIC_LOG ( INFO , TAG , "there<S2SV_blank>is<S2SV_blank>no<S2SV_blank>scanned<S2SV_blank>device" ) ; goto error_exit ; } if ( g_context && g_deviceList ) { size_t length = u_arraylist_length ( g_deviceList ) ; for ( size_t index = 0 ; index < length ; index ++ ) { jobject jarrayObj = ( jobject ) u_arraylist_get ( g_deviceList , index ) ; if ( ! jarrayObj ) { OIC_LOG ( ERROR , TAG , "jarrayObj<S2SV_blank>is<S2SV_blank>null" ) ; goto error_exit ; } jstring jni_setAddress = CALEGetAddressFromBTDevice ( env , jarrayObj ) ; if ( ! jni_setAddress ) { OIC_LOG ( ERROR , TAG , "jni_setAddress<S2SV_blank>is<S2SV_blank>null" ) ; goto error_exit ; } const char * setAddress = ( * env ) -> GetStringUTFChars ( env , jni_setAddress , NULL ) ; if ( ! setAddress ) { OIC_LOG ( ERROR , TAG , "setAddress<S2SV_blank>is<S2SV_blank>null" ) ; CACheckJNIException ( env ) ; goto error_exit ; } if ( ! strcasecmp ( setAddress , address ) ) { ( * env ) -> ReleaseStringUTFChars ( env , jni_setAddress , setAddress ) ; ( * env ) -> DeleteLocalRef ( env , jni_setAddress ) ; <S2SV_StartBug> if ( g_sendBuffer ) <S2SV_EndBug> { ( * env ) -> DeleteGlobalRef ( env , g_sendBuffer ) ; g_sendBuffer = NULL ; } if ( data && dataLen > 0 ) { jbyteArray jni_arr = ( * env ) -> NewByteArray ( env , dataLen ) ; CACheckJNIException ( env ) ; ( * env ) -> SetByteArrayRegion ( env , jni_arr , 0 , dataLen , ( jbyte * ) data ) ; CACheckJNIException ( env ) ; g_sendBuffer = ( jbyteArray ) ( * env ) -> NewGlobalRef ( env , jni_arr ) ; CACheckJNIException ( env ) ; } g_targetCnt = 1 ; ret = CALEClientSendData ( env , jarrayObj ) ; if ( CA_STATUS_OK != ret ) { OIC_LOG ( ERROR , TAG , "CALEClientSendData<S2SV_blank>in<S2SV_blank>unicast<S2SV_blank>is<S2SV_blank>failed" ) ; goto error_exit ; } OIC_LOG ( INFO , TAG , "wake<S2SV_blank>up" ) ; break ; } ( * env ) -> ReleaseStringUTFChars ( env , jni_setAddress , setAddress ) ; ( * env ) -> DeleteLocalRef ( env , jni_setAddress ) ; } } OIC_LOG ( DEBUG , TAG , "connection<S2SV_blank>routine<S2SV_blank>is<S2SV_blank>finished<S2SV_blank>for<S2SV_blank>unicast" ) ; oc_mutex_lock ( g_threadMutex ) ; if ( ! g_isFinishedSendData ) { OIC_LOG ( DEBUG , TAG , "waiting<S2SV_blank>send<S2SV_blank>finish<S2SV_blank>signal" ) ; oc_cond_wait ( g_threadCond , g_threadMutex ) ; OIC_LOG ( DEBUG , TAG , "connection<S2SV_blank>/<S2SV_blank>send<S2SV_blank>is<S2SV_blank>finished<S2SV_blank>for<S2SV_blank>unicast" ) ; } oc_mutex_unlock ( g_threadMutex ) ; if ( isAttached ) { ( * g_jvm ) -> DetachCurrentThread ( g_jvm ) ; } oc_mutex_unlock ( g_threadSendMutex ) ; OIC_LOG ( INFO , TAG , "unicast<S2SV_blank>-<S2SV_blank>send<S2SV_blank>logic<S2SV_blank>has<S2SV_blank>finished" ) ; if ( CALEIsValidState ( address , CA_LE_SEND_STATE , STATE_SEND_SUCCESS , g_deviceStateList , g_deviceStateListMutex ) ) { OIC_LOG ( INFO , TAG , "send<S2SV_blank>success" ) ; ret = CA_STATUS_OK ; } else if ( CALEIsValidState ( address , CA_LE_SEND_STATE , STATE_SEND_MTU_NEGO_SUCCESS , g_deviceStateList , g_deviceStateListMutex ) ) { OIC_LOG ( INFO , TAG , "mtu<S2SV_blank>nego<S2SV_blank>success" ) ; ret = CA_STATUS_OK ; } else { OIC_LOG ( ERROR , TAG , "send<S2SV_blank>failure" ) ; ret = CA_SEND_FAILED ; } CAResult_t resetRet = CALEUpdateDeviceState ( address , CA_LE_SEND_STATE , STATE_SEND_NONE , g_deviceStateList , g_deviceStateListMutex ) ; if ( CA_STATUS_OK != resetRet ) { OIC_LOG_V ( ERROR , TAG , "CALEUpdateDeviceState<S2SV_blank>has<S2SV_blank>failed<S2SV_blank>(%d)" , resetRet ) ; ret = CA_SEND_FAILED ; } return ret ; error_exit : if ( isAttached ) { ( * g_jvm ) -> DetachCurrentThread ( g_jvm ) ; } oc_mutex_unlock ( g_threadSendMutex ) ; return CA_SEND_FAILED ; } | <S2SV_ModStart> jni_setAddress ) ; CALEDeleteSendBuffer ( env ) ; <S2SV_ModEnd> if ( data |
1,601 | CWE-000 static int dt2w_input_connect ( struct input_handler * handler , struct input_dev * dev , const struct input_device_id * id ) { struct input_handle * handle ; <S2SV_StartBug> int error ; <S2SV_EndBug> printk ( KERN_DEBUG "dt2w<S2SV_blank>:<S2SV_blank>dt2w_input_connect" ) ; if ( input_dev_filter ( dev ) ) return - ENODEV ; handle = kzalloc ( sizeof ( struct input_handle ) , GFP_KERNEL ) ; if ( ! handle ) return - ENOMEM ; handle -> dev = dev ; handle -> handler = handler ; handle -> name = "dt2w" ; error = input_register_handle ( handle ) ; if ( error ) goto err2 ; error = input_open_device ( handle ) ; if ( error ) goto err1 ; return 0 ; err1 : input_unregister_handle ( handle ) ; err2 : kfree ( handle ) ; return error ; } | <S2SV_ModStart> ; int error <S2SV_ModEnd> ; if ( |
1,602 | CWE-000 int read_pir ( void ) { FILE * fp ; if ( wiringPiSetup ( ) == - 1 ) return 1 ; pinMode ( 25 , INPUT ) ; delay ( 2000 ) ; printf ( "Process<S2SV_blank>2<S2SV_blank>:<S2SV_blank>Process<S2SV_blank>initialized!\\n" ) ; while ( 1 ) { if ( digitalRead ( 25 ) ) { printf ( "Process<S2SV_blank>2<S2SV_blank>:<S2SV_blank>Detected!\\n" ) ; fp = popen ( "raspistill<S2SV_blank>-o<S2SV_blank>-" , "r" ) ; if ( fp == NULL ) { printf ( "Process<S2SV_blank>2<S2SV_blank>:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>run<S2SV_blank>photo<S2SV_blank>capture<S2SV_blank>command\\n" ) ; } else { printf ( "Process<S2SV_blank>2<S2SV_blank>:<S2SV_blank>Command<S2SV_blank>has<S2SV_blank>started\\n" ) ; CURL * curl ; CURLcode res ; struct curl_httppost * formpost = NULL ; struct curl_httppost * lastptr = NULL ; struct curl_slist * headerlist = NULL ; static const char buf [ ] = "Expect:" ; char time_str [ 20 ] ; <S2SV_StartBug> itoa ( ( int ) time ( NULL ) , time_str , 10 ) ; <S2SV_EndBug> printf ( "Process<S2SV_blank>2:<S2SV_blank>Pass<S2SV_blank>1\\n" ) ; curl_global_init ( CURL_GLOBAL_ALL ) ; curl_formadd ( & formpost , & lastptr , CURLFORM_COPYNAME , "photo" , CURLFORM_COPYCONTENTS , fp , CURLFORM_CONTENTTYPE , "image/jpeg" , CURLFORM_END ) ; printf ( "Process<S2SV_blank>2:<S2SV_blank>Pass<S2SV_blank>2\\n" ) ; curl_formadd ( & formpost , & lastptr , CURLFORM_COPYNAME , "time" , CURLFORM_COPYCONTENTS , time_str , CURLFORM_END ) ; printf ( "Process<S2SV_blank>2:<S2SV_blank>Pass<S2SV_blank>3\\n" ) ; curl = curl_easy_init ( ) ; printf ( "Process<S2SV_blank>2:<S2SV_blank>Pass<S2SV_blank>4\\n" ) ; headerlist = curl_slist_append ( headerlist , buf ) ; if ( curl ) { printf ( "Process<S2SV_blank>2:<S2SV_blank>Pass<S2SV_blank>5\\n" ) ; curl_easy_setopt ( curl , CURLOPT_URL , "https://wiput.me" ) ; printf ( "Process<S2SV_blank>2:<S2SV_blank>Pass<S2SV_blank>6\\n" ) ; curl_easy_setopt ( curl , CURLOPT_HTTPPOST , formpost ) ; printf ( "Process<S2SV_blank>2:<S2SV_blank>Pass<S2SV_blank>7\\n" ) ; res = curl_easy_perform ( curl ) ; if ( res != CURLE_OK ) fprintf ( stderr , "curl_easy_perform()<S2SV_blank>failed:<S2SV_blank>%s\\n" , curl_easy_strerror ( res ) ) ; curl_easy_cleanup ( curl ) ; curl_formfree ( formpost ) ; curl_slist_free_all ( headerlist ) ; printf ( "Process<S2SV_blank>2<S2SV_blank>:<S2SV_blank>Command<S2SV_blank>successfully<S2SV_blank>run\\n" ) ; } else { printf ( "Process<S2SV_blank>2<S2SV_blank>:<S2SV_blank>Failed<S2SV_blank>to<S2SV_blank>run<S2SV_blank>curl\\n" ) ; } } pclose ( fp ) ; while ( digitalRead ( 25 ) ) ; } delay ( 2500 ) ; } } | <S2SV_ModStart> 20 ] ; snprintf ( time_str , 20 , "%d" , <S2SV_ModEnd> ( int ) <S2SV_ModStart> ( NULL ) <S2SV_ModEnd> ) ; printf |
1,603 | CWE-000 int import_cylindrical ( ndom , filename ) int ndom ; char * filename ; { FILE * fopen ( ) , * fptr ; char line [ LINELEN ] ; int n , icell , jcell , ncell , inwind ; double q1 , q2 , q3 , q4 , q5 , q6 , q7 ; int jz , jx ; double delta ; Log ( "Reading<S2SV_blank>a<S2SV_blank>model<S2SV_blank>in<S2SV_blank>cylindrical<S2SV_blank>coordinates<S2SV_blank>%s\\n" , filename ) ; if ( ( fptr = fopen ( filename , "r" ) ) == NULL ) { Error ( "import_cylindrical:<S2SV_blank>No<S2SV_blank>such<S2SV_blank>file\\n" ) ; exit ( 0 ) ; } ncell = 0 ; while ( fgets ( line , 512 , fptr ) != NULL ) { n = sscanf ( line , "<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%le<S2SV_blank>%le<S2SV_blank>%le<S2SV_blank>%le<S2SV_blank>%le<S2SV_blank>%le<S2SV_blank>%le" , & icell , & jcell , & inwind , & q1 , & q2 , & q3 , & q4 , & q5 , & q6 , & q7 ) ; if ( n < 4 ) { printf ( "Error.<S2SV_blank>Ignore<S2SV_blank>%s<S2SV_blank>\\n" , line ) ; continue ; } else { xx_cyl . i [ ncell ] = icell ; xx_cyl . j [ ncell ] = jcell ; xx_cyl . inwind [ ncell ] = inwind ; xx_cyl . x [ ncell ] = q1 ; xx_cyl . z [ ncell ] = q2 ; xx_cyl . v_x [ ncell ] = q3 ; xx_cyl . v_y [ ncell ] = q4 ; xx_cyl . v_z [ ncell ] = q5 ; xx_cyl . rho [ ncell ] = q6 ; if ( n > 10 ) { xx_cyl . t [ ncell ] = q7 ; } else { xx_cyl . t [ ncell ] = 10000. ; } ncell ++ ; } } xx_cyl . ndim = icell + 1 ; xx_cyl . mdim = jcell + 1 ; xx_cyl . ncell = ncell ; jz = jx = 0 ; for ( n = 0 ; n < xx_cyl . ncell ; n ++ ) { if ( xx_cyl . i [ n ] == 0 ) { xx_cyl . wind_z [ jz ] = xx_cyl . z [ n ] ; jz ++ ; } if ( xx_cyl . j [ n ] == 0 ) { xx_cyl . wind_x [ jx ] = xx_cyl . x [ n ] ; jx ++ ; } } for ( n = 0 ; n < jz - 1 ; n ++ ) { xx_cyl . wind_midz [ n ] = 0.5 * ( xx_cyl . wind_z [ n ] + xx_cyl . wind_z [ n + 1 ] ) ; } delta = ( xx_cyl . wind_z [ jz - 1 ] - xx_cyl . wind_z [ jz - 2 ] ) ; xx_cyl . wind_midz [ jz ] = xx_cyl . wind_z [ jz - 1 ] + 0.5 * delta ; for ( n = 0 ; n < jx - 1 ; n ++ ) { xx_cyl . wind_midx [ n ] = 0.5 * ( xx_cyl . wind_x [ n ] + xx_cyl . wind_x [ n + 1 ] ) ; } delta = ( xx_cyl . wind_x [ n - 1 ] - xx_cyl . wind_x [ n - 2 ] ) ; xx_cyl . wind_midx [ jx ] = xx_cyl . wind_x [ jx - 1 ] + 0.5 * delta ; Log ( "Gotcha<S2SV_blank>%d<S2SV_blank>%d<S2SV_blank>%d\\n" , xx_cyl . ncell , jz , jx ) ; <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> jx ) ; zdom [ ndom ] . ndim = xx_cyl . ndim ; zdom [ ndom ] . mdim = xx_cyl . mdim ; zdom [ ndom ] . ndim2 = xx_cyl . ndim * xx_cyl . mdim ; |
1,604 | CWE-000 bool hexBitstr2List ( char * bitstr , char * * list , size_t * listSize ) { size_t len ; int32_t next , count = 0 ; if ( ! bitstr ) { mlog ( "%s:<S2SV_blank>invalid<S2SV_blank>bitstring\\n" , __func__ ) ; return false ; } if ( ! strncmp ( bitstr , "0x" , 2 ) ) bitstr += 2 ; len = strlen ( bitstr ) ; while ( len -- ) { char tmp [ 1024 ] ; next = ( int32_t ) bitstr [ len ] ; if ( ! isxdigit ( next ) ) return false ; if ( isdigit ( next ) ) { next -= '0' ; } else { next = toupper ( next ) ; next -= 'A' - 10 ; } if ( next & 1 ) { if ( * listSize ) str2Buf ( "," , list , listSize ) ; <S2SV_StartBug> snprintf ( tmp , sizeof ( tmp ) , "%u" , count ) ; <S2SV_EndBug> str2Buf ( tmp , list , listSize ) ; } count ++ ; if ( next & 2 ) { if ( * listSize ) str2Buf ( "," , list , listSize ) ; <S2SV_StartBug> snprintf ( tmp , sizeof ( tmp ) , "%u" , count ) ; <S2SV_EndBug> str2Buf ( tmp , list , listSize ) ; } count ++ ; if ( next & 4 ) { if ( * listSize ) str2Buf ( "," , list , listSize ) ; <S2SV_StartBug> snprintf ( tmp , sizeof ( tmp ) , "%u" , count ) ; <S2SV_EndBug> str2Buf ( tmp , list , listSize ) ; } count ++ ; if ( next & 8 ) { if ( * listSize ) str2Buf ( "," , list , listSize ) ; <S2SV_StartBug> snprintf ( tmp , sizeof ( tmp ) , "%u" , count ) ; <S2SV_EndBug> str2Buf ( tmp , list , listSize ) ; } count ++ ; } return true ; } | <S2SV_ModStart> tmp ) , "%i" <S2SV_ModEnd> , count ) <S2SV_ModStart> tmp ) , "%i" <S2SV_ModEnd> , count ) <S2SV_ModStart> tmp ) , "%i" <S2SV_ModEnd> , count ) <S2SV_ModStart> tmp ) , "%i" <S2SV_ModEnd> , count ) |
1,605 | CWE-000 static int nkcfs_remove ( struct _file * filp ) { int cjddrive , jddrive ; char * pfilename , * pc1 , * pc2 ; struct ioctl_nkc_blk args ; pc1 = filp -> pname ; pc2 = pfilename = ( char * ) malloc ( strlen ( pc1 ) ) ; * pc2 = 0 ; if ( ! pfilename ) { printf ( "<S2SV_blank>error,<S2SV_blank>out<S2SV_blank>of<S2SV_blank>memory<S2SV_blank>(nkcfs_remove)\\n" ) ; return 1 ; } while ( * pc1 ) { if ( * pc1 != '/' ) { * pc2 ++ = toupper ( * pc1 ) ; } pc1 ++ ; } * pc2 = 0 ; # ifdef USE_JADOS <S2SV_StartBug> _nkc_remove ( pfilename ) ; <S2SV_EndBug> # else # endif free ( pfilename ) ; return 0 ; } | <S2SV_ModStart> # ifdef USE_JADOS jd_remove <S2SV_ModEnd> ( pfilename ) |
1,606 | CWE-000 <S2SV_StartBug> char * quickwhich ( char * command , struct pathelement * pathlist , bool freePath ) <S2SV_EndBug> { bool found = false ; <S2SV_StartBug> pathlist = get_path ( ) ; <S2SV_EndBug> freePath = true ; while ( pathlist ) { char str [ 256 ] ; strcpy ( str , pathlist -> element ) ; strcat ( str , "/" ) ; strcat ( str , command ) ; if ( access ( str , X_OK ) == 0 ) { strcpy ( command , str ) ; found = true ; break ; } pathlist = pathlist -> next ; } if ( found == false ) { return NULL ; } return command ; } | <S2SV_ModStart> pathelement * pathlist <S2SV_ModEnd> ) { bool <S2SV_ModStart> ; pathlist = pathlist -> head <S2SV_ModEnd> ; while ( |
1,607 | CWE-000 static int read_abbrevs ( struct backtrace_state * state , uint64_t abbrev_offset , const unsigned char * dwarf_abbrev , size_t dwarf_abbrev_size , int is_bigendian , backtrace_error_callback error_callback , void * data , struct abbrevs * abbrevs ) { struct dwarf_buf abbrev_buf ; struct dwarf_buf count_buf ; size_t num_abbrevs ; abbrevs -> num_abbrevs = 0 ; abbrevs -> abbrevs = NULL ; if ( abbrev_offset >= dwarf_abbrev_size ) { error_callback ( data , "abbrev<S2SV_blank>offset<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range" , 0 ) ; return 0 ; } abbrev_buf . name = ".debug_abbrev" ; abbrev_buf . start = dwarf_abbrev ; abbrev_buf . buf = dwarf_abbrev + abbrev_offset ; abbrev_buf . left = dwarf_abbrev_size - abbrev_offset ; abbrev_buf . is_bigendian = is_bigendian ; abbrev_buf . error_callback = error_callback ; abbrev_buf . data = data ; abbrev_buf . reported_underflow = 0 ; count_buf = abbrev_buf ; num_abbrevs = 0 ; while ( read_uleb128 ( & count_buf ) != 0 ) { if ( count_buf . reported_underflow ) return 0 ; ++ num_abbrevs ; read_uleb128 ( & count_buf ) ; read_byte ( & count_buf ) ; while ( read_uleb128 ( & count_buf ) != 0 ) read_uleb128 ( & count_buf ) ; read_uleb128 ( & count_buf ) ; } if ( count_buf . reported_underflow ) return 0 ; if ( num_abbrevs == 0 ) return 1 ; <S2SV_StartBug> abbrevs -> num_abbrevs = num_abbrevs ; <S2SV_EndBug> abbrevs -> abbrevs = ( ( struct abbrev * ) backtrace_alloc ( state , num_abbrevs * sizeof ( struct abbrev ) , error_callback , data ) ) ; if ( abbrevs -> abbrevs == NULL ) return 0 ; <S2SV_StartBug> memset ( abbrevs -> abbrevs , 0 , num_abbrevs * sizeof ( struct abbrev ) ) ; <S2SV_EndBug> num_abbrevs = 0 ; while ( 1 ) { uint64_t code ; struct abbrev a ; size_t num_attrs ; struct attr * attrs ; if ( abbrev_buf . reported_underflow ) goto fail ; code = read_uleb128 ( & abbrev_buf ) ; if ( code == 0 ) break ; a . code = code ; a . tag = ( enum dwarf_tag ) read_uleb128 ( & abbrev_buf ) ; a . has_children = read_byte ( & abbrev_buf ) ; count_buf = abbrev_buf ; num_attrs = 0 ; while ( read_uleb128 ( & count_buf ) != 0 ) { ++ num_attrs ; read_uleb128 ( & count_buf ) ; } if ( num_attrs == 0 ) { attrs = NULL ; read_uleb128 ( & abbrev_buf ) ; read_uleb128 ( & abbrev_buf ) ; } else { attrs = ( ( struct attr * ) backtrace_alloc ( state , num_attrs * sizeof * attrs , error_callback , data ) ) ; if ( attrs == NULL ) goto fail ; num_attrs = 0 ; while ( 1 ) { uint64_t name ; uint64_t form ; name = read_uleb128 ( & abbrev_buf ) ; form = read_uleb128 ( & abbrev_buf ) ; if ( name == 0 ) break ; attrs [ num_attrs ] . name = ( enum dwarf_attribute ) name ; attrs [ num_attrs ] . form = ( enum dwarf_form ) form ; ++ num_attrs ; } } a . num_attrs = num_attrs ; a . attrs = attrs ; abbrevs -> abbrevs [ num_abbrevs ] = a ; ++ num_abbrevs ; } backtrace_qsort ( abbrevs -> abbrevs , abbrevs -> num_abbrevs , sizeof ( struct abbrev ) , abbrev_compare ) ; return 1 ; fail : free_abbrevs ( state , abbrevs , error_callback , data ) ; return 0 ; } | <S2SV_ModStart> ; abbrevs -> <S2SV_ModEnd> abbrevs = ( <S2SV_ModStart> return 0 ; abbrevs -> num_abbrevs = num_abbrevs ; |
1,608 | CWE-000 static struct netvsc_device * alloc_net_device ( void ) { struct netvsc_device * net_device ; net_device = kzalloc ( sizeof ( struct netvsc_device ) , GFP_KERNEL ) ; if ( ! net_device ) return NULL ; init_waitqueue_head ( & net_device -> wait_drain ) ; net_device -> destroy = false ; net_device -> max_pkt = RNDIS_MAX_PKT_DEFAULT ; net_device -> pkt_align = RNDIS_PKT_ALIGN_DEFAULT ; init_completion ( & net_device -> channel_init_wait ) ; init_waitqueue_head ( & net_device -> subchan_open ) ; <S2SV_StartBug> INIT_WORK ( & net_device -> subchan_work , rndis_set_subchannel ) ; <S2SV_EndBug> return net_device ; } | <S2SV_ModStart> -> subchan_work , netvsc_subchan_work <S2SV_ModEnd> ) ; return |
1,609 | CWE-000 static void sighandler_kill ( int sig , siginfo_t * info , void * ucontext ) { debug ( "killed<S2SV_blank>by<S2SV_blank>%s\\n" , signal_name ( sig ) ) ; if ( ! info -> si_pid ) switch ( sig ) { case SIGTERM : case SIGINT : shim_do_kill ( - 1 , sig ) ; break ; } <S2SV_StartBug> try_process_exit ( 0 ) ; <S2SV_EndBug> DkThreadExit ( ) ; } | <S2SV_ModStart> try_process_exit ( 0 , sig |
1,610 | CWE-000 qboolean SV_Push ( edict_t * pusher , vec3_t move , vec3_t amove ) { int i , e ; edict_t * check , * block ; vec3_t mins , maxs ; pushed_t * p ; <S2SV_StartBug> vec3_t org , org2 , move2 , forward , right , up ; <S2SV_EndBug> for ( i = 0 ; i < 3 ; i ++ ) { float temp ; temp = move [ i ] * 8.0 ; if ( temp > 0.0 ) temp += 0.5 ; else temp -= 0.5 ; move [ i ] = 0.125 * ( int ) temp ; } for ( i = 0 ; i < 3 ; i ++ ) { mins [ i ] = pusher -> absmin [ i ] + move [ i ] ; maxs [ i ] = pusher -> absmax [ i ] + move [ i ] ; } VectorSubtract ( vec3_origin , amove , org ) ; AngleVectors ( org , forward , right , up ) ; pushed_p -> ent = pusher ; VectorCopy ( pusher -> s . origin , pushed_p -> origin ) ; VectorCopy ( pusher -> s . angles , pushed_p -> angles ) ; if ( pusher -> client ) pushed_p -> deltayaw = pusher -> client -> ps . pmove . delta_angles [ YAW ] ; pushed_p ++ ; VectorAdd ( pusher -> s . origin , move , pusher -> s . origin ) ; VectorAdd ( pusher -> s . angles , amove , pusher -> s . angles ) ; gi . linkentity ( pusher ) ; <S2SV_StartBug> check = g_edicts + 1 ; <S2SV_EndBug> for ( e = 1 ; e < globals . num_edicts ; e ++ , check ++ ) { if ( ! check -> inuse ) continue ; if ( check -> movetype == MOVETYPE_PUSH || check -> movetype == MOVETYPE_STOP || check -> movetype == MOVETYPE_NONE || check -> movetype == MOVETYPE_NOCLIP ) continue ; if ( ! check -> area . prev ) continue ; if ( check -> groundentity != pusher ) { <S2SV_StartBug> if ( check -> absmin [ 0 ] >= maxs [ 0 ] <S2SV_EndBug> <S2SV_StartBug> || check -> absmin [ 1 ] >= maxs [ 1 ] <S2SV_EndBug> <S2SV_StartBug> || check -> absmin [ 2 ] >= maxs [ 2 ] <S2SV_EndBug> <S2SV_StartBug> || check -> absmax [ 0 ] <= mins [ 0 ] <S2SV_EndBug> <S2SV_StartBug> || check -> absmax [ 1 ] <= mins [ 1 ] <S2SV_EndBug> <S2SV_StartBug> || check -> absmax [ 2 ] <= mins [ 2 ] ) <S2SV_EndBug> continue ; if ( ! SV_TestEntityPosition ( check ) ) continue ; } if ( ( pusher -> movetype == MOVETYPE_PUSH ) || ( check -> groundentity == pusher ) ) { pushed_p -> ent = check ; VectorCopy ( check -> s . origin , pushed_p -> origin ) ; VectorCopy ( check -> s . angles , pushed_p -> angles ) ; pushed_p ++ ; VectorAdd ( check -> s . origin , move , check -> s . origin ) ; if ( check -> client ) { check -> client -> ps . pmove . delta_angles [ YAW ] += amove [ YAW ] ; } VectorSubtract ( check -> s . origin , pusher -> s . origin , org ) ; org2 [ 0 ] = DotProduct ( org , forward ) ; org2 [ 1 ] = - DotProduct ( org , right ) ; org2 [ 2 ] = DotProduct ( org , up ) ; VectorSubtract ( org2 , org , move2 ) ; VectorAdd ( check -> s . origin , move2 , check -> s . origin ) ; if ( check -> groundentity != pusher ) check -> groundentity = NULL ; block = SV_TestEntityPosition ( check ) ; if ( ! block ) { gi . linkentity ( check ) ; continue ; } VectorSubtract ( check -> s . origin , move , check -> s . origin ) ; block = SV_TestEntityPosition ( check ) ; if ( ! block ) { pushed_p -- ; continue ; } } obstacle = check ; for ( p = pushed_p - 1 ; p >= pushed ; p -- ) { VectorCopy ( p -> origin , p -> ent -> s . origin ) ; VectorCopy ( p -> angles , p -> ent -> s . angles ) ; if ( p -> ent -> client ) { p -> ent -> client -> ps . pmove . delta_angles [ YAW ] = p -> deltayaw ; } gi . linkentity ( p -> ent ) ; } return false ; } for ( p = pushed_p - 1 ; p >= pushed ; p -- ) G_TouchTriggers ( p -> ent ) ; return true ; } | <S2SV_ModStart> right , up ; vec3_t realmins , realmaxs <S2SV_ModStart> pusher ) ; SV_RealBoundingBox ( pusher , realmins , realmaxs ) ; <S2SV_ModStart> 0 ] >= realmaxs <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> 1 ] >= realmaxs <S2SV_ModEnd> [ 1 ] <S2SV_ModStart> 2 ] >= realmaxs <S2SV_ModEnd> [ 2 ] <S2SV_ModStart> 0 ] <= realmins <S2SV_ModEnd> [ 0 ] <S2SV_ModStart> 1 ] <= realmins <S2SV_ModEnd> [ 1 ] <S2SV_ModStart> 2 ] <= realmins <S2SV_ModEnd> [ 2 ] |
1,611 | CWE-000 BT_HIDDEN struct bt_ctf_packet * debug_info_new_packet ( struct debug_info_iterator * debug_it , struct bt_ctf_packet * packet ) { struct bt_ctf_stream * stream = NULL , * writer_stream = NULL ; struct bt_ctf_field * writer_packet_context = NULL ; <S2SV_StartBug> struct bt_ctf_packet * writer_packet = NULL ; <S2SV_EndBug> struct debug_info_trace * di_trace ; int int_ret ; stream = bt_ctf_packet_get_stream ( packet ) ; if ( ! stream ) { fprintf ( debug_it -> err , "[error]<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>%s:%d\\n" , __func__ , __FILE__ , __LINE__ ) ; goto error ; } writer_stream = get_writer_stream ( debug_it , packet , stream ) ; if ( ! writer_stream ) { fprintf ( debug_it -> err , "[error]<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>%s:%d\\n" , __func__ , __FILE__ , __LINE__ ) ; goto error ; } di_trace = lookup_di_trace_from_stream ( debug_it , stream ) ; if ( ! di_trace ) { fprintf ( debug_it -> err , "[error]<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>%s:%d\\n" , __func__ , __FILE__ , __LINE__ ) ; goto error ; } writer_packet = lookup_packet ( debug_it , packet , di_trace ) ; if ( writer_packet ) { g_hash_table_remove ( di_trace -> packet_map , packet ) ; BT_PUT ( writer_packet ) ; } writer_packet = insert_new_packet ( debug_it , packet , writer_stream , di_trace ) ; if ( ! writer_packet ) { fprintf ( debug_it -> err , "[error]<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>%s:%d\\n" , __func__ , __FILE__ , __LINE__ ) ; goto error ; } <S2SV_StartBug> writer_packet_context = ctf_copy_packet_context ( debug_it -> err , packet , <S2SV_EndBug> writer_stream ) ; if ( ! writer_packet_context ) { fprintf ( debug_it -> err , "[error]<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>%s:%d\\n" , __func__ , __FILE__ , __LINE__ ) ; goto error ; } <S2SV_StartBug> int_ret = bt_ctf_packet_set_context ( writer_packet , writer_packet_context ) ; <S2SV_EndBug> if ( int_ret ) { fprintf ( debug_it -> err , "[error]<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>%s:%d\\n" , __func__ , __FILE__ , __LINE__ ) ; goto error ; } bt_get ( writer_packet ) ; goto end ; error : end : <S2SV_StartBug> bt_put ( writer_packet_context ) ; <S2SV_EndBug> bt_put ( writer_stream ) ; bt_put ( stream ) ; return writer_packet ; } | <S2SV_ModStart> bt_ctf_packet * writer_packet = NULL ; struct bt_ctf_field * packet_context <S2SV_ModStart> error ; } packet_context = bt_ctf_packet_get_context ( packet ) ; if ( packet_context ) { <S2SV_ModStart> -> err , packet , <S2SV_ModEnd> writer_stream ) ; <S2SV_ModStart> error ; } BT_PUT ( packet_context ) ; } <S2SV_ModStart> : bt_put ( packet_context ) ; bt_put ( |
1,612 | CWE-000 int command_handle ( char * * argument_list ) { <S2SV_StartBug> int child1 = fork ( ) ; <S2SV_EndBug> if ( ! child1 ) { <S2SV_StartBug> execvp ( argument_list [ 0 ] , argument_list ) ; <S2SV_EndBug> if ( execvp ( * argument_list , argument_list ) < 0 ) { printf ( "ERROR<S2SV_blank>MESSAGE:<S2SV_blank>Zoo<S2SV_blank>Wee<S2SV_blank>Mama!<S2SV_blank><S2SV_blank>Invalid<S2SV_blank>command!\\n" ) ; <S2SV_StartBug> exit ( 1 ) ; <S2SV_EndBug> } } <S2SV_StartBug> else { <S2SV_EndBug> int status = 0 ; wait ( & status ) ; return ( WEXITSTATUS ( status ) ) ; } } | <S2SV_ModStart> argument_list ) { if ( ! <S2SV_ModEnd> fork ( ) <S2SV_ModStart> fork ( ) ) { if ( <S2SV_ModEnd> execvp ( argument_list <S2SV_ModStart> [ 0 ] <S2SV_ModEnd> , argument_list ) <S2SV_ModStart> "ERROR<S2SV_blank>MESSAGE:<S2SV_blank>Zoo<S2SV_blank>Wee<S2SV_blank>Mama!<S2SV_blank><S2SV_blank>Invalid<S2SV_blank>command!\\n" ) ; } <S2SV_ModStart> ; } } <S2SV_ModEnd> <S2SV_null> <S2SV_null> <S2SV_null> |
1,613 | CWE-000 void tableRemoveWhite ( Table * table ) { <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> table ) { for ( int i = 0 ; i <= table -> capacityMask ; i ++ ) { Entry * entry = & table -> entries [ i ] ; if ( entry -> key != NULL && ! entry -> key -> object . isDark ) { tableDelete ( table , entry -> key ) ; } } |
1,614 | CWE-000 void DMAPageWrite ( uint32_t PhysAddress , const void * DataWrite , uint32_t TotalSize ) { <S2SV_StartBug> memcpy ( & ram [ PhysAddress ] , DataWrite , TotalSize ) ; <S2SV_EndBug> <S2SV_StartBug> mem_invalidate_range ( PhysAddress , PhysAddress + TotalSize - 1 ) ; <S2SV_EndBug> DataWrite -= TotalSize ; } | <S2SV_ModStart> TotalSize ) { mem_invalidate_range ( PhysAddress , PhysAddress + TotalSize - 1 ) ; <S2SV_ModStart> TotalSize ) ; <S2SV_ModEnd> DataWrite -= TotalSize |
1,615 | CWE-000 static void gst_xv_image_sink_class_init ( GstXvImageSinkClass * klass ) { GObjectClass * gobject_class ; GstElementClass * gstelement_class ; GstBaseSinkClass * gstbasesink_class ; GstVideoSinkClass * videosink_class ; gobject_class = ( GObjectClass * ) klass ; gstelement_class = ( GstElementClass * ) klass ; gstbasesink_class = ( GstBaseSinkClass * ) klass ; videosink_class = ( GstVideoSinkClass * ) klass ; parent_class = g_type_class_peek_parent ( klass ) ; gobject_class -> set_property = gst_xv_image_sink_set_property ; gobject_class -> get_property = gst_xv_image_sink_get_property ; g_object_class_install_property ( gobject_class , PROP_CONTRAST , g_param_spec_int ( "contrast" , "Contrast" , "The<S2SV_blank>contrast<S2SV_blank>of<S2SV_blank>the<S2SV_blank>video" , - 1000 , 1000 , 0 , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_BRIGHTNESS , g_param_spec_int ( "brightness" , "Brightness" , "The<S2SV_blank>brightness<S2SV_blank>of<S2SV_blank>the<S2SV_blank>video" , - 1000 , 1000 , 0 , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_HUE , g_param_spec_int ( "hue" , "Hue" , "The<S2SV_blank>hue<S2SV_blank>of<S2SV_blank>the<S2SV_blank>video" , - 1000 , 1000 , 0 , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_SATURATION , g_param_spec_int ( "saturation" , "Saturation" , "The<S2SV_blank>saturation<S2SV_blank>of<S2SV_blank>the<S2SV_blank>video" , - 1000 , 1000 , 0 , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_DISPLAY , g_param_spec_string ( "display" , "Display" , "X<S2SV_blank>Display<S2SV_blank>name" , NULL , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_SYNCHRONOUS , g_param_spec_boolean ( "synchronous" , "Synchronous" , "When<S2SV_blank>enabled,<S2SV_blank>runs<S2SV_blank>the<S2SV_blank>X<S2SV_blank>display<S2SV_blank>in<S2SV_blank>synchronous<S2SV_blank>mode.<S2SV_blank>" "(unrelated<S2SV_blank>to<S2SV_blank>A/V<S2SV_blank>sync,<S2SV_blank>used<S2SV_blank>only<S2SV_blank>for<S2SV_blank>debugging)" , FALSE , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_PIXEL_ASPECT_RATIO , g_param_spec_string ( "pixel-aspect-ratio" , "Pixel<S2SV_blank>Aspect<S2SV_blank>Ratio" , "The<S2SV_blank>pixel<S2SV_blank>aspect<S2SV_blank>ratio<S2SV_blank>of<S2SV_blank>the<S2SV_blank>device" , "1/1" , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_FORCE_ASPECT_RATIO , g_param_spec_boolean ( "force-aspect-ratio" , "Force<S2SV_blank>aspect<S2SV_blank>ratio" , "When<S2SV_blank>enabled,<S2SV_blank>scaling<S2SV_blank>will<S2SV_blank>respect<S2SV_blank>original<S2SV_blank>aspect<S2SV_blank>ratio" , TRUE , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_HANDLE_EVENTS , g_param_spec_boolean ( "handle-events" , "Handle<S2SV_blank>XEvents" , "When<S2SV_blank>enabled,<S2SV_blank>XEvents<S2SV_blank>will<S2SV_blank>be<S2SV_blank>selected<S2SV_blank>and<S2SV_blank>handled" , TRUE , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_DEVICE , g_param_spec_string ( "device" , "Adaptor<S2SV_blank>number" , "The<S2SV_blank>number<S2SV_blank>of<S2SV_blank>the<S2SV_blank>video<S2SV_blank>adaptor" , "0" , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_DEVICE_NAME , g_param_spec_string ( "device-name" , "Adaptor<S2SV_blank>name" , "The<S2SV_blank>name<S2SV_blank>of<S2SV_blank>the<S2SV_blank>video<S2SV_blank>adaptor" , NULL , G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ) ; gst_video_overlay_install_properties ( gobject_class , PROP_LAST ) ; g_object_class_install_property ( gobject_class , PROP_HANDLE_EXPOSE , g_param_spec_boolean ( "handle-expose" , "Handle<S2SV_blank>expose" , "When<S2SV_blank>enabled,<S2SV_blank>" "the<S2SV_blank>current<S2SV_blank>frame<S2SV_blank>will<S2SV_blank>always<S2SV_blank>be<S2SV_blank>drawn<S2SV_blank>in<S2SV_blank>response<S2SV_blank>to<S2SV_blank>X<S2SV_blank>Expose<S2SV_blank>" "events" , TRUE , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_DOUBLE_BUFFER , g_param_spec_boolean ( "double-buffer" , "Double-buffer" , "Whether<S2SV_blank>to<S2SV_blank>double-buffer<S2SV_blank>the<S2SV_blank>output" , TRUE , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_AUTOPAINT_COLORKEY , g_param_spec_boolean ( "autopaint-colorkey" , "Autofill<S2SV_blank>with<S2SV_blank>colorkey" , "Whether<S2SV_blank>to<S2SV_blank>autofill<S2SV_blank>overlay<S2SV_blank>with<S2SV_blank>colorkey" , TRUE , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_COLORKEY , g_param_spec_int ( "colorkey" , "Colorkey" , "Color<S2SV_blank>to<S2SV_blank>use<S2SV_blank>for<S2SV_blank>the<S2SV_blank>overlay<S2SV_blank>mask" , G_MININT , G_MAXINT , 0 , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_DRAW_BORDERS , g_param_spec_boolean ( "draw-borders" , "Draw<S2SV_blank>Borders" , "Draw<S2SV_blank>black<S2SV_blank>borders<S2SV_blank>to<S2SV_blank>fill<S2SV_blank>unused<S2SV_blank>area<S2SV_blank>in<S2SV_blank>force-aspect-ratio<S2SV_blank>mode" , TRUE , G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_WINDOW_WIDTH , g_param_spec_uint64 ( "window-width" , "window-width" , "Width<S2SV_blank>of<S2SV_blank>the<S2SV_blank>window" , 0 , G_MAXUINT64 , 0 , G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ) ; g_object_class_install_property ( gobject_class , PROP_WINDOW_HEIGHT , g_param_spec_uint64 ( "window-height" , "window-height" , "Height<S2SV_blank>of<S2SV_blank>the<S2SV_blank>window" , 0 , G_MAXUINT64 , 0 , G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ) ; gobject_class -> finalize = gst_xv_image_sink_finalize ; gst_element_class_set_static_metadata ( gstelement_class , "Video<S2SV_blank>sink" , "Sink/Video" , "A<S2SV_blank>Xv<S2SV_blank>based<S2SV_blank>videosink" , "Julien<S2SV_blank>Moutte<S2SV_blank><julien@moutte.net>" ) ; gst_element_class_add_static_pad_template ( gstelement_class , & gst_xv_image_sink_sink_template_factory ) ; gstelement_class -> change_state = GST_DEBUG_FUNCPTR ( gst_xv_image_sink_change_state ) ; gstbasesink_class -> get_caps = GST_DEBUG_FUNCPTR ( gst_xv_image_sink_getcaps ) ; gstbasesink_class -> set_caps = GST_DEBUG_FUNCPTR ( gst_xv_image_sink_setcaps ) ; gstbasesink_class -> get_times = GST_DEBUG_FUNCPTR ( gst_xv_image_sink_get_times ) ; gstbasesink_class -> propose_allocation = GST_DEBUG_FUNCPTR ( gst_xv_image_sink_propose_allocation ) ; gstbasesink_class -> event = GST_DEBUG_FUNCPTR ( gst_xv_image_sink_event ) ; videosink_class -> show_frame = GST_DEBUG_FUNCPTR ( gst_xv_image_sink_show_frame ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> gst_xv_image_sink_show_frame ) ; GST_DEBUG_CATEGORY_GET ( GST_CAT_PERFORMANCE , "GST_PERFORMANCE" ) ; |
1,616 | CWE-000 static void resolve_assoc_var ( gfc_symbol * sym , bool resolve_target ) { gfc_expr * target ; gcc_assert ( sym -> assoc ) ; gcc_assert ( sym -> attr . flavor == FL_VARIABLE ) ; target = sym -> assoc -> target ; if ( ! target ) return ; gcc_assert ( ! sym -> assoc -> dangling ) ; if ( resolve_target && ! gfc_resolve_expr ( target ) ) return ; if ( target -> expr_type == EXPR_VARIABLE ) { gfc_symbol * tsym ; gcc_assert ( target -> symtree ) ; tsym = target -> symtree -> n . sym ; sym -> attr . asynchronous = tsym -> attr . asynchronous ; sym -> attr . volatile_ = tsym -> attr . volatile_ ; sym -> attr . target = tsym -> attr . target || gfc_expr_attr ( target ) . pointer ; if ( is_subref_array ( target ) ) sym -> attr . subref_array_pointer = 1 ; } <S2SV_StartBug> if ( sym -> ts . type == BT_UNKNOWN ) <S2SV_EndBug> sym -> ts = target -> ts ; gcc_assert ( sym -> ts . type != BT_UNKNOWN ) ; sym -> assoc -> variable = ( target -> expr_type == EXPR_VARIABLE && ! gfc_has_vector_subscript ( target ) ) ; if ( sym -> attr . dimension && target -> rank == 0 ) { if ( sym -> ts . type != BT_CHARACTER ) gfc_error ( "Associate-name<S2SV_blank>%qs<S2SV_blank>at<S2SV_blank>%L<S2SV_blank>is<S2SV_blank>used<S2SV_blank>as<S2SV_blank>array" , sym -> name , & sym -> declared_at ) ; sym -> attr . dimension = 0 ; return ; } if ( target -> ts . type == BT_CLASS && gfc_ref_needs_temporary_p ( target -> ref ) ) { gfc_error ( "CLASS<S2SV_blank>selector<S2SV_blank>at<S2SV_blank>%L<S2SV_blank>needs<S2SV_blank>a<S2SV_blank>temporary<S2SV_blank>which<S2SV_blank>is<S2SV_blank>not<S2SV_blank>" "yet<S2SV_blank>implemented" , & target -> where ) ; return ; } if ( target -> ts . type == BT_CLASS ) gfc_fix_class_refs ( target ) ; if ( target -> rank != 0 ) { gfc_array_spec * as ; if ( sym -> ts . type != BT_CLASS && ( ! sym -> as || sym -> assoc -> rankguessed ) ) { if ( ! sym -> as ) sym -> as = gfc_get_array_spec ( ) ; as = sym -> as ; as -> rank = target -> rank ; as -> type = AS_DEFERRED ; as -> corank = gfc_get_corank ( target ) ; sym -> attr . dimension = 1 ; if ( as -> corank != 0 ) sym -> attr . codimension = 1 ; } } else { if ( sym -> ts . type == BT_CLASS && CLASS_DATA ( sym ) -> as ) { gfc_array_spec * as ; symbol_attribute attr ; gfc_typespec * ts = & target -> ts ; gfc_ref * ref ; gfc_component * c ; for ( ref = target -> ref ; ref != NULL ; ref = ref -> next ) { switch ( ref -> type ) { case REF_COMPONENT : ts = & ref -> u . c . component -> ts ; break ; case REF_ARRAY : if ( ts -> type == BT_CLASS ) ts = & ts -> u . derived -> components -> ts ; break ; default : break ; } } as = NULL ; sym -> ts = * ts ; sym -> ts . type = BT_CLASS ; attr = CLASS_DATA ( sym ) -> attr ; attr . class_ok = 0 ; attr . associate_var = 1 ; attr . dimension = attr . codimension = 0 ; attr . class_pointer = 1 ; if ( ! gfc_build_class_symbol ( & sym -> ts , & attr , & as ) ) gcc_unreachable ( ) ; c = gfc_find_component ( sym -> ts . u . derived , "_vptr" , true , true , NULL ) ; if ( c -> ts . u . derived == NULL ) c -> ts . u . derived = gfc_find_derived_vtab ( sym -> ts . u . derived ) ; CLASS_DATA ( sym ) -> attr . pointer = 1 ; CLASS_DATA ( sym ) -> attr . class_pointer = 1 ; gfc_set_sym_referenced ( sym -> ts . u . derived ) ; gfc_commit_symbol ( sym -> ts . u . derived ) ; if ( c -> ts . u . derived -> attr . vtab ) c -> ts . u . derived = c -> ts . u . derived -> ts . u . derived ; c -> ts . u . derived -> ns -> types_resolved = 0 ; resolve_types ( c -> ts . u . derived -> ns ) ; } } sym -> attr . associate_var = 1 ; if ( sym -> ts . type == BT_CHARACTER && ! sym -> attr . select_type_temporary ) { if ( ! sym -> ts . u . cl ) sym -> ts . u . cl = target -> ts . u . cl ; if ( ! sym -> ts . u . cl -> length ) sym -> ts . u . cl -> length = gfc_get_int_expr ( gfc_default_integer_kind , NULL , target -> value . character . length ) ; } if ( sym -> ts . type == BT_CLASS && gfc_expr_attr ( target ) . class_ok ) sym -> attr . class_ok = 1 ; } | <S2SV_ModStart> } if ( target -> expr_type == EXPR_NULL ) { gfc_error ( "Selector<S2SV_blank>at<S2SV_blank>%L<S2SV_blank>cannot<S2SV_blank>be<S2SV_blank>NULL()" , & target -> where ) ; return ; } else if ( target -> ts . type == BT_UNKNOWN ) { gfc_error ( "Selector<S2SV_blank>at<S2SV_blank>%L<S2SV_blank>has<S2SV_blank>no<S2SV_blank>type" , & target -> where ) ; return ; } if ( |
1,617 | CWE-000 <S2SV_StartBug> void rotateMe ( float * angle ) { <S2SV_EndBug> if ( abs ( * angle ) > 0.01 ) { <S2SV_StartBug> telega . leftwheel . task = ( * angle ) / 57.2958 * ( DISTANCEBTWWHEELS / 2 ) * TICKSPERROTATION * 2 * PI ; <S2SV_EndBug> telega . rightwheel . task = telega . leftwheel . task ; * angle = 0 ; } <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> float * angle ) { if ( telega . traekenable == 1 <S2SV_ModStart> angle ) / 360 * PI * DISTANCEBTWWHEELS <S2SV_ModEnd> ; telega . <S2SV_ModStart> ; } } } |
1,618 | CWE-000 void qla2x00_async_iocb_timeout ( void * data ) { srb_t * sp = data ; fc_port_t * fcport = sp -> fcport ; struct srb_iocb * lio = & sp -> u . iocb_cmd ; struct event_arg ea ; if ( fcport ) { ql_dbg ( ql_dbg_disc , fcport -> vha , 0x2071 , "Async-%s<S2SV_blank>timeout<S2SV_blank>-<S2SV_blank>hdl=%x<S2SV_blank>portid=%06x<S2SV_blank>%8phC.\\n" , sp -> name , sp -> handle , fcport -> d_id . b24 , fcport -> port_name ) ; fcport -> flags &= ~ ( FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE ) ; } else { pr_info ( "Async-%s<S2SV_blank>timeout<S2SV_blank>-<S2SV_blank>hdl=%x.\\n" , sp -> name , sp -> handle ) ; } switch ( sp -> type ) { <S2SV_StartBug> case SRB_LOGIN_CMD : <S2SV_EndBug> lio -> u . logio . data [ 0 ] = MBS_COMMAND_ERROR ; lio -> u . logio . data [ 1 ] = lio -> u . logio . flags & SRB_LOGIN_RETRIED ? QLA_LOGIO_LOGIN_RETRIED : 0 ; memset ( & ea , 0 , sizeof ( ea ) ) ; ea . event = FCME_PLOGI_DONE ; ea . fcport = sp -> fcport ; ea . data [ 0 ] = lio -> u . logio . data [ 0 ] ; ea . data [ 1 ] = lio -> u . logio . data [ 1 ] ; ea . sp = sp ; qla24xx_handle_plogi_done_event ( fcport -> vha , & ea ) ; break ; case SRB_LOGOUT_CMD : <S2SV_StartBug> qlt_logo_completion_handler ( fcport , QLA_FUNCTION_TIMEOUT ) ; <S2SV_EndBug> break ; case SRB_CT_PTHRU_CMD : case SRB_MB_IOCB : case SRB_NACK_PLOGI : case SRB_NACK_PRLI : case SRB_NACK_LOGO : case SRB_CTRL_VP : sp -> done ( sp , QLA_FUNCTION_TIMEOUT ) ; break ; } } | <S2SV_ModStart> case SRB_LOGIN_CMD : if ( ! fcport ) break ; <S2SV_ModStart> case SRB_LOGOUT_CMD : if ( ! fcport ) break ; |
1,619 | CWE-000 static long uvc_v4l2_ioctl ( struct file * file , unsigned int cmd , unsigned long arg ) { if ( uvc_trace_param & UVC_TRACE_IOCTL ) { uvc_printk ( KERN_DEBUG , "uvc_v4l2_ioctl(" ) ; <S2SV_StartBug> v4l_printk_ioctl ( cmd ) ; <S2SV_EndBug> printk ( ")\\n" ) ; } return video_usercopy ( file , cmd , arg , uvc_v4l2_do_ioctl ) ; } | <S2SV_ModStart> "uvc_v4l2_ioctl(" ) ; <S2SV_ModEnd> printk ( ")\\n" |
1,620 | CWE-000 int rating ( char * nick , char sim_w_l ) { users mmr [ 20 ] ; users tmp ; int ind = 0 ; int size = 0 ; int sw = 0 ; FILE * pf = fopen ( "rating.txt" , "r" ) ; for ( int i = 0 ; addstr ( pf , & mmr [ i ] ) != - 1 ; i ++ ) { size = i + 1 ; } fclose ( pf ) ; ind = prow ( nick , mmr ) ; if ( ind != - 1 ) { if ( sim_w_l == 'L' ) { mmr [ ind ] . lose ++ ; } if ( sim_w_l == 'W' ) { mmr [ ind ] . win ++ ; } } else { if ( sim_w_l == 'L' ) { nousl ( size , mmr , nick ) ; <S2SV_StartBug> } <S2SV_EndBug> if ( sim_w_l == 'W' ) { nousw ( size , mmr , nick ) ; <S2SV_StartBug> } <S2SV_EndBug> } for ( int i = 0 ; i < size ; i ++ ) { for ( int j = 0 ; j < ( size - i - 1 ) ; j ++ ) { if ( mmr [ j ] . n < mmr [ j + 1 ] . n ) { sw = mmr [ j ] . num ; mmr [ j ] . num = mmr [ j + 1 ] . num ; mmr [ j + 1 ] . num = sw ; tmp = mmr [ j ] ; mmr [ j ] = mmr [ j + 1 ] ; mmr [ j + 1 ] = tmp ; } } } FILE * pfin = fopen ( "rating.txt" , "w" ) ; in_f ( mmr , pfin , size , nick ) ; fclose ( pfin ) ; char menu ; <S2SV_StartBug> printf ( "Желаете<S2SV_blank>вывести<S2SV_blank>статистику?\\n" ) ; <S2SV_EndBug> printf ( "y/n\\n" ) ; scanf ( "%c" , & menu ) ; if ( menu == 'y' ) { out ( size , nick ) ; } <S2SV_StartBug> if ( menu == 'n' ) { <S2SV_EndBug> system ( "clear" ) ; printf ( "Ничего<S2SV_blank>страшного,<S2SV_blank>посмотрите<S2SV_blank>в<S2SV_blank>следующий<S2SV_blank>раз<S2SV_blank>;-)\\n" ) ; } } | <S2SV_ModStart> nick ) ; size ++ ; <S2SV_ModStart> nick ) ; size ++ ; <S2SV_ModStart> char menu ; system ( "clear" ) ; <S2SV_ModStart> printf ( "Желаете<S2SV_blank>вывести<S2SV_blank>статистику?\\n" <S2SV_ModEnd> "y/n\\n" ) ; <S2SV_ModStart> ) ; } else <S2SV_ModEnd> { system ( |
1,621 | CWE-000 void iemgui_label_font ( void * x , t_iemgui * iemgui , t_symbol * s , int ac , t_atom * av ) { int zoom = glist_getzoom ( iemgui -> x_glist ) ; int f = ( int ) atom_getfloatarg ( 0 , ac , av ) ; if ( f == 1 ) strcpy ( iemgui -> x_font , "helvetica" ) ; else if ( f == 2 ) strcpy ( iemgui -> x_font , "times" ) ; else { f = 0 ; strcpy ( iemgui -> x_font , sys_font ) ; } iemgui -> x_fsf . x_font_style = f ; f = ( int ) atom_getfloatarg ( 1 , ac , av ) ; if ( f < 4 ) f = 4 ; iemgui -> x_fontsize = f ; <S2SV_StartBug> if ( glist_isvisible ( iemgui -> x_glist ) ) <S2SV_EndBug> sys_vgui ( ".x%lx.c<S2SV_blank>itemconfigure<S2SV_blank>%lxLABEL<S2SV_blank>-font<S2SV_blank>{{%s}<S2SV_blank>-%d<S2SV_blank>%s}\\n" , glist_getcanvas ( iemgui -> x_glist ) , x , iemgui -> x_font , iemgui -> x_fontsize * zoom , sys_fontweight ) ; } | <S2SV_ModStart> ; if ( gobj_shouldvis ( & iemgui -> x_obj . te_g , <S2SV_ModEnd> iemgui -> x_glist |
1,622 | CWE-000 static void init_layers ( void ) { new_empty_layer ( & graphics . video_layers [ BOARD_LAYER ] , 0 , 0 , SCREEN_W , SCREEN_H , LAYER_DRAWORDER_BOARD ) ; new_empty_layer ( & graphics . video_layers [ OVERLAY_LAYER ] , <S2SV_StartBug> 0 , 0 , SCREEN_W , SCREEN_H , LAYER_DRAWORDER_OVERLAY ) ; <S2SV_EndBug> new_empty_layer ( & graphics . video_layers [ UI_LAYER ] , 0 , 0 , SCREEN_W , SCREEN_H , LAYER_DRAWORDER_UI ) ; select_layer ( UI_LAYER ) ; graphics . video_layers [ BOARD_LAYER ] . mode = graphics . screen_mode ; graphics . video_layers [ OVERLAY_LAYER ] . mode = graphics . screen_mode ; <S2SV_StartBug> graphics . video_layers [ UI_LAYER ] . mode = 0 ; <S2SV_EndBug> <S2SV_StartBug> graphics . layer_count = 3 ; <S2SV_EndBug> graphics . layer_count_prev = graphics . layer_count ; blank_layers ( ) ; } | <S2SV_ModStart> SCREEN_H , LAYER_DRAWORDER_OVERLAY ) ; new_empty_layer ( & graphics . video_layers [ GAME_UI_LAYER ] , 0 , 0 , SCREEN_W , SCREEN_H , LAYER_DRAWORDER_GAME_UI <S2SV_ModStart> . video_layers [ GAME_UI_LAYER ] . mode = graphics . screen_mode ; graphics . video_layers [ <S2SV_ModStart> . layer_count = 4 <S2SV_ModEnd> ; graphics . |
1,623 | CWE-000 <S2SV_StartBug> static void cciss_map_sg_chain_block ( ctlr_info_t * h , CommandList_struct * c , <S2SV_EndBug> SGDescriptor_struct * chain_block , int len ) { SGDescriptor_struct * chain_sg ; u64bit temp64 ; chain_sg = & c -> SG [ h -> max_cmd_sgentries - 1 ] ; chain_sg -> Ext = CCISS_SG_CHAIN ; chain_sg -> Len = len ; temp64 . val = pci_map_single ( h -> pdev , chain_block , len , PCI_DMA_TODEVICE ) ; <S2SV_StartBug> chain_sg -> Addr . lower = temp64 . val32 . lower ; <S2SV_EndBug> chain_sg -> Addr . upper = temp64 . val32 . upper ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> static int <S2SV_ModEnd> cciss_map_sg_chain_block ( ctlr_info_t <S2SV_ModStart> PCI_DMA_TODEVICE ) ; if ( dma_mapping_error ( & h -> pdev -> dev , temp64 . val ) ) { dev_warn ( & h -> pdev -> dev , "%s:<S2SV_blank>error<S2SV_blank>mapping<S2SV_blank>chain<S2SV_blank>block<S2SV_blank>for<S2SV_blank>DMA\\n" , __func__ ) ; return - 1 ; } <S2SV_ModStart> . upper ; return 0 ; |
1,624 | CWE-000 static void addMugenFont1 ( int tKey , char * tPath ) { setMugenFontDirectory ( tPath ) ; MugenFontHeader header ; Buffer b = fileToBuffer ( tPath ) ; BufferPointer p = getBufferPointer ( b ) ; readFromBufferPointer ( & header , & p , sizeof ( MugenFontHeader ) ) ; Buffer textureBuffer = makeBuffer ( ( void * ) ( ( ( uint32_t ) b . mData ) + header . mTextureOffset ) , header . mTextureLength ) ; Buffer textBuffer = makeBuffer ( ( void * ) ( ( ( uint32_t ) b . mData ) + header . mTextOffset ) , header . mTextLength ) ; <S2SV_StartBug> MugenDefScript script = loadMugenDefScriptFromBuffer ( textBuffer ) ; <S2SV_EndBug> unloadMugenDefScript ( script ) ; <S2SV_StartBug> script = loadMugenDefScriptFromBuffer ( textBuffer ) ; <S2SV_EndBug> MugenFont * e = allocMemory ( sizeof ( MugenFont ) ) ; e -> mSize = getMugenDefVectorIOrDefault ( & script , "Def" , "size" , makeVector3DI ( 1 , 1 , 0 ) ) ; e -> mSpacing = getMugenDefVectorIOrDefault ( & script , "Def" , "spacing" , makeVector3DI ( 0 , 0 , 0 ) ) ; e -> mOffset = getMugenDefVectorIOrDefault ( & script , "Def" , "offset" , makeVector3DI ( 0 , 0 , 0 ) ) ; e -> mType = MUGEN_FONT_TYPE_ELECBYTE ; loadMugenElecbyteFont ( & script , textureBuffer , e ) ; unloadElecbyteFont ( e ) ; loadMugenElecbyteFont ( & script , textureBuffer , e ) ; unloadMugenDefScript ( script ) ; freeBuffer ( b ) ; resetMugenFontDirectory ( ) ; int_map_push_owned ( & gData . mFonts , tKey , e ) ; } | <S2SV_ModStart> MugenDefScript script = loadMugenDefScriptFromBufferAndFreeBuffer <S2SV_ModEnd> ( textBuffer ) <S2SV_ModStart> ; script = loadMugenDefScriptFromBufferAndFreeBuffer <S2SV_ModEnd> ( textBuffer ) |
1,625 | CWE-000 void <S2SV_StartBug> PREFIX ( stop_numeric ) ( int32_t stop_code ) <S2SV_EndBug> { fprintf ( stderr , "STOP<S2SV_blank>%d\\n" , stop_code ) ; terminate_internal ( STAT_STOPPED_IMAGE , stop_code ) ; } | <S2SV_ModStart> stop_numeric ) ( int <S2SV_ModEnd> stop_code ) { |
1,626 | CWE-000 static int ses_recv_diag ( struct scsi_device * sdev , int page_code , void * buf , int bufflen ) { int ret ; unsigned char cmd [ ] = { RECEIVE_DIAGNOSTIC , 1 , page_code , bufflen >> 8 , bufflen & 0xff , 0 } ; unsigned char recv_page_code ; ret = scsi_execute_req ( sdev , cmd , DMA_FROM_DEVICE , buf , bufflen , NULL , SES_TIMEOUT , SES_RETRIES , NULL ) ; <S2SV_StartBug> if ( unlikely ( ! ret ) ) <S2SV_EndBug> return ret ; recv_page_code = ( ( unsigned char * ) buf ) [ 0 ] ; if ( likely ( recv_page_code == page_code ) ) return ret ; sdev_printk ( KERN_ERR , sdev , "Wrong<S2SV_blank>diagnostic<S2SV_blank>page;<S2SV_blank>asked<S2SV_blank>for<S2SV_blank>%d<S2SV_blank>got<S2SV_blank>%u\\n" , page_code , recv_page_code ) ; return - EINVAL ; } | <S2SV_ModStart> ( unlikely ( <S2SV_ModEnd> ret ) ) |
1,627 | CWE-000 <S2SV_StartBug> void SRV_msgHeader_t_copy ( SRV_msgHeader * to , const SRV_msgHeader * from ) { <S2SV_EndBug> to -> msgNo = from -> msgNo ; to -> sender . idType = from -> sender . idType ; <S2SV_StartBug> SRV_String_copy ( & to -> sender . idSpec , & from -> sender . idSpec ) ; <S2SV_EndBug> <S2SV_StartBug> to -> receiver . idType = from -> receiver . idType ; <S2SV_EndBug> <S2SV_StartBug> SRV_String_copy ( & to -> receiver . idSpec , & from -> receiver . idSpec ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> <S2SV_null> <S2SV_null> <S2SV_null> SRV_msgHeader * <S2SV_ModEnd> SRV_msgHeader_t_copy ( SRV_msgHeader <S2SV_ModStart> ( SRV_msgHeader * header ) { SRV_msgHeader * this = SRV_msgHeader_t_new ( ) ; memcpy ( this , header , sizeof ( SRV_msgHeader ) ) <S2SV_ModEnd> ; SRV_String_copy ( <S2SV_ModStart> SRV_String_copy ( & this <S2SV_ModEnd> -> sender . <S2SV_ModStart> idSpec , & header <S2SV_ModEnd> -> sender . <S2SV_ModStart> idSpec ) ; <S2SV_ModEnd> SRV_String_copy ( & <S2SV_ModStart> SRV_String_copy ( & this <S2SV_ModEnd> -> receiver . <S2SV_ModStart> idSpec , & header <S2SV_ModEnd> -> receiver . <S2SV_ModStart> idSpec ) ; return this ; |
1,628 | CWE-000 int parse_args ( int argc , char * * argv , Arg * arg , Argpdb * argpdb ) { int c ; <S2SV_StartBug> const char usage [ ] = "\\npops<S2SV_blank>[--pdb<S2SV_blank>...<S2SV_blank>|<S2SV_blank>--pdbml<S2SV_blank>...]<S2SV_blank>[OPTIONS<S2SV_blank>...]\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank>INPUT<S2SV_blank>OPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Input<S2SV_blank>is<S2SV_blank>either<S2SV_blank>a<S2SV_blank>*.pdb[.gz]<S2SV_blank>file<S2SV_blank>(--pdb)<S2SV_blank>or<S2SV_blank>a<S2SV_blank>*.xml[.gz]<S2SV_blank>file<S2SV_blank>(--pdbml).\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--pdb<S2SV_blank><PDB<S2SV_blank>input>\\t\\t(mode:<S2SV_blank>optional,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>void)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--pdbml<S2SV_blank><PDBML<S2SV_blank>input>\\t(mode:<S2SV_blank>optional,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>void)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--traj<S2SV_blank><trajectory<S2SV_blank>input>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>void)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank>MODE<S2SV_blank>OPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--coarse\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--hydrogens\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--multiModel\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--partOcc\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--rProbe<S2SV_blank><probe<S2SV_blank>radius<S2SV_blank>[A]>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>float<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>1.4)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--silent\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank>OUTPUT<S2SV_blank>OPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--popsOut<S2SV_blank><POPS<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>pops.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--popstrajOut<S2SV_blank><POPS<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>popstraj.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--popsbOut<S2SV_blank><POPSb<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>popsb.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--popsbtrajOut<S2SV_blank><POPSb<S2SV_blank>output>(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>popsbtraj.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--sigmaOut<S2SV_blank><SFE<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>sigma.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--sigmatrajOut<S2SV_blank><SFE<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>sigmatraj.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--interfaceOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--compositionOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--typeOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--topologyOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--atomOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--residueOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--chainOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--neighbourOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--parameterOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--noTotalOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--noHeaderOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--padding\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--rout\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--jsonOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank>INFO<S2SV_blank>OPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--cite\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--version\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--help\\n" ; <S2SV_EndBug> if ( argc < 2 ) { print_header ( ) ; fprintf ( stderr , "%s" , usage ) ; print_license ( ) ; exit ( 0 ) ; } set_defaults ( arg , argpdb ) ; static struct option long_options [ ] = { { "pdb" , required_argument , 0 , 1 } , { "traj" , required_argument , 0 , 2 } , { "coarse" , no_argument , 0 , 3 } , { "multiModel" , no_argument , 0 , 4 } , { "rProbe" , required_argument , 0 , 5 } , { "popsOut" , required_argument , 0 , 6 } , { "popstrajOut" , required_argument , 0 , 7 } , { "popsbOut" , required_argument , 0 , 8 } , { "popsbtrajOut" , required_argument , 0 , 9 } , { "sigmaOut" , required_argument , 0 , 10 } , { "sigmatrajOut" , required_argument , 0 , 11 } , { "interfaceOut" , no_argument , 0 , 12 } , { "silent" , no_argument , 0 , 13 } , { "compositionOut" , no_argument , 0 , 14 } , { "typeOut" , no_argument , 0 , 15 } , { "topologyOut" , no_argument , 0 , 16 } , { "atomOut" , no_argument , 0 , 17 } , { "residueOut" , no_argument , 0 , 18 } , { "chainOut" , no_argument , 0 , 19 } , { "neighbourOut" , no_argument , 0 , 20 } , { "parameterOut" , no_argument , 0 , 21 } , { "noTotalOut" , no_argument , 0 , 22 } , { "noHeaderOut" , no_argument , 0 , 23 } , { "padding" , no_argument , 0 , 24 } , { "rout" , no_argument , 0 , 25 } , { "jsonOut" , no_argument , 0 , 26 } , { "hydrogens" , no_argument , 0 , 27 } , { "partOcc" , no_argument , 0 , 28 } , { "pdbml" , required_argument , 0 , 29 } , { "cite" , no_argument , 0 , 30 } , { "version" , no_argument , 0 , 31 } , { "help" , no_argument , 0 , 32 } , { 0 , 0 , 0 , 0 } } ; while ( ( c = getopt_long ( argc , argv , "1:2:3<S2SV_blank>4<S2SV_blank>5:6:7:8:9:10:11:12<S2SV_blank>13<S2SV_blank>14<S2SV_blank>15<S2SV_blank>16<S2SV_blank>17<S2SV_blank>18<S2SV_blank>19<S2SV_blank>20<S2SV_blank>21<S2SV_blank>22<S2SV_blank>23<S2SV_blank>24<S2SV_blank>25<S2SV_blank>26<S2SV_blank>27<S2SV_blank>28<S2SV_blank>29:30<S2SV_blank>31<S2SV_blank>32" , long_options , NULL ) ) != - 1 ) { switch ( c ) { case 1 : arg -> pdbInFileName = optarg ; break ; case 2 : arg -> trajInFileName = optarg ; break ; case 3 : argpdb -> coarse = 1 ; break ; case 4 : argpdb -> multiModel = 1 ; break ; case 5 : arg -> rProbe = atof ( optarg ) ; break ; case 6 : arg -> sasaOutFileName = optarg ; break ; case 7 : arg -> sasatrajOutFileName = optarg ; break ; case 8 : arg -> bsasaOutFileName = optarg ; break ; case 9 : arg -> bsasatrajOutFileName = optarg ; break ; case 10 : arg -> sigmaOutFileName = optarg ; break ; case 11 : arg -> sigmatrajOutFileName = optarg ; case 12 : arg -> interfaceOut = 1 ; break ; case 13 : arg -> silent = 1 ; break ; case 14 : arg -> compositionOut = 1 ; break ; case 15 : arg -> typeOut = 1 ; break ; case 16 : arg -> topologyOut = 1 ; break ; case 17 : arg -> atomOut = 1 ; break ; case 18 : arg -> residueOut = 1 ; break ; case 19 : arg -> chainOut = 1 ; break ; case 20 : arg -> neighbourOut = 1 ; break ; case 21 : arg -> parameterOut = 1 ; break ; case 22 : arg -> noTotalOut = 1 ; break ; case 23 : arg -> noHeaderOut = 1 ; break ; case 24 : arg -> padding = 1 ; break ; case 25 : arg -> rout = 1 ; break ; case 26 : arg -> jsonOut = 1 ; break ; case 27 : argpdb -> hydrogens = 1 ; break ; case 28 : argpdb -> partOcc = 1 ; break ; case 29 : arg -> pdbmlInFileName = optarg ; arg -> pdbml = 1 ; break ; case 30 : print_citation ( ) ; exit ( 0 ) ; case 31 : <S2SV_StartBug> fprintf ( stderr , "%s" , usage ) ; <S2SV_EndBug> print_license ( ) ; <S2SV_StartBug> exit ( 0 ) ; <S2SV_EndBug> default : fprintf ( stderr , "%s" , usage ) ; print_license ( ) ; exit ( 1 ) ; } } check_input ( arg , argpdb ) ; print_header ( ) ; print_args ( arg , argpdb ) ; return 0 ; } | <S2SV_ModStart> [ ] = "\\npops<S2SV_blank>[--pdb<S2SV_blank>...<S2SV_blank>|<S2SV_blank>--pdbml<S2SV_blank>...]<S2SV_blank>[OPTIONS<S2SV_blank>...]\\n\\\n<S2SV_blank><S2SV_blank>INPUT<S2SV_blank>OPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>Input<S2SV_blank>is<S2SV_blank>either<S2SV_blank>a<S2SV_blank>*.pdb[.gz]<S2SV_blank>file<S2SV_blank>(--pdb)<S2SV_blank>or<S2SV_blank>a<S2SV_blank>*.xml[.gz]<S2SV_blank>file<S2SV_blank>(--pdbml).\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--pdb<S2SV_blank><PDB<S2SV_blank>input>\\t\\t(mode:<S2SV_blank>optional,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>void)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--pdbml<S2SV_blank><PDBML<S2SV_blank>input>\\t(mode:<S2SV_blank>optional,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>void)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--traj<S2SV_blank><trajectory<S2SV_blank>input>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>void)\\n\\\n<S2SV_blank><S2SV_blank>MODE<S2SV_blank>OPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--coarse\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--hydrogens\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--multiModel\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--partOcc\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--rProbe<S2SV_blank><probe<S2SV_blank>radius<S2SV_blank>[A]>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>float<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>1.4)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--silent\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank>OUTPUT<S2SV_blank>OPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--popsOut<S2SV_blank><POPS<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>pops.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--popstrajOut<S2SV_blank><POPS<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>popstraj.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--popsbOut<S2SV_blank><POPSb<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>popsb.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--popsbtrajOut<S2SV_blank><POPSb<S2SV_blank>output>(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>popsbtraj.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--sigmaOut<S2SV_blank><SFE<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>sigma.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--sigmatrajOut<S2SV_blank><SFE<S2SV_blank>output>\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>char<S2SV_blank>,<S2SV_blank>default:<S2SV_blank>sigmatraj.out)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--interfaceOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--compositionOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--typeOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--topologyOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--atomOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--residueOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--chainOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--neighbourOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--parameterOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--noTotalOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--noHeaderOut\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--padding\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--rout\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--jsonOut\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank>INFO<S2SV_blank>OPTIONS\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--cite\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--version\\t\\t\\t(mode:<S2SV_blank>optional<S2SV_blank>,<S2SV_blank>type:<S2SV_blank>no_arg,<S2SV_blank>default:<S2SV_blank>off)\\n\\\n<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>--help\\n" <S2SV_ModEnd> ; if ( <S2SV_ModStart> case 31 : print_version ( ) ; print_license ( ) ; exit ( 0 ) ; default : <S2SV_ModStart> ; exit ( <S2SV_ModEnd> 1 ) ; |
1,629 | CWE-000 SYSCALL_DEFINE2 ( pivot_root , const char __user * , new_root , const char __user * , put_old ) { struct vfsmount * tmp ; struct path new , old , parent_path , root_parent , root ; int error ; if ( ! capable ( CAP_SYS_ADMIN ) ) return - EPERM ; error = user_path_dir ( new_root , & new ) ; if ( error ) goto out0 ; error = user_path_dir ( put_old , & old ) ; if ( error ) goto out1 ; error = security_sb_pivotroot ( & old , & new ) ; if ( error ) goto out2 ; get_fs_root ( current -> fs , & root ) ; error = lock_mount ( & old ) ; if ( error ) goto out3 ; error = - EINVAL ; if ( IS_MNT_SHARED ( old . mnt ) || IS_MNT_SHARED ( new . mnt -> mnt_parent ) || IS_MNT_SHARED ( root . mnt -> mnt_parent ) ) goto out4 ; if ( ! check_mnt ( root . mnt ) || ! check_mnt ( new . mnt ) ) goto out4 ; error = - ENOENT ; if ( d_unlinked ( new . dentry ) ) goto out4 ; if ( d_unlinked ( old . dentry ) ) goto out4 ; error = - EBUSY ; if ( new . mnt == root . mnt || old . mnt == root . mnt ) goto out4 ; error = - EINVAL ; if ( root . mnt -> mnt_root != root . dentry ) goto out4 ; if ( root . mnt -> mnt_parent == root . mnt ) goto out4 ; if ( new . mnt -> mnt_root != new . dentry ) goto out4 ; if ( new . mnt -> mnt_parent == new . mnt ) goto out4 ; tmp = old . mnt ; if ( tmp != new . mnt ) { for ( ; ; ) { if ( tmp -> mnt_parent == tmp ) goto out4 ; if ( tmp -> mnt_parent == new . mnt ) break ; tmp = tmp -> mnt_parent ; } if ( ! is_subdir ( tmp -> mnt_mountpoint , new . dentry ) ) goto out4 ; } else if ( ! is_subdir ( old . dentry , new . dentry ) ) goto out4 ; <S2SV_StartBug> br_write_lock ( vfsmount_lock ) ; <S2SV_EndBug> detach_mnt ( new . mnt , & parent_path ) ; detach_mnt ( root . mnt , & root_parent ) ; attach_mnt ( root . mnt , & old ) ; attach_mnt ( new . mnt , & root_parent ) ; touch_mnt_namespace ( current -> nsproxy -> mnt_ns ) ; br_write_unlock ( vfsmount_lock ) ; chroot_fs_refs ( & root , & new ) ; error = 0 ; out4 : unlock_mount ( & old ) ; if ( ! error ) { path_put ( & root_parent ) ; path_put ( & parent_path ) ; } out3 : path_put ( & root ) ; out2 : path_put ( & old ) ; out1 : path_put ( & new ) ; out0 : return error ; } | <S2SV_ModStart> goto out4 ; if ( ! is_path_reachable ( new . mnt , new . dentry , & root ) ) goto out4 ; |
1,630 | CWE-000 static void dp_test_send_phy_test_pattern ( struct dc_link * link ) { union phy_test_pattern dpcd_test_pattern ; union lane_adjust dpcd_lane_adjustment [ 2 ] ; unsigned char dpcd_post_cursor_2_adjustment = 0 ; unsigned char test_80_bit_pattern [ ( DP_TEST_80BIT_CUSTOM_PATTERN_79_72 - DP_TEST_80BIT_CUSTOM_PATTERN_7_0 ) + 1 ] = { 0 } ; enum dp_test_pattern test_pattern ; struct dc_link_training_settings link_settings ; union lane_adjust dpcd_lane_adjust ; unsigned int lane ; struct link_training_settings link_training_settings ; int i = 0 ; dpcd_test_pattern . raw = 0 ; memset ( dpcd_lane_adjustment , 0 , sizeof ( dpcd_lane_adjustment ) ) ; memset ( & link_settings , 0 , sizeof ( link_settings ) ) ; core_link_read_dpcd ( link , DP_TEST_PHY_PATTERN , & dpcd_test_pattern . raw , sizeof ( dpcd_test_pattern ) ) ; core_link_read_dpcd ( link , DP_ADJUST_REQUEST_LANE0_1 , & dpcd_lane_adjustment [ 0 ] . raw , sizeof ( dpcd_lane_adjustment ) ) ; core_link_read_dpcd ( link , DP_ADJUST_REQUEST_POST_CURSOR2 , & dpcd_post_cursor_2_adjustment , sizeof ( dpcd_post_cursor_2_adjustment ) ) ; switch ( dpcd_test_pattern . bits . PATTERN ) { case PHY_TEST_PATTERN_D10_2 : test_pattern = DP_TEST_PATTERN_D102 ; break ; case PHY_TEST_PATTERN_SYMBOL_ERROR : test_pattern = DP_TEST_PATTERN_SYMBOL_ERROR ; break ; case PHY_TEST_PATTERN_PRBS7 : test_pattern = DP_TEST_PATTERN_PRBS7 ; break ; case PHY_TEST_PATTERN_80BIT_CUSTOM : test_pattern = DP_TEST_PATTERN_80BIT_CUSTOM ; break ; case PHY_TEST_PATTERN_CP2520_1 : <S2SV_StartBug> test_pattern = ( force_tps4_for_cp2520 == 1 ) ? <S2SV_EndBug> DP_TEST_PATTERN_TRAINING_PATTERN4 : DP_TEST_PATTERN_HBR2_COMPLIANCE_EYE ; break ; case PHY_TEST_PATTERN_CP2520_2 : <S2SV_StartBug> test_pattern = ( force_tps4_for_cp2520 == 1 ) ? <S2SV_EndBug> DP_TEST_PATTERN_TRAINING_PATTERN4 : DP_TEST_PATTERN_HBR2_COMPLIANCE_EYE ; break ; case PHY_TEST_PATTERN_CP2520_3 : test_pattern = DP_TEST_PATTERN_TRAINING_PATTERN4 ; break ; default : test_pattern = DP_TEST_PATTERN_VIDEO_MODE ; break ; } if ( test_pattern == DP_TEST_PATTERN_80BIT_CUSTOM ) core_link_read_dpcd ( link , DP_TEST_80BIT_CUSTOM_PATTERN_7_0 , test_80_bit_pattern , sizeof ( test_80_bit_pattern ) ) ; link_settings . link = link -> cur_link_settings ; for ( lane = 0 ; lane < ( unsigned int ) ( link -> cur_link_settings . lane_count ) ; lane ++ ) { dpcd_lane_adjust . raw = get_nibble_at_index ( & dpcd_lane_adjustment [ 0 ] . raw , lane ) ; link_settings . lane_settings [ lane ] . VOLTAGE_SWING = ( enum dc_voltage_swing ) ( dpcd_lane_adjust . bits . VOLTAGE_SWING_LANE ) ; link_settings . lane_settings [ lane ] . PRE_EMPHASIS = ( enum dc_pre_emphasis ) ( dpcd_lane_adjust . bits . PRE_EMPHASIS_LANE ) ; link_settings . lane_settings [ lane ] . POST_CURSOR2 = ( enum dc_post_cursor2 ) ( ( dpcd_post_cursor_2_adjustment >> ( lane * 2 ) ) & 0x03 ) ; } for ( i = 0 ; i < 4 ; i ++ ) link_training_settings . lane_settings [ i ] = link_settings . lane_settings [ i ] ; link_training_settings . link_settings = link_settings . link ; link_training_settings . allow_invalid_msa_timing_param = false ; dc_link_dp_set_test_pattern ( link , test_pattern , & link_training_settings , test_80_bit_pattern , ( DP_TEST_80BIT_CUSTOM_PATTERN_79_72 - DP_TEST_80BIT_CUSTOM_PATTERN_7_0 ) + 1 ) ; } | <S2SV_ModStart> test_pattern = ( link -> dc -> caps . force_dp_tps4_for_cp2520 <S2SV_ModEnd> == 1 ) <S2SV_ModStart> test_pattern = ( link -> dc -> caps . force_dp_tps4_for_cp2520 <S2SV_ModEnd> == 1 ) |
1,631 | CWE-000 static int process_in_file ( accel_t accel , const char * in_f , <S2SV_StartBug> uint8_t * ibuf , int ibuf_size , <S2SV_EndBug> int check_result , int use_sglist , int use_adler ) { int rc , size_f ; struct stat st ; FILE * i_fp ; uint32_t crc = 0 , m_crc32 = 0 ; uint32_t m_adler32 = 1 ; uint32_t m_inp_processed ; struct ddcb_cmd cmd ; int xerrno ; if ( check_result ) crc = crc32 ( 0L , Z_NULL , 0 ) ; if ( stat ( in_f , & st ) == - 1 ) { fprintf ( stderr , "err:<S2SV_blank>stat<S2SV_blank>on<S2SV_blank>input<S2SV_blank>file<S2SV_blank>(%s)\\n" , strerror ( errno ) ) ; exit ( EX_ERRNO ) ; } size_f = st . st_size ; i_fp = fopen ( in_f , "r" ) ; if ( ! i_fp ) { pr_err ( "err:<S2SV_blank>can\'t<S2SV_blank>open<S2SV_blank>input<S2SV_blank>file<S2SV_blank>%s:<S2SV_blank>%s\\n" , in_f , strerror ( errno ) ) ; exit ( EX_ERRNO ) ; } while ( size_f ) { int tocopy = MIN ( ibuf_size , size_f ) ; rc = fread ( ibuf , tocopy , 1 , i_fp ) ; if ( rc != 1 ) { pr_err ( "err:<S2SV_blank>can\'t<S2SV_blank>read<S2SV_blank>input<S2SV_blank>file<S2SV_blank>%s:<S2SV_blank>%s\\n" , in_f , strerror ( errno ) ) ; exit ( EX_ERRNO ) ; } if ( check_result ) crc = crc32 ( crc , ibuf , tocopy ) ; <S2SV_StartBug> rc = accel_cksum ( accel , & cmd , ibuf , tocopy , <S2SV_EndBug> & m_crc32 , & m_adler32 , & m_inp_processed , use_sglist ) ; xerrno = errno ; if ( rc != DDCB_OK ) { struct asv_runtime_dma_error * d ; fprintf ( stderr , "\\nerr:<S2SV_blank>CKSUM<S2SV_blank>DDCB<S2SV_blank>failed,<S2SV_blank>%s<S2SV_blank>(%d)\\n" "<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>errno=%d<S2SV_blank>%s\\n" , card_strerror ( rc ) , rc , xerrno , strerror ( xerrno ) ) ; fprintf ( stderr , "<S2SV_blank><S2SV_blank>RETC:<S2SV_blank>%03x<S2SV_blank>%s<S2SV_blank>ATTN:<S2SV_blank>%x<S2SV_blank>PROGR:<S2SV_blank>%x\\n" "<S2SV_blank><S2SV_blank>from<S2SV_blank>card<S2SV_blank>CRC32:<S2SV_blank>%08x<S2SV_blank>ADLER:<S2SV_blank>%08x\\n" "<S2SV_blank><S2SV_blank>DEQUEUE=%016llx<S2SV_blank>CMPLT=%016llx<S2SV_blank>DISP=%016llx\\n" , cmd . retc , retc_strerror ( cmd . retc ) , cmd . attn , cmd . progress , m_crc32 , m_adler32 , ( long long ) cmd . deque_ts , ( long long ) cmd . cmplt_ts , ( long long ) cmd . disp_ts ) ; if ( ( cmd . retc == DDCB_RETC_UNEXEC ) && ( cmd . attn == 0xe007 ) ) { d = ( struct asv_runtime_dma_error * ) cmd . asv ; fprintf ( stderr , "<S2SV_blank>raddr:<S2SV_blank>%016llx<S2SV_blank>rfmt/chan/disc:<S2SV_blank>%08x<S2SV_blank>" "rdmae:<S2SV_blank>%04x<S2SV_blank>rsge:<S2SV_blank>%04x\\n" "<S2SV_blank>waddr:<S2SV_blank>%016llx<S2SV_blank>wfmt/chan/disc:<S2SV_blank>%08x<S2SV_blank>" "wdmae:<S2SV_blank>%04x<S2SV_blank>wsge:<S2SV_blank>%04x\\n" , ( long long ) __be64_to_cpu ( d -> raddr_be64 ) , __be32_to_cpu ( d -> rfmt_chan_disccnt_be32 ) , __be16_to_cpu ( d -> rdmae_be16 ) , __be16_to_cpu ( d -> rsge_be16 ) , ( long long ) __be64_to_cpu ( d -> waddr_be64 ) , __be32_to_cpu ( d -> wfmt_chan_disccnt_be32 ) , __be16_to_cpu ( d -> wdmae_be16 ) , __be16_to_cpu ( d -> wsge_be16 ) ) ; } ddcb_hexdump ( stderr , cmd . asv , sizeof ( cmd . asv ) ) ; exit ( EXIT_FAILURE ) ; <S2SV_StartBug> } <S2SV_EndBug> size_f -= tocopy ; } if ( use_adler ) printf ( "%u<S2SV_blank>%llu<S2SV_blank>%s\\n" , m_adler32 , ( long long ) st . st_size , in_f ) ; else printf ( "%u<S2SV_blank>%llu<S2SV_blank>%s\\n" , m_crc32 , ( long long ) st . st_size , in_f ) ; if ( ( check_result ) && ( m_crc32 != crc ) ) { fprintf ( stderr , "err:<S2SV_blank>CRCs<S2SV_blank>do<S2SV_blank>not<S2SV_blank>match<S2SV_blank>%u<S2SV_blank>!=<S2SV_blank>%u\\n" , m_crc32 , crc ) ; } fclose ( i_fp ) ; return 0 ; } | <S2SV_ModStart> * ibuf , void * obuf , <S2SV_ModStart> , ibuf , obuf , <S2SV_ModStart> ) ; } else pr_info ( "<S2SV_blank><S2SV_blank>RETC:<S2SV_blank>%03x<S2SV_blank>%s<S2SV_blank>ATTN:<S2SV_blank>%x<S2SV_blank>PROGR:<S2SV_blank>%x\\n" "<S2SV_blank><S2SV_blank>from<S2SV_blank>card<S2SV_blank>CRC32:<S2SV_blank>%08x<S2SV_blank>ADLER:<S2SV_blank>%08x\\n" "<S2SV_blank><S2SV_blank>DEQUEUE=%016llx<S2SV_blank>CMPLT=%016llx<S2SV_blank>DISP=%016llx\\n" , cmd . retc , retc_strerror ( cmd . retc ) , cmd . attn , cmd . progress , m_crc32 , m_adler32 , ( long long ) cmd . deque_ts , ( long long ) cmd . cmplt_ts , ( long long ) cmd . disp_ts ) ; |
1,632 | CWE-000 int psh_execute ( char * * args ) { int i ; if ( args [ 0 ] == NULL ) { return 1 ; } <S2SV_StartBug> for ( i = 0 ; i < psh_num_builtins ( ) ; i ++ ) <S2SV_EndBug> { if ( ( i = isbuildin ( args [ 0 ] ) ) != NO ) { return runbuildin ( i , args ) ; } <S2SV_StartBug> } <S2SV_EndBug> return psh_launch ( args ) ; } | <S2SV_ModStart> 1 ; } <S2SV_ModEnd> if ( ( <S2SV_ModStart> ) ; } <S2SV_ModEnd> return psh_launch ( |
1,633 | CWE-000 static inline struct page * __alloc_pages_slowpath ( gfp_t gfp_mask , unsigned int order , struct alloc_context * ac ) { bool can_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM ; struct page * page = NULL ; unsigned int alloc_flags ; unsigned long did_some_progress ; <S2SV_StartBug> enum compact_priority compact_priority = DEF_COMPACT_PRIORITY ; <S2SV_EndBug> enum compact_result compact_result ; <S2SV_StartBug> int compaction_retries = 0 ; <S2SV_EndBug> <S2SV_StartBug> int no_progress_loops = 0 ; <S2SV_EndBug> unsigned long alloc_start = jiffies ; unsigned int stall_timeout = 10 * HZ ; <S2SV_StartBug> if ( order >= MAX_ORDER ) { <S2SV_EndBug> WARN_ON_ONCE ( ! ( gfp_mask & __GFP_NOWARN ) ) ; return NULL ; } if ( WARN_ON_ONCE ( ( gfp_mask & ( __GFP_ATOMIC | __GFP_DIRECT_RECLAIM ) ) == ( __GFP_ATOMIC | __GFP_DIRECT_RECLAIM ) ) ) <S2SV_StartBug> gfp_mask &= ~ __GFP_ATOMIC ; <S2SV_EndBug> alloc_flags = gfp_to_alloc_flags ( gfp_mask ) ; if ( gfp_mask & __GFP_KSWAPD_RECLAIM ) wake_all_kswapds ( order , ac ) ; page = get_page_from_freelist ( gfp_mask , order , alloc_flags , ac ) ; if ( page ) goto got_pg ; if ( can_direct_reclaim && order > PAGE_ALLOC_COSTLY_ORDER && ! gfp_pfmemalloc_allowed ( gfp_mask ) ) { page = __alloc_pages_direct_compact ( gfp_mask , order , alloc_flags , ac , INIT_COMPACT_PRIORITY , & compact_result ) ; if ( page ) goto got_pg ; if ( gfp_mask & __GFP_NORETRY ) { if ( compact_result == COMPACT_DEFERRED ) goto nopage ; compact_priority = INIT_COMPACT_PRIORITY ; } } retry : if ( gfp_mask & __GFP_KSWAPD_RECLAIM ) wake_all_kswapds ( order , ac ) ; if ( gfp_pfmemalloc_allowed ( gfp_mask ) ) alloc_flags = ALLOC_NO_WATERMARKS ; if ( ! ( alloc_flags & ALLOC_CPUSET ) || ( alloc_flags & ALLOC_NO_WATERMARKS ) ) { ac -> zonelist = node_zonelist ( numa_node_id ( ) , gfp_mask ) ; ac -> preferred_zoneref = first_zones_zonelist ( ac -> zonelist , ac -> high_zoneidx , ac -> nodemask ) ; } page = get_page_from_freelist ( gfp_mask , order , alloc_flags , ac ) ; if ( page ) goto got_pg ; if ( ! can_direct_reclaim ) { WARN_ON_ONCE ( gfp_mask & __GFP_NOFAIL ) ; goto nopage ; } if ( current -> flags & PF_MEMALLOC ) { if ( WARN_ON_ONCE ( gfp_mask & __GFP_NOFAIL ) ) { cond_resched ( ) ; goto retry ; } goto nopage ; } if ( test_thread_flag ( TIF_MEMDIE ) && ! ( gfp_mask & __GFP_NOFAIL ) ) goto nopage ; page = __alloc_pages_direct_reclaim ( gfp_mask , order , alloc_flags , ac , & did_some_progress ) ; if ( page ) goto got_pg ; page = __alloc_pages_direct_compact ( gfp_mask , order , alloc_flags , ac , compact_priority , & compact_result ) ; if ( page ) goto got_pg ; if ( gfp_mask & __GFP_NORETRY ) goto nopage ; if ( order > PAGE_ALLOC_COSTLY_ORDER && ! ( gfp_mask & __GFP_REPEAT ) ) goto nopage ; if ( time_after ( jiffies , alloc_start + stall_timeout ) ) { warn_alloc ( gfp_mask , "page<S2SV_blank>allocation<S2SV_blank>stalls<S2SV_blank>for<S2SV_blank>%ums,<S2SV_blank>order:%u" , jiffies_to_msecs ( jiffies - alloc_start ) , order ) ; stall_timeout += 10 * HZ ; } if ( should_reclaim_retry ( gfp_mask , order , ac , alloc_flags , did_some_progress > 0 , & no_progress_loops ) ) goto retry ; if ( did_some_progress > 0 && should_compact_retry ( ac , order , alloc_flags , compact_result , & compact_priority , & compaction_retries ) ) goto retry ; page = __alloc_pages_may_oom ( gfp_mask , order , ac , & did_some_progress ) ; if ( page ) goto got_pg ; if ( did_some_progress ) { no_progress_loops = 0 ; goto retry ; } nopage : <S2SV_StartBug> warn_alloc ( gfp_mask , <S2SV_EndBug> "page<S2SV_blank>allocation<S2SV_blank>failure:<S2SV_blank>order:%u" , order ) ; got_pg : return page ; } | <S2SV_ModStart> enum compact_priority compact_priority <S2SV_ModEnd> ; enum compact_result <S2SV_ModStart> ; int compaction_retries <S2SV_ModEnd> ; int no_progress_loops <S2SV_ModStart> ; int no_progress_loops <S2SV_ModEnd> ; unsigned long <S2SV_ModStart> * HZ ; unsigned int cpuset_mems_cookie ; <S2SV_ModStart> &= ~ __GFP_ATOMIC ; retry_cpuset : compaction_retries = 0 ; no_progress_loops = 0 ; compact_priority = DEF_COMPACT_PRIORITY ; cpuset_mems_cookie = read_mems_allowed_begin ( ) <S2SV_ModStart> } nopage : if ( read_mems_allowed_retry ( cpuset_mems_cookie ) ) goto retry_cpuset ; |
1,634 | CWE-000 void displayDLL ( FILE * fp , dll * items ) { if ( items -> size == 0 ) { printf ( "[]" ) ; } else if ( items -> size == 1 ) { printf ( "[" ) ; <S2SV_StartBug> items -> display ( fp , items -> head -> value ) ; <S2SV_EndBug> } else { printf ( "[" ) ; dllnode * spot = items -> head ; int counter = 0 ; while ( counter < items -> size ) { items -> display ( fp , spot -> value ) ; if ( counter + 1 == items -> size ) { break ; } else { printf ( "," ) ; spot = spot -> next ; ++ counter ; } } printf ( "]" ) ; } } | <S2SV_ModStart> head -> value ) ; printf ( "]" |
1,635 | CWE-000 int main ( int argc , char * argv [ ] ) { struct u_task * tsk = ( struct u_task * ) malloc ( sizeof ( struct u_task ) ) ; memset ( tsk , 0 , sizeof ( struct u_task ) ) ; tsk -> _stack = malloc ( U_STACK_SIZE ) ; tsk -> _stack_size = U_STACK_SIZE ; tsk -> _func = test_task_func ; <S2SV_StartBug> run_task ( tsk ) ; <S2SV_EndBug> <S2SV_StartBug> for ( int i = 0 ; i < 10 ; i ++ ) <S2SV_EndBug> { printf ( "%d\\n" , i ) ; if ( i % 2 == 0 ) <S2SV_StartBug> resume_task ( tsk ) ; <S2SV_EndBug> } printf ( "end<S2SV_blank>of<S2SV_blank>the<S2SV_blank>test.\\n" ) ; free ( tsk -> _stack ) ; free ( tsk ) ; return 0 ; } | <S2SV_ModStart> = test_task_func ; asm_run_task <S2SV_ModEnd> ( tsk ) <S2SV_ModStart> ; i < 100 <S2SV_ModEnd> ; i ++ <S2SV_ModStart> resume_task ( tsk ) ; sleep ( 1 |
1,636 | CWE-000 static int find_check_entry ( struct ipt_entry * e , struct net * net , const char * name , unsigned int size ) { struct xt_entry_target * t ; struct xt_target * target ; int ret ; unsigned int j ; struct xt_mtchk_param mtpar ; struct xt_entry_match * ematch ; <S2SV_StartBug> e -> counters . pcnt = xt_percpu_counter_alloc ( ) ; <S2SV_EndBug> <S2SV_StartBug> if ( IS_ERR_VALUE ( e -> counters . pcnt ) ) <S2SV_EndBug> <S2SV_StartBug> return - ENOMEM ; <S2SV_EndBug> j = 0 ; mtpar . net = net ; mtpar . table = name ; mtpar . entryinfo = & e -> ip ; mtpar . hook_mask = e -> comefrom ; mtpar . family = NFPROTO_IPV4 ; xt_ematch_foreach ( ematch , e ) { ret = find_check_match ( ematch , & mtpar ) ; if ( ret != 0 ) goto cleanup_matches ; ++ j ; } t = ipt_get_target ( e ) ; target = xt_request_find_target ( NFPROTO_IPV4 , t -> u . user . name , t -> u . user . revision ) ; if ( IS_ERR ( target ) ) { duprintf ( "find_check_entry:<S2SV_blank>`%s\'<S2SV_blank>not<S2SV_blank>found\\n" , t -> u . user . name ) ; ret = PTR_ERR ( target ) ; goto cleanup_matches ; } t -> u . kernel . target = target ; ret = check_target ( e , net , name ) ; if ( ret ) goto err ; return 0 ; err : module_put ( t -> u . kernel . target -> me ) ; cleanup_matches : xt_ematch_foreach ( ematch , e ) { if ( j -- == 0 ) break ; cleanup_match ( ematch , net ) ; } xt_percpu_counter_free ( e -> counters . pcnt ) ; return ret ; } | <S2SV_ModStart> * ematch ; unsigned long pcnt ; <S2SV_ModEnd> pcnt = xt_percpu_counter_alloc <S2SV_ModStart> ( IS_ERR_VALUE ( <S2SV_ModEnd> pcnt ) ) <S2SV_ModStart> return - ENOMEM ; e -> counters . pcnt = pcnt |
1,637 | CWE-000 void do_invalid_op ( struct cpu_user_regs * regs ) { const struct bug_frame * bug = NULL ; u8 bug_insn [ 2 ] ; const char * prefix = "" , * filename , * predicate , * eip = ( char * ) regs -> rip ; unsigned long fixup ; int id = - 1 , lineno ; const struct virtual_region * region ; if ( debugger_trap_entry ( TRAP_invalid_op , regs ) ) return ; if ( likely ( guest_mode ( regs ) ) ) { if ( ! emulate_invalid_rdtscp ( regs ) && ! emulate_forced_invalid_op ( regs ) ) do_guest_trap ( TRAP_invalid_op , regs ) ; return ; } if ( ! is_active_kernel_text ( regs -> rip ) || __copy_from_user ( bug_insn , eip , sizeof ( bug_insn ) ) || memcmp ( bug_insn , "\\xf\\xb" , sizeof ( bug_insn ) ) ) goto die ; region = find_text_region ( regs -> rip ) ; if ( region ) { for ( id = 0 ; id < BUGFRAME_NR ; id ++ ) { const struct bug_frame * b ; unsigned int i ; for ( i = 0 , b = region -> frame [ id ] . bugs ; i < region -> frame [ id ] . n_bugs ; b ++ , i ++ ) { if ( bug_loc ( b ) == eip ) { bug = b ; goto found ; } } } } found : if ( ! bug ) goto die ; eip += sizeof ( bug_insn ) ; if ( id == BUGFRAME_run_fn ) { void ( * fn ) ( struct cpu_user_regs * ) = bug_ptr ( bug ) ; fn ( regs ) ; regs -> rip = ( unsigned long ) eip ; return ; } filename = bug_ptr ( bug ) ; if ( ! is_kernel ( filename ) && ! is_patch ( filename ) ) goto die ; fixup = strlen ( filename ) ; if ( fixup > 50 ) { filename += fixup - 47 ; prefix = "..." ; } lineno = bug_line ( bug ) ; switch ( id ) { case BUGFRAME_warn : printk ( "Xen<S2SV_blank>WARN<S2SV_blank>at<S2SV_blank>%s%s:%d\\n" , prefix , filename , lineno ) ; show_execution_state ( regs ) ; regs -> rip = ( unsigned long ) eip ; return ; case BUGFRAME_bug : printk ( "Xen<S2SV_blank>BUG<S2SV_blank>at<S2SV_blank>%s%s:%d\\n" , prefix , filename , lineno ) ; if ( debugger_trap_fatal ( TRAP_invalid_op , regs ) ) return ; show_execution_state ( regs ) ; panic ( "Xen<S2SV_blank>BUG<S2SV_blank>at<S2SV_blank>%s%s:%d" , prefix , filename , lineno ) ; case BUGFRAME_assert : predicate = bug_msg ( bug ) ; if ( ! is_kernel ( predicate ) && ! is_patch ( predicate ) ) predicate = "<unknown>" ; printk ( "Assertion<S2SV_blank>\'%s\'<S2SV_blank>failed<S2SV_blank>at<S2SV_blank>%s%s:%d\\n" , predicate , prefix , filename , lineno ) ; if ( debugger_trap_fatal ( TRAP_invalid_op , regs ) ) return ; show_execution_state ( regs ) ; panic ( "Assertion<S2SV_blank>\'%s\'<S2SV_blank>failed<S2SV_blank>at<S2SV_blank>%s%s:%d" , predicate , prefix , filename , lineno ) ; } die : <S2SV_StartBug> if ( ( fixup = search_exception_table ( regs -> rip ) ) != 0 ) <S2SV_EndBug> { this_cpu ( last_extable_addr ) = regs -> rip ; regs -> rip = fixup ; return ; } if ( debugger_trap_fatal ( TRAP_invalid_op , regs ) ) return ; show_execution_state ( regs ) ; panic ( "FATAL<S2SV_blank>TRAP:<S2SV_blank>vector<S2SV_blank>=<S2SV_blank>%d<S2SV_blank>(invalid<S2SV_blank>opcode)" , TRAP_invalid_op ) ; } | <S2SV_ModStart> search_exception_table ( regs <S2SV_ModEnd> ) ) != |
1,638 | CWE-000 static const char * set_outdir ( const char * prefix , const char * output_directory ) { if ( output_directory && is_absolute_path ( output_directory ) ) return output_directory ; if ( ! prefix || ! * prefix ) { if ( output_directory ) return output_directory ; outdir_offset = 2 ; return "./" ; } outdir_offset = strlen ( prefix ) ; if ( ! output_directory ) return prefix ; <S2SV_StartBug> return xstrdup ( prefix_filename ( prefix , outdir_offset , <S2SV_EndBug> output_directory ) ) ; } | <S2SV_ModStart> prefix ; return <S2SV_ModEnd> prefix_filename ( prefix <S2SV_ModStart> ( prefix , output_directory <S2SV_ModEnd> ) ; } |
1,639 | CWE-000 void __list_add ( struct list_head * new , struct list_head * prev , struct list_head * next ) { WARN ( next -> prev != prev , "list_add<S2SV_blank>corruption.<S2SV_blank>next->prev<S2SV_blank>should<S2SV_blank>be<S2SV_blank>" "prev<S2SV_blank>(%p),<S2SV_blank>but<S2SV_blank>was<S2SV_blank>%p.<S2SV_blank>(next=%p).\\n" , prev , next -> prev , next ) ; WARN ( prev -> next != next , "list_add<S2SV_blank>corruption.<S2SV_blank>prev->next<S2SV_blank>should<S2SV_blank>be<S2SV_blank>" "next<S2SV_blank>(%p),<S2SV_blank>but<S2SV_blank>was<S2SV_blank>%p.<S2SV_blank>(prev=%p).\\n" , next , prev -> next , prev ) ; WARN ( new == prev || new == next , "list_add<S2SV_blank>double<S2SV_blank>add:<S2SV_blank>new=%p,<S2SV_blank>prev=%p,<S2SV_blank>next=%p.\\n" , new , prev , next ) ; <S2SV_StartBug> BUG_ON ( ( prev -> next != next || next -> prev != prev || <S2SV_EndBug> new == prev || new == next ) && PANIC_CORRUPTION ) ; next -> prev = new ; new -> next = next ; new -> prev = prev ; prev -> next = new ; } | <S2SV_ModStart> next ) ; <S2SV_ModEnd> next -> prev |
1,640 | CWE-000 void ModifyScore ( COURSE * course ) { char studentID [ 10 ] ; double midtermScore ; double finalScore ; int studentIndex = - 1 ; printf ( "Input<S2SV_blank>student<S2SV_blank>ID<S2SV_blank>to<S2SV_blank>modify<S2SV_blank>score:<S2SV_blank>" ) ; scanf ( "%s" , studentID ) ; getchar ( ) ; printf ( "\\n" ) ; for ( int i = 0 ; i < course -> studentCount ; i ++ ) { if ( strcmp ( course -> student [ i ] . id , studentID ) == 0 ) { studentIndex = i ; break ; } } if ( studentIndex == - 1 ) { printf ( "There<S2SV_blank>is<S2SV_blank>no<S2SV_blank>student<S2SV_blank>who<S2SV_blank>you<S2SV_blank>entered\\n" ) ; printf ( "It<S2SV_blank>will<S2SV_blank>be<S2SV_blank>returned<S2SV_blank>to<S2SV_blank>Score<S2SV_blank>Menu<S2SV_blank>after<S2SV_blank>3<S2SV_blank>seconds<S2SV_blank>automatically" ) ; Sleep ( 3000 ) ; return ; } printf ( "----------------Scores<S2SV_blank>of<S2SV_blank>you<S2SV_blank>found-------------------------\\n" ) ; PrintScore ( course , PRINTTYPE_EDIT , studentIndex ) ; printf ( "Input<S2SV_blank>midterm<S2SV_blank>score<S2SV_blank>to<S2SV_blank>modify<S2SV_blank>:<S2SV_blank>" ) ; scanf ( "%lf" , & midtermScore ) ; getchar ( ) ; printf ( "\\n" ) ; printf ( "Input<S2SV_blank>final<S2SV_blank>score<S2SV_blank>to<S2SV_blank>modify<S2SV_blank>:<S2SV_blank>" ) ; scanf ( "%lf" , & finalScore ) ; getchar ( ) ; printf ( "\\n" ) ; course -> student [ studentIndex ] . examScore [ 0 ] = midtermScore ; course -> student [ studentIndex ] . examScore [ 1 ] = finalScore ; <S2SV_StartBug> printf ( "----------------Changed<S2SV_blank>Scores<S2SV_blank>of<S2SV_blank>%s-------------------------\\n" ) ; <S2SV_EndBug> printf ( "midterm<S2SV_blank>score<S2SV_blank>what<S2SV_blank>you<S2SV_blank>changed<S2SV_blank>:<S2SV_blank>%.2lf\\n" , midtermScore ) ; printf ( "final<S2SV_blank>score<S2SV_blank>what<S2SV_blank>you<S2SV_blank>changed<S2SV_blank>:<S2SV_blank>%.2lf\\n\\n" , finalScore ) ; printf ( "Modified<S2SV_blank>Complete!\\n" ) ; printf ( "It<S2SV_blank>will<S2SV_blank>be<S2SV_blank>returned<S2SV_blank>to<S2SV_blank>Score<S2SV_blank>Menu<S2SV_blank>after<S2SV_blank>3<S2SV_blank>seconds" ) ; Sleep ( 3000 ) ; } | <S2SV_ModStart> ; printf ( "----------------Changed<S2SV_blank>Scores-------------------------\\n" <S2SV_ModEnd> ) ; printf |
1,641 | CWE-000 static SANE_Status finish_pass ( Test_Device * test_device ) { SANE_Status return_status = SANE_STATUS_GOOD ; DBG ( 2 , "finish_pass:<S2SV_blank>test_device=%p\\n" , ( void * ) test_device ) ; test_device -> scanning = SANE_FALSE ; if ( test_device -> pipe >= 0 ) { DBG ( 2 , "finish_pass:<S2SV_blank>closing<S2SV_blank>pipe\\n" ) ; close ( test_device -> pipe ) ; DBG ( 2 , "finish_pass:<S2SV_blank>pipe<S2SV_blank>closed\\n" ) ; test_device -> pipe = - 1 ; } if ( sanei_thread_is_valid ( test_device -> reader_pid ) ) { int status ; SANE_Pid pid ; DBG ( 2 , "finish_pass:<S2SV_blank>terminating<S2SV_blank>reader<S2SV_blank>process<S2SV_blank>%ld\\n" , ( long ) test_device -> reader_pid ) ; sanei_thread_kill ( test_device -> reader_pid ) ; pid = sanei_thread_waitpid ( test_device -> reader_pid , & status ) ; if ( ! sanei_thread_is_valid ( pid ) ) { DBG ( 1 , "finish_pass:<S2SV_blank>sanei_thread_waitpid<S2SV_blank>failed,<S2SV_blank>already<S2SV_blank>terminated?<S2SV_blank>(%s)\\n" , strerror ( errno ) ) ; } else { DBG ( 2 , "finish_pass:<S2SV_blank>reader<S2SV_blank>process<S2SV_blank>terminated<S2SV_blank>with<S2SV_blank>status:<S2SV_blank>%s\\n" , sane_strstatus ( status ) ) ; } <S2SV_StartBug> test_device -> reader_pid = - 1 ; <S2SV_EndBug> } if ( test_device -> reader_fds >= 0 ) { DBG ( 2 , "finish_pass:<S2SV_blank>closing<S2SV_blank>reader<S2SV_blank>pipe\\n" ) ; close ( test_device -> reader_fds ) ; DBG ( 2 , "finish_pass:<S2SV_blank>reader<S2SV_blank>pipe<S2SV_blank>closed\\n" ) ; test_device -> reader_fds = - 1 ; } return return_status ; } | <S2SV_ModStart> ) ; } sanei_thread_invalidate ( test_device -> reader_pid ) <S2SV_ModEnd> ; } if |
1,642 | CWE-000 int32_t rtapi_app_main ( void ) { int32_t mem_fd ; uint32_t vrt_offset = 0 ; off_t phy_block_addr = 0 ; int32_t n , retval ; int8_t * data , * token ; int32_t pin ; comp_id = hal_init ( "hal_gpio_h3" ) ; if ( comp_id < 0 ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>hal_init()<S2SV_blank>failed\\n" ) ; return - 1 ; } if ( ( mem_fd = open ( "/dev/mem" , O_RDWR | O_SYNC ) ) < 0 ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>can\'t<S2SV_blank>open<S2SV_blank>/dev/mem<S2SV_blank>file\\n" ) ; return - 1 ; } vrt_offset = GPIO_PHY_MEM_OFFSET1 % PHY_MEM_BLOCK_SIZE ; phy_block_addr = GPIO_PHY_MEM_OFFSET1 - vrt_offset ; vrt_block_addr [ 0 ] = mmap ( NULL , PHY_MEM_BLOCK_SIZE , PROT_READ | PROT_WRITE , MAP_SHARED , mem_fd , phy_block_addr ) ; if ( vrt_block_addr [ 0 ] == MAP_FAILED ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>mmap()<S2SV_blank>failed\\n" ) ; return - 1 ; } vrt_offset >>= 2 ; <S2SV_StartBug> for ( uint32_t p = GPIO_A ; p <= GPIO_I ; ++ p ) <S2SV_EndBug> { <S2SV_StartBug> _GPIO_port_reg [ p ] = <S2SV_EndBug> ( struct _GPIO_PORT_REG_t * ) <S2SV_StartBug> ( vrt_block_addr [ 0 ] + vrt_offset + p * 0x24 ) ; <S2SV_EndBug> } # if USE_GPIO_PORT_L vrt_offset = GPIO_PHY_MEM_OFFSET2 % PHY_MEM_BLOCK_SIZE ; phy_block_addr = GPIO_PHY_MEM_OFFSET2 - vrt_offset ; vrt_block_addr [ 1 ] = mmap ( NULL , PHY_MEM_BLOCK_SIZE , PROT_READ | PROT_WRITE , MAP_SHARED , mem_fd , phy_block_addr ) ; if ( vrt_block_addr [ 1 ] == MAP_FAILED ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>mmap()<S2SV_blank>failed\\n" ) ; return - 1 ; } vrt_offset >>= 2 ; _GPIO_port_reg [ GPIO_L ] = ( struct _GPIO_PORT_REG_t * ) ( vrt_block_addr [ 1 ] + vrt_offset + 0 * 0x24 ) ; # endif close ( mem_fd ) ; port_data = hal_malloc ( GPIO_PIN_COUNT ) ; if ( port_data == 0 ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>hal_malloc()<S2SV_blank>failed\\n" ) ; hal_exit ( comp_id ) ; return - 1 ; } if ( input_pins != NULL ) { data = input_pins ; while ( ( token = strtok ( data , "," ) ) != NULL ) { pin = strtol ( token , NULL , 10 ) ; if ( pin < 0 || pin >= GPIO_PIN_COUNT || ! _available_pins [ pin ] ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>" "invalid<S2SV_blank>pin<S2SV_blank>number<S2SV_blank>%d\\n" , pin ) ; hal_exit ( comp_id ) ; return - 1 ; } input_pins_list [ input_pins_count ] = pin ; ++ input_pins_count ; config_pin_as_input ( pin ) ; retval = hal_pin_bit_newf ( HAL_OUT , & port_data [ pin ] , comp_id , "hal_gpio_h3.pin-%02d-in" , pin ) ; if ( retval < 0 ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>pin<S2SV_blank>%d<S2SV_blank>export<S2SV_blank>failed\\n" , pin ) ; hal_exit ( comp_id ) ; return - 1 ; } } data = NULL ; } if ( output_pins != NULL ) { data = output_pins ; while ( ( token = strtok ( data , "," ) ) != NULL ) { pin = strtol ( token , NULL , 10 ) ; if ( pin < 0 || pin >= GPIO_PIN_COUNT || ! _available_pins [ pin ] ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>invalid<S2SV_blank>pin<S2SV_blank>number<S2SV_blank>%d\\n" , pin ) ; hal_exit ( comp_id ) ; return - 1 ; } for ( n = input_pins_count ; n -- ; ) { if ( input_pins_list [ n ] == pin ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>" "output<S2SV_blank>pin<S2SV_blank>%d<S2SV_blank>exported<S2SV_blank>before<S2SV_blank>as<S2SV_blank>input\\n" , pin ) ; break ; } } if ( n < 0 ) { output_pins_list [ output_pins_count ] = pin ; ++ output_pins_count ; config_pin_as_output ( pin ) ; retval = hal_pin_bit_newf ( HAL_IN , & port_data [ pin ] , comp_id , "hal_gpio_h3.pin-%02d-out" , pin ) ; if ( retval < 0 ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>pin<S2SV_blank>%d<S2SV_blank>export<S2SV_blank>failed\\n" , pin ) ; hal_exit ( comp_id ) ; return - 1 ; } } } data = NULL ; } retval = hal_export_funct ( "hal_gpio_h3.write" , write_port , 0 , 0 , 0 , comp_id ) ; if ( retval < 0 ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>write<S2SV_blank>funct<S2SV_blank>export<S2SV_blank>failed\\n" ) ; hal_exit ( comp_id ) ; return - 1 ; } retval = hal_export_funct ( "hal_gpio_h3.read" , read_port , 0 , 0 , 0 , comp_id ) ; if ( retval < 0 ) { rtapi_print_msg ( RTAPI_MSG_ERR , "hal_gpio_h3:<S2SV_blank>ERROR:<S2SV_blank>read<S2SV_blank>funct<S2SV_blank>export<S2SV_blank>failed\\n" ) ; hal_exit ( comp_id ) ; return - 1 ; } rtapi_print_msg ( RTAPI_MSG_INFO , "hal_gpio_h3:<S2SV_blank>installed<S2SV_blank>driver\\n" ) ; hal_ready ( comp_id ) ; return 0 ; } | <S2SV_ModStart> ; for ( n <S2SV_ModEnd> = GPIO_A ; <S2SV_ModStart> = GPIO_A ; n <S2SV_ModEnd> <= GPIO_I ; <S2SV_ModStart> GPIO_I ; ++ n <S2SV_ModEnd> ) { _GPIO_port_reg <S2SV_ModStart> { _GPIO_port_reg [ n <S2SV_ModEnd> ] = ( <S2SV_ModStart> + vrt_offset + n <S2SV_ModEnd> * 0x24 ) |
1,643 | CWE-000 int main ( void ) { const char * a = "abc" ; const char * b = a ; <S2SV_StartBug> strpbrk ( b ++ , "" ) ; <S2SV_EndBug> if ( b != a + 1 ) return 1 ; return 0 ; } | <S2SV_ModStart> = a ; DIAG_PUSH_NEEDS_COMMENT ; DIAG_IGNORE_NEEDS_COMMENT ( 9 , "-Wunused-value" ) ; <S2SV_ModStart> , "" ) ; DIAG_POP_NEEDS_COMMENT |
1,644 | CWE-000 SRes decode ( unsigned int input_base , unsigned int output_base , unsigned int file_size ) { UInt64 unpackSize = 0 ; int i ; SRes res = 0 ; CLzmaDec state ; int header_size = LZMA_PROPS_SIZE + 8 ; Byte ( * header ) [ header_size ] = ( Byte ( * ) [ header_size ] ) input_base ; <S2SV_StartBug> int hex = 0 ; <S2SV_EndBug> hex += ( ( * header ) [ 0 ] & 0xFF ) << 24 ; hex += ( ( * header ) [ 1 ] & 0xFF ) << 16 ; hex += ( ( * header ) [ 2 ] & 0xFF ) << 8 ; hex += ( * header ) [ 3 ] & 0xFF ; uart_putx ( ( unsigned int ) header ) ; uart_putx ( hex ) ; for ( i = 0 ; i < 8 ; i ++ ) unpackSize += ( UInt64 ) ( * header ) [ LZMA_PROPS_SIZE + i ] << ( i * 8 ) ; int sizeUnknown = ( unpackSize == ( UInt64 ) ( Int64 ) - 1 ) ; <S2SV_StartBug> uart_putc ( sizeUnknown ? 'U' : 'K' ) ; <S2SV_EndBug> LzmaDec_Construct ( & state ) ; <S2SV_StartBug> res = LzmaDec_Allocate ( & state , ( * header ) , LZMA_PROPS_SIZE , & g_Alloc ) ; <S2SV_EndBug> uart_putc ( res != 0 ? 'E' : 'K' ) ; Byte * dest = ( Byte * ) output_base ; Byte * src = ( * header + 13 ) ; size_t destLen = sizeUnknown ? OUT_BUF_SIZE : unpackSize ; size_t srcLen = file_size ; ELzmaFinishMode finishMode = LZMA_FINISH_ANY ; ELzmaStatus status ; res = LzmaDecode ( dest , & destLen , src , & srcLen , ( * header ) , LZMA_PROPS_SIZE , finishMode , & status , & g_Alloc ) ; LzmaDec_Free ( & state , & g_Alloc ) ; return res ; } | <S2SV_ModStart> ) input_base ; <S2SV_ModEnd> for ( i <S2SV_ModStart> 1 ) ; <S2SV_ModEnd> LzmaDec_Construct ( & <S2SV_ModStart> , & g_Alloc <S2SV_ModEnd> ) ; Byte |
1,645 | CWE-000 static int qat_sym_do_precomputes ( enum icp_qat_hw_auth_algo hash_alg , const uint8_t * auth_key , uint16_t auth_keylen , uint8_t * p_state_buf , uint16_t * p_state_len , uint8_t aes_cmac ) { int block_size ; uint8_t ipad [ qat_hash_get_block_size ( ICP_QAT_HW_AUTH_ALGO_DELIMITER ) ] ; uint8_t opad [ qat_hash_get_block_size ( ICP_QAT_HW_AUTH_ALGO_DELIMITER ) ] ; int i ; if ( hash_alg == ICP_QAT_HW_AUTH_ALGO_AES_XCBC_MAC ) { if ( aes_cmac ) { AES_KEY enc_key ; uint8_t * in = NULL ; uint8_t k0 [ ICP_QAT_HW_AES_128_KEY_SZ ] ; uint8_t * k1 , * k2 ; auth_keylen = ICP_QAT_HW_AES_128_KEY_SZ ; in = rte_zmalloc ( "AES<S2SV_blank>CMAC<S2SV_blank>K1" , ICP_QAT_HW_AES_128_KEY_SZ , 16 ) ; if ( in == NULL ) { QAT_LOG ( ERR , "Failed<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>memory" ) ; return - ENOMEM ; } rte_memcpy ( in , AES_CMAC_SEED , ICP_QAT_HW_AES_128_KEY_SZ ) ; rte_memcpy ( p_state_buf , auth_key , auth_keylen ) ; if ( AES_set_encrypt_key ( auth_key , auth_keylen << 3 , & enc_key ) != 0 ) { rte_free ( in ) ; return - EFAULT ; } AES_encrypt ( in , k0 , & enc_key ) ; k1 = p_state_buf + ICP_QAT_HW_AES_XCBC_MAC_STATE1_SZ ; k2 = k1 + ICP_QAT_HW_AES_XCBC_MAC_STATE1_SZ ; aes_cmac_key_derive ( k0 , k1 ) ; aes_cmac_key_derive ( k1 , k2 ) ; memset ( k0 , 0 , ICP_QAT_HW_AES_128_KEY_SZ ) ; * p_state_len = ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ ; rte_free ( in ) ; return 0 ; } else { static uint8_t qat_aes_xcbc_key_seed [ ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ ] = { 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x01 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x02 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , 0x03 , } ; uint8_t * in = NULL ; uint8_t * out = p_state_buf ; int x ; AES_KEY enc_key ; in = rte_zmalloc ( "working<S2SV_blank>mem<S2SV_blank>for<S2SV_blank>key" , ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ , 16 ) ; if ( in == NULL ) { QAT_LOG ( ERR , "Failed<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>memory" ) ; return - ENOMEM ; } rte_memcpy ( in , qat_aes_xcbc_key_seed , ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ ) ; for ( x = 0 ; x < HASH_XCBC_PRECOMP_KEY_NUM ; x ++ ) { if ( AES_set_encrypt_key ( auth_key , auth_keylen << 3 , & enc_key ) != 0 ) { rte_free ( in - ( x * ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ ) ) ; memset ( out - ( x * ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ ) , 0 , ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ ) ; return - EFAULT ; } AES_encrypt ( in , out , & enc_key ) ; in += ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ ; out += ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ ; } * p_state_len = ICP_QAT_HW_AES_XCBC_MAC_STATE2_SZ ; rte_free ( in - x * ICP_QAT_HW_AES_XCBC_MAC_KEY_SZ ) ; return 0 ; } } else if ( ( hash_alg == ICP_QAT_HW_AUTH_ALGO_GALOIS_128 ) || ( hash_alg == ICP_QAT_HW_AUTH_ALGO_GALOIS_64 ) ) { uint8_t * in = NULL ; uint8_t * out = p_state_buf ; AES_KEY enc_key ; memset ( p_state_buf , 0 , ICP_QAT_HW_GALOIS_H_SZ + ICP_QAT_HW_GALOIS_LEN_A_SZ + ICP_QAT_HW_GALOIS_E_CTR0_SZ ) ; in = rte_zmalloc ( "working<S2SV_blank>mem<S2SV_blank>for<S2SV_blank>key" , ICP_QAT_HW_GALOIS_H_SZ , 16 ) ; if ( in == NULL ) { QAT_LOG ( ERR , "Failed<S2SV_blank>to<S2SV_blank>alloc<S2SV_blank>memory" ) ; return - ENOMEM ; } memset ( in , 0 , ICP_QAT_HW_GALOIS_H_SZ ) ; if ( AES_set_encrypt_key ( auth_key , auth_keylen << 3 , & enc_key ) != 0 ) { return - EFAULT ; } AES_encrypt ( in , out , & enc_key ) ; * p_state_len = ICP_QAT_HW_GALOIS_H_SZ + ICP_QAT_HW_GALOIS_LEN_A_SZ + ICP_QAT_HW_GALOIS_E_CTR0_SZ ; rte_free ( in ) ; return 0 ; } block_size = qat_hash_get_block_size ( hash_alg ) ; <S2SV_StartBug> if ( block_size <= 0 ) <S2SV_EndBug> return - EFAULT ; memset ( ipad , 0 , block_size ) ; memset ( opad , 0 , block_size ) ; if ( auth_keylen > ( unsigned int ) block_size ) { QAT_LOG ( ERR , "invalid<S2SV_blank>keylen<S2SV_blank>%u" , auth_keylen ) ; return - EFAULT ; } rte_memcpy ( ipad , auth_key , auth_keylen ) ; rte_memcpy ( opad , auth_key , auth_keylen ) ; for ( i = 0 ; i < block_size ; i ++ ) { uint8_t * ipad_ptr = ipad + i ; uint8_t * opad_ptr = opad + i ; * ipad_ptr ^= HMAC_IPAD_VALUE ; * opad_ptr ^= HMAC_OPAD_VALUE ; } if ( partial_hash_compute ( hash_alg , ipad , p_state_buf ) ) { memset ( ipad , 0 , block_size ) ; memset ( opad , 0 , block_size ) ; QAT_LOG ( ERR , "ipad<S2SV_blank>precompute<S2SV_blank>failed" ) ; return - EFAULT ; } * p_state_len = qat_hash_get_state1_size ( hash_alg ) ; if ( partial_hash_compute ( hash_alg , opad , p_state_buf + * p_state_len ) ) { memset ( ipad , 0 , block_size ) ; memset ( opad , 0 , block_size ) ; QAT_LOG ( ERR , "opad<S2SV_blank>precompute<S2SV_blank>failed" ) ; return - EFAULT ; } memset ( ipad , 0 , block_size ) ; memset ( opad , 0 , block_size ) ; return 0 ; } | <S2SV_ModStart> if ( block_size < 0 ) return block_size <S2SV_ModEnd> ; memset ( |
1,646 | CWE-000 static int dsi_event_thread ( void * data ) { struct mdss_dsi_event * ev ; struct dsi_event_q * evq ; struct mdss_dsi_ctrl_pdata * ctrl ; unsigned long flag ; struct sched_param param ; u32 todo = 0 , ln_status ; u32 arg ; int ret ; param . sched_priority = 16 ; ret = sched_setscheduler_nocheck ( current , SCHED_FIFO , & param ) ; if ( ret ) pr_err ( "%s:<S2SV_blank>set<S2SV_blank>priority<S2SV_blank>failed\\n" , __func__ ) ; ev = ( struct mdss_dsi_event * ) data ; init_waitqueue_head ( & ev -> event_q ) ; spin_lock_init ( & ev -> event_lock ) ; while ( 1 ) { wait_event ( ev -> event_q , ( ev -> event_pndx != ev -> event_gndx ) ) ; spin_lock_irqsave ( & ev -> event_lock , flag ) ; evq = & ev -> todo_list [ ev -> event_gndx ++ ] ; todo = evq -> todo ; ctrl = evq -> ctrl ; arg = evq -> arg ; evq -> todo = 0 ; ev -> event_gndx %= DSI_EVENT_Q_MAX ; spin_unlock_irqrestore ( & ev -> event_lock , flag ) ; pr_debug ( "%s:<S2SV_blank>ev=%x\\n" , __func__ , todo ) ; if ( todo & DSI_EV_PLL_UNLOCKED ) mdss_dsi_pll_relock ( ctrl ) ; <S2SV_StartBug> if ( todo & DSI_EV_MDP_FIFO_UNDERFLOW ) { <S2SV_EndBug> mutex_lock ( & ctrl -> mutex ) ; if ( ctrl -> recovery ) { pr_debug ( "%s:<S2SV_blank>Handling<S2SV_blank>underflow<S2SV_blank>event\\n" , __func__ ) ; mdss_dsi_clk_ctrl ( ctrl , DSI_ALL_CLKS , 1 ) ; mdss_dsi_sw_reset ( ctrl , true ) ; ctrl -> recovery -> fxn ( ctrl -> recovery -> data , MDP_INTF_DSI_CMD_FIFO_UNDERFLOW ) ; mdss_dsi_clk_ctrl ( ctrl , DSI_ALL_CLKS , 0 ) ; } mutex_unlock ( & ctrl -> mutex ) ; MDSS_XLOG_TOUT_HANDLER ( "mdp" , "dsi0_ctrl" , "dsi0_phy" , "dsi1_ctrl" , "dsi1_phy" , "panic" ) ; } if ( todo & DSI_EV_DSI_FIFO_EMPTY ) mdss_dsi_sw_reset ( ctrl , true ) ; if ( todo & DSI_EV_DLNx_FIFO_OVERFLOW ) { mdss_dsi_get_hw_revision ( ctrl ) ; mutex_lock ( & dsi_mtx ) ; ln_status = MIPI_INP ( ctrl -> ctrl_base + 0x00a8 ) ; pr_debug ( "%s:<S2SV_blank>lane_status:<S2SV_blank>0x%x\\n" , __func__ , ln_status ) ; if ( ctrl -> recovery && ( ctrl -> hw_rev != MDSS_DSI_HW_REV_103 ) && ( ln_status & DSI_DATA_LANES_STOP_STATE ) && ! ( ln_status & DSI_CLK_LANE_STOP_STATE ) ) { pr_debug ( "%s:<S2SV_blank>Handling<S2SV_blank>overflow<S2SV_blank>event.\\n" , __func__ ) ; mdss_dsi_clk_ctrl ( ctrl , DSI_ALL_CLKS , 1 ) ; mdss_dsi_ctl_phy_reset ( ctrl ) ; mdss_dsi_err_intr_ctrl ( ctrl , DSI_INTR_ERROR_MASK , 1 ) ; mdss_dsi_clk_ctrl ( ctrl , DSI_ALL_CLKS , 0 ) ; } else if ( ctrl -> recovery && ( ctrl -> hw_rev == MDSS_DSI_HW_REV_103 ) ) { pr_debug ( "%s:<S2SV_blank>Handle<S2SV_blank>overflow->Rev_103\\n" , __func__ ) ; mdss_dsi_clk_ctrl ( ctrl , DSI_ALL_CLKS , 1 ) ; mdss_dsi_ctl_phy_reset ( ctrl ) ; mdss_dsi_err_intr_ctrl ( ctrl , DSI_INTR_ERROR_MASK , 1 ) ; mdss_dsi_clk_ctrl ( ctrl , DSI_ALL_CLKS , 0 ) ; } mutex_unlock ( & dsi_mtx ) ; } if ( todo & DSI_EV_MDP_BUSY_RELEASE ) { pr_debug ( "%s:<S2SV_blank>Handling<S2SV_blank>MDP_BUSY_RELEASE<S2SV_blank>event\\n" , __func__ ) ; spin_lock_irqsave ( & ctrl -> mdp_lock , flag ) ; ctrl -> mdp_busy = false ; mdss_dsi_disable_irq_nosync ( ctrl , DSI_MDP_TERM ) ; complete_all ( & ctrl -> mdp_comp ) ; spin_unlock_irqrestore ( & ctrl -> mdp_lock , flag ) ; mdss_dsi_clk_ctrl ( ctrl , DSI_ALL_CLKS , 1 ) ; mdss_dsi_err_intr_ctrl ( ctrl , DSI_INTR_ERROR_MASK , 1 ) ; mdss_dsi_clk_ctrl ( ctrl , DSI_ALL_CLKS , 0 ) ; } if ( todo & DSI_EV_STOP_HS_CLK_LANE ) mdss_dsi_stop_hs_clk_lane ( ctrl ) ; } return 0 ; } | <S2SV_ModStart> ( todo & DSI_EV_DLNx_FIFO_UNDERFLOW <S2SV_ModEnd> ) { mutex_lock |
1,647 | CWE-000 int tcaps ( t_env * e ) { if ( ! tcaps_check_key ( BUF , 27 , 91 , 65 ) && ! tcaps_check_key ( BUF , 27 , 91 , 66 ) ) TCAPS . hist_move = - 1 ; if ( BUF [ 0 ] == 4 ) ft_exit ( e ) ; else if ( tcaps_check_read ( BUF ) ) tcaps_insert ( e ) ; else if ( tcaps_check_key ( BUF , 12 , 0 , 0 ) ) tcaps_clear ( e ) ; else if ( tcaps_check_key ( BUF , 1 , 0 , 0 ) ) tcaps_rtrbeg ( e ) ; else if ( tcaps_check_key ( BUF , 27 , 91 , 65 ) || tcaps_check_key ( BUF , 27 , 91 , 66 ) ) tcaps_history ( e ) ; else if ( tcaps_check_key ( BUF , 27 , 91 , 67 ) && TCAPS . nb_move < TCAPS . nb_read ) tcaps_right ( e ) ; else if ( tcaps_check_key ( BUF , 27 , 91 , 68 ) && TCAPS . nb_move > 0 ) tcaps_left ( e ) ; else if ( BUF [ 0 ] == 127 && TCAPS . nb_read && TCAPS . nb_move > 0 ) tcaps_del ( e ) ; <S2SV_StartBug> return ( 0 ) ; <S2SV_EndBug> } | <S2SV_ModStart> e ) ; else if ( tcaps_check_key ( BUF , 27 , 91 , 49 ) && TCAPS . nb_move ) tcaps_ctrl_mov ( e ) ; else if ( BUF [ 0 ] ) printf ( "\\n%d<S2SV_blank>|<S2SV_blank>%d<S2SV_blank>|<S2SV_blank>%d\\n" , BUF [ 0 ] , BUF [ 1 ] , BUF [ 2 ] ) ; |
1,648 | CWE-000 static void mca_btl_vader_sc_emu_afop_complete ( mca_btl_base_module_t * btl , mca_btl_base_endpoint_t * endpoint , mca_btl_base_descriptor_t * desc , int status ) { mca_btl_vader_frag_t * frag = ( mca_btl_vader_frag_t * ) desc ; mca_btl_vader_sc_emu_hdr_t * hdr ; void * local_address = frag -> rdma . local_address ; <S2SV_StartBug> hdr = ( mca_btl_vader_sc_emu_hdr_t * ) frag -> segments [ 0 ] . seg_addr . pval ; <S2SV_EndBug> * ( ( int64_t * ) frag -> rdma . local_address ) = hdr -> operand [ 0 ] ; <S2SV_StartBug> frag -> rdma . cbfunc ( btl , endpoint , local_address , NULL , frag -> rdma . context , frag -> rdma . cbdata , status ) ; <S2SV_EndBug> } | <S2SV_ModStart> . local_address ; void * context = frag -> rdma . context ; void * cbdata = frag -> rdma . cbdata ; mca_btl_base_rdma_completion_fn_t cbfunc = frag -> rdma . cbfunc ; <S2SV_ModStart> 0 ] ; MCA_BTL_VADER_FRAG_RETURN ( frag ) ; <S2SV_ModEnd> cbfunc ( btl <S2SV_ModStart> , NULL , context , <S2SV_ModEnd> cbdata , status |
1,649 | CWE-000 ast * create_ast_expr ( int type , code_context * c ) { <S2SV_StartBug> ast * ast_expr = malloc ( sizeof ( ast ) ) ; <S2SV_EndBug> ast_expr -> type = type ; ast_expr -> val = NULL ; ast_expr -> child_count = 0 ; ast_expr -> children = NULL ; if ( c == NULL ) ast_expr -> context = c ; else ast_expr -> context = copy_context ( c ) ; return ast_expr ; } | <S2SV_ModStart> * ast_expr = calloc ( 1 , <S2SV_ModEnd> sizeof ( ast |
1,650 | CWE-000 u8 bch2_btree_key_recalc_oldest_gen ( struct bch_fs * c , struct bkey_s_c k ) { const struct bch_extent_ptr * ptr ; u8 max_stale = 0 ; if ( bkey_extent_is_data ( k . k ) ) { struct bkey_s_c_extent e = bkey_s_c_to_extent ( k ) ; extent_for_each_ptr ( e , ptr ) { <S2SV_StartBug> struct bch_dev * ca = c -> devs [ ptr -> dev ] ; <S2SV_EndBug> size_t b = PTR_BUCKET_NR ( ca , ptr ) ; if ( gen_after ( ca -> oldest_gens [ b ] , ptr -> gen ) ) ca -> oldest_gens [ b ] = ptr -> gen ; max_stale = max ( max_stale , ptr_stale ( ca , ptr ) ) ; } } return max_stale ; } | <S2SV_ModStart> * ca = bch_dev_bkey_exists ( c , <S2SV_ModEnd> ptr -> dev <S2SV_ModStart> ptr -> dev ) <S2SV_ModEnd> ; size_t b |
1,651 | CWE-000 static void hdcp_lib_msg_recvd ( struct hdcp_lib_handle * handle ) { int rc = 0 ; struct hdmi_hdcp_wakeup_data cdata = { HDMI_HDCP_WKUP_CMD_INVALID } ; struct hdcp_rcvd_msg_req * req_buf ; struct hdcp_rcvd_msg_rsp * rsp_buf ; uint32_t msglen ; char * msg ; if ( ! handle || ! handle -> qseecom_handle || ! handle -> qseecom_handle -> sbuf ) { pr_err ( "invalid<S2SV_blank>handle\\n" ) ; return ; } if ( atomic_read ( & handle -> hdcp_off ) ) { pr_debug ( "invalid<S2SV_blank>state,<S2SV_blank>hdcp<S2SV_blank>off\\n" ) ; return ; } cdata . context = handle -> client_ctx ; mutex_lock ( & handle -> msg_lock ) ; msglen = handle -> last_msg_recvd_len ; if ( msglen <= 0 ) { pr_err ( "invalid<S2SV_blank>msg<S2SV_blank>len\\n" ) ; mutex_unlock ( & handle -> msg_lock ) ; rc = - EINVAL ; goto exit ; } msg = kzalloc ( msglen , GFP_KERNEL ) ; if ( ! msg ) { mutex_unlock ( & handle -> msg_lock ) ; rc = - ENOMEM ; goto exit ; } memcpy ( msg , handle -> last_msg_recvd_buf , msglen ) ; mutex_unlock ( & handle -> msg_lock ) ; pr_debug ( "msg<S2SV_blank>received:<S2SV_blank>%s<S2SV_blank>from<S2SV_blank>sink\\n" , hdcp_lib_message_name ( ( int ) msg [ 0 ] ) ) ; req_buf = ( struct hdcp_rcvd_msg_req * ) ( handle -> qseecom_handle -> sbuf ) ; req_buf -> commandid = HDCP_TXMTR_PROCESS_RECEIVED_MESSAGE ; memcpy ( req_buf -> msg , msg , msglen ) ; req_buf -> msglen = msglen ; req_buf -> ctxhandle = handle -> tz_ctxhandle ; rsp_buf = ( struct hdcp_rcvd_msg_rsp * ) ( handle -> qseecom_handle -> sbuf + QSEECOM_ALIGN ( sizeof ( struct hdcp_rcvd_msg_req ) ) ) ; pr_debug ( "writing<S2SV_blank>%s<S2SV_blank>to<S2SV_blank>TZ<S2SV_blank>at<S2SV_blank>%dms\\n" , hdcp_lib_message_name ( ( int ) msg [ 0 ] ) , jiffies_to_msecs ( jiffies ) ) ; rc = qseecom_send_command ( handle -> qseecom_handle , req_buf , QSEECOM_ALIGN ( sizeof ( struct hdcp_rcvd_msg_req ) ) , rsp_buf , QSEECOM_ALIGN ( sizeof ( struct hdcp_rcvd_msg_rsp ) ) ) ; if ( ( msg [ 0 ] == AKE_SEND_H_PRIME_MESSAGE_ID ) && handle -> no_stored_km_flag ) { handle -> hdcp_timeout = rsp_buf -> timeout ; cdata . cmd = HDMI_HDCP_WKUP_CMD_RECV_MESSAGE ; cdata . timeout = handle -> hdcp_timeout ; goto exit ; } if ( ( msg [ 0 ] == REPEATER_AUTH_STREAM_READY_MESSAGE_ID ) && ( rc == 0 ) && ( rsp_buf -> status == 0 ) ) { pr_debug ( "Got<S2SV_blank>Auth_Stream_Ready,<S2SV_blank>nothing<S2SV_blank>sent<S2SV_blank>to<S2SV_blank>rx\\n" ) ; cdata . cmd = HDMI_HDCP_WKUP_CMD_LINK_POLL ; goto exit ; } if ( ( rc < 0 ) || ( rsp_buf -> status < 0 ) || ( rsp_buf -> msglen <= 0 ) || ( rsp_buf -> commandid != HDCP_TXMTR_PROCESS_RECEIVED_MESSAGE ) || ( rsp_buf -> msg == NULL ) ) { pr_err ( "qseecom<S2SV_blank>cmd<S2SV_blank>failed<S2SV_blank>with<S2SV_blank>err=%d<S2SV_blank>status=%d\\n" , rc , rsp_buf -> status ) ; rc = - EINVAL ; goto exit ; } pr_debug ( "recvd<S2SV_blank>%s<S2SV_blank>from<S2SV_blank>TZ<S2SV_blank>at<S2SV_blank>%dms\\n" , hdcp_lib_message_name ( ( int ) rsp_buf -> msg [ 0 ] ) , jiffies_to_msecs ( jiffies ) ) ; if ( ( ( int ) rsp_buf -> msg [ 0 ] == AKE_NO_STORED_KM_MESSAGE_ID ) ) { pr_debug ( "Setting<S2SV_blank>no_stored_km_flag\\n" ) ; handle -> no_stored_km_flag = 1 ; } else { handle -> no_stored_km_flag = 0 ; } if ( ( rsp_buf -> msg [ 0 ] == SKE_SEND_EKS_MESSAGE_ID ) && ( rsp_buf -> msglen == SKE_SEND_EKS_MESSAGE_SIZE ) ) { if ( ( rsp_buf -> flag == HDCP_TXMTR_SUBSTATE_WAITING_FOR_RECIEVERID_LIST ) && <S2SV_StartBug> ( rsp_buf -> timeout > 0 ) ) <S2SV_EndBug> handle -> repeater_flag = true ; <S2SV_StartBug> handle -> update_stream = true ; <S2SV_EndBug> } memset ( handle -> listener_buf , 0 , MAX_TX_MESSAGE_SIZE ) ; memcpy ( handle -> listener_buf , ( unsigned char * ) rsp_buf -> msg , rsp_buf -> msglen ) ; handle -> hdcp_timeout = rsp_buf -> timeout ; handle -> msglen = rsp_buf -> msglen ; if ( ! atomic_read ( & handle -> hdcp_off ) ) { cdata . cmd = HDMI_HDCP_WKUP_CMD_SEND_MESSAGE ; cdata . send_msg_buf = handle -> listener_buf ; cdata . send_msg_len = handle -> msglen ; cdata . timeout = handle -> hdcp_timeout ; } exit : kzfree ( msg ) ; hdcp_lib_wakeup_client ( handle , & cdata ) ; if ( rc && ! atomic_read ( & handle -> hdcp_off ) ) HDCP_LIB_EXECUTE ( clean ) ; } | <S2SV_ModStart> 0 ) ) { <S2SV_ModStart> = true ; } |
1,652 | CWE-000 int BarCol_Size ( BarColObject * self ) { <S2SV_StartBug> if ( self -> size < 0 ) <S2SV_EndBug> self -> size = ( BarCol_Rows ( self ) ? glp_get_num_rows : glp_get_num_cols ) ( LP ) ; return self -> size ; } | <S2SV_ModStart> self ) { <S2SV_ModEnd> self -> size |
1,653 | CWE-000 static s32 ixgbe_get_phy_id_fw ( struct ixgbe_hw * hw ) { u32 info [ FW_PHY_ACT_DATA_COUNT ] = { 0 } ; u16 phy_speeds ; u16 phy_id_lo ; s32 rc ; u16 i ; rc = ixgbe_fw_phy_activity ( hw , FW_PHY_ACT_GET_PHY_INFO , & info ) ; if ( rc ) return rc ; hw -> phy . speeds_supported = 0 ; phy_speeds = info [ 0 ] & FW_PHY_INFO_SPEED_MASK ; for ( i = 0 ; i < sizeof ( ixgbe_fw_map ) / sizeof ( ixgbe_fw_map [ 0 ] ) ; ++ i ) { if ( phy_speeds & ixgbe_fw_map [ i ] . fw_speed ) hw -> phy . speeds_supported |= ixgbe_fw_map [ i ] . phy_speed ; } <S2SV_StartBug> if ( ! hw -> phy . autoneg_advertised ) <S2SV_EndBug> <S2SV_StartBug> hw -> phy . autoneg_advertised = hw -> phy . speeds_supported ; <S2SV_EndBug> hw -> phy . id = info [ 0 ] & FW_PHY_INFO_ID_HI_MASK ; phy_id_lo = info [ 1 ] & FW_PHY_INFO_ID_LO_MASK ; hw -> phy . id |= phy_id_lo & IXGBE_PHY_REVISION_MASK ; hw -> phy . revision = phy_id_lo & ~ IXGBE_PHY_REVISION_MASK ; if ( ! hw -> phy . id || hw -> phy . id == IXGBE_PHY_REVISION_MASK ) return IXGBE_ERR_PHY_ADDR_INVALID ; return IXGBE_SUCCESS ; } | <S2SV_ModStart> phy_speed ; } # if 0 <S2SV_ModStart> . speeds_supported ; # endif |
1,654 | CWE-000 static void print_flag_v ( t_core * core , t_process * process ) { if ( core -> flags -> v && core -> flags -> verbosity_four && ARGS [ 0 ] . type == REG_CODE && ARGS [ 1 ] . type == REG_CODE && ARGS [ 2 ] . type == REG_CODE && ARGS [ 0 ] . arg <= REG_NUMBER && ARGS [ 0 ] . arg > 0 && ARGS [ 1 ] . arg <= REG_NUMBER && ARGS [ 1 ] . arg > 0 && ARGS [ 2 ] . arg <= REG_NUMBER && ARGS [ 2 ] . arg > 0 ) { <S2SV_StartBug> ft_printf ( "P%5d<S2SV_blank>|<S2SV_blank>%s<S2SV_blank>" , process -> id , "sub" ) ; <S2SV_EndBug> ft_printf ( "r%d<S2SV_blank>r%d<S2SV_blank>" , process -> args [ 0 ] . arg , process -> args [ 1 ] . arg ) ; ft_printf ( "r%d\\n" , process -> args [ 2 ] . arg ) ; } if ( FLAGS -> v && FLAGS -> verbosity_sixteen ) pc_movements ( core , process ) ; } | <S2SV_ModStart> { ft_printf ( "P<S2SV_blank>%4d<S2SV_blank>|<S2SV_blank>%s<S2SV_blank>" <S2SV_ModEnd> , process -> |
1,655 | CWE-000 void simulation ( ) { int p ; float win = 0 ; float lose = 0 ; float winrate ; for ( p = 0 ; p < 100000 ; p ++ ) { dummypower = 1700 ; dummystamina = 3060 ; dummyagility = 680 ; int countermax = 100 ; int playerNo ; int i ; int cycle ; int petcheck ; float dummytr ; float dummycounter = 0 ; float dummyinterval ; bool DS ; bool teamalive = true ; playerNo = 5 ; <S2SV_StartBug> encon ( 0 ) ; <S2SV_EndBug> encon ( 1 ) ; <S2SV_StartBug> encon ( 2 ) ; <S2SV_EndBug> <S2SV_StartBug> encon ( 3 ) ; <S2SV_EndBug> <S2SV_StartBug> encon ( 4 ) ; <S2SV_EndBug> hpdummy = dummystamina * 10 ; dummytr = turnRate ( dummypower , dummyagility ) ; dummyinterval = countermax / dummytr ; for ( i = 0 ; i < playerNo ; i ++ ) { hero [ i ] . power *= hero [ i ] . powerrune ; hero [ i ] . agility *= hero [ i ] . agirune ; hero [ i ] . hp = hero [ i ] . stamina * 10 ; hero [ i ] . maxhp = hero [ i ] . hp ; hero [ i ] . tr = turnRate ( hero [ i ] . power , hero [ i ] . agility ) ; hero [ i ] . interval = countermax / hero [ i ] . tr ; hero [ i ] . counter = 0 ; } while ( hpdummy > 0 && teamalive == true ) { for ( cycle = 1 ; cycle <= countermax ; cycle ++ ) { dummycounter ++ ; for ( i = 0 ; i < playerNo ; i ++ ) { hero [ i ] . counter ++ ; if ( hero [ i ] . counter >= hero [ i ] . interval && hero [ i ] . alive ) { hero [ i ] . sp ++ ; petcheck = strcmp ( hero [ i ] . pet , "gemmi" ) ; if ( petcheck == 0 ) { defpetproc ( i ) ; } else { offpetproc ( i ) ; } DS = RNGroll ( hero [ i ] . DSchance ) ; if ( DS ) { heroattack ( i ) ; heroattack ( i ) ; } else { heroattack ( i ) ; } hero [ i ] . counter -= hero [ i ] . interval ; if ( hpdummy <= 0 ) { win ++ ; i = playerNo ; cycle = countermax ; } } } if ( hpdummy > 0 && dummycounter >= dummyinterval ) { spdummy ++ ; bossattack ( ) ; dummycounter -= dummyinterval ; if ( ! hero [ 0 ] . alive && ! hero [ 1 ] . alive && ! hero [ 2 ] . alive && ! hero [ 3 ] . alive && ! hero [ 4 ] . alive ) { teamalive = false ; cycle = countermax ; } } } } if ( ! teamalive ) { lose ++ ; } } winrate = ( win / 100000 ) * 100 ; <S2SV_StartBug> printf ( "win<S2SV_blank>=<S2SV_blank>%f<S2SV_blank>lost<S2SV_blank>=<S2SV_blank>%f\\n" , win , lose ) ; <S2SV_EndBug> printf ( "winrate<S2SV_blank>=<S2SV_blank>%f<S2SV_blank>%%\\n" , winrate ) ; } | <S2SV_ModStart> = 5 ; byleth ( 0 ) ; byleth <S2SV_ModEnd> ( 1 ) <S2SV_ModStart> 1 ) ; byleth <S2SV_ModEnd> ( 2 ) <S2SV_ModStart> 2 ) ; byleth <S2SV_ModEnd> ( 3 ) <S2SV_ModStart> 3 ) ; byleth <S2SV_ModEnd> ( 4 ) <S2SV_ModStart> ; printf ( "won<S2SV_blank>=<S2SV_blank>%f<S2SV_blank>lost<S2SV_blank>=<S2SV_blank>%f\\n" <S2SV_ModEnd> , win , |
1,656 | CWE-000 static int host1x_probe ( struct platform_device * pdev ) { const struct of_device_id * id ; struct host1x * host ; struct resource * regs ; int syncpt_irq ; int err ; id = of_match_device ( host1x_of_match , & pdev -> dev ) ; if ( ! id ) return - EINVAL ; regs = platform_get_resource ( pdev , IORESOURCE_MEM , 0 ) ; if ( ! regs ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>registers\\n" ) ; return - ENXIO ; } syncpt_irq = platform_get_irq ( pdev , 0 ) ; if ( syncpt_irq < 0 ) { <S2SV_StartBug> dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>IRQ\\n" ) ; <S2SV_EndBug> return - ENXIO ; } host = devm_kzalloc ( & pdev -> dev , sizeof ( * host ) , GFP_KERNEL ) ; if ( ! host ) return - ENOMEM ; mutex_init ( & host -> devices_lock ) ; INIT_LIST_HEAD ( & host -> devices ) ; INIT_LIST_HEAD ( & host -> list ) ; host -> dev = & pdev -> dev ; host -> info = id -> data ; platform_set_drvdata ( pdev , host ) ; host -> regs = devm_ioremap_resource ( & pdev -> dev , regs ) ; if ( IS_ERR ( host -> regs ) ) return PTR_ERR ( host -> regs ) ; dma_set_mask_and_coherent ( host -> dev , host -> info -> dma_mask ) ; if ( host -> info -> init ) { err = host -> info -> init ( host ) ; if ( err ) return err ; } host -> clk = devm_clk_get ( & pdev -> dev , NULL ) ; if ( IS_ERR ( host -> clk ) ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>clock\\n" ) ; err = PTR_ERR ( host -> clk ) ; return err ; } host -> rst = devm_reset_control_get ( & pdev -> dev , "host1x" ) ; if ( IS_ERR ( host -> rst ) ) { err = PTR_ERR ( host -> rst ) ; dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>reset:<S2SV_blank>%d\\n" , err ) ; return err ; } if ( iommu_present ( & platform_bus_type ) ) { struct iommu_domain_geometry * geometry ; unsigned long order ; host -> domain = iommu_domain_alloc ( & platform_bus_type ) ; if ( ! host -> domain ) return - ENOMEM ; err = iommu_attach_device ( host -> domain , & pdev -> dev ) ; if ( err ) goto fail_free_domain ; geometry = & host -> domain -> geometry ; order = __ffs ( host -> domain -> pgsize_bitmap ) ; init_iova_domain ( & host -> iova , 1UL << order , geometry -> aperture_start >> order , geometry -> aperture_end >> order ) ; host -> iova_end = geometry -> aperture_end ; } err = host1x_channel_list_init ( & host -> channel_list , host -> info -> nb_channels ) ; if ( err ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>channel<S2SV_blank>list\\n" ) ; goto fail_detach_device ; } err = clk_prepare_enable ( host -> clk ) ; if ( err < 0 ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>enable<S2SV_blank>clock\\n" ) ; goto fail_free_channels ; } err = reset_control_deassert ( host -> rst ) ; if ( err < 0 ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>deassert<S2SV_blank>reset:<S2SV_blank>%d\\n" , err ) ; goto fail_unprepare_disable ; } err = host1x_syncpt_init ( host ) ; if ( err ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>syncpts\\n" ) ; goto fail_reset_assert ; } err = host1x_intr_init ( host , syncpt_irq ) ; if ( err ) { dev_err ( & pdev -> dev , "failed<S2SV_blank>to<S2SV_blank>initialize<S2SV_blank>interrupts\\n" ) ; goto fail_deinit_syncpt ; } host1x_debug_init ( host ) ; err = host1x_register ( host ) ; if ( err < 0 ) goto fail_deinit_intr ; return 0 ; fail_deinit_intr : host1x_intr_deinit ( host ) ; fail_deinit_syncpt : host1x_syncpt_deinit ( host ) ; fail_reset_assert : reset_control_assert ( host -> rst ) ; fail_unprepare_disable : clk_disable_unprepare ( host -> clk ) ; fail_free_channels : host1x_channel_list_free ( & host -> channel_list ) ; fail_detach_device : if ( host -> domain ) { put_iova_domain ( & host -> iova ) ; iommu_detach_device ( host -> domain , & pdev -> dev ) ; } fail_free_domain : if ( host -> domain ) iommu_domain_free ( host -> domain ) ; return err ; } | <S2SV_ModStart> -> dev , "failed<S2SV_blank>to<S2SV_blank>get<S2SV_blank>IRQ:<S2SV_blank>%d\\n" , syncpt_irq ) ; return syncpt_irq <S2SV_ModEnd> ; } host |
1,657 | CWE-000 <S2SV_StartBug> static PHP_METHOD ( Phalcon_Mvc_Model_Relation , getReferencedModel ) { <S2SV_EndBug> zval * this_ptr = getThis ( ) ; RETURN_MEMBER ( getThis ( ) , "_referencedModel" ) ; } | <S2SV_ModStart> static PHP_METHOD ( Phalcon_Cache_Frontend_Msgpack , stop ) { <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,658 | CWE-000 Datum hypertable_create ( PG_FUNCTION_ARGS ) { Oid table_relid = PG_GETARG_OID ( 0 ) ; Name associated_schema_name = PG_ARGISNULL ( 4 ) ? NULL : PG_GETARG_NAME ( 4 ) ; Name associated_table_prefix = PG_ARGISNULL ( 5 ) ? NULL : PG_GETARG_NAME ( 5 ) ; bool create_default_indexes = PG_ARGISNULL ( 7 ) ? false : PG_GETARG_BOOL ( 7 ) ; bool if_not_exists = PG_ARGISNULL ( 8 ) ? false : PG_GETARG_BOOL ( 8 ) ; bool migrate_data = PG_ARGISNULL ( 10 ) ? false : PG_GETARG_BOOL ( 10 ) ; DimensionInfo time_dim_info = { . table_relid = table_relid , . colname = PG_ARGISNULL ( 1 ) ? NULL : PG_GETARG_NAME ( 1 ) , . interval_datum = PG_ARGISNULL ( 6 ) ? Int64GetDatum ( - 1 ) : PG_GETARG_DATUM ( 6 ) , . interval_type = PG_ARGISNULL ( 6 ) ? InvalidOid : get_fn_expr_argtype ( fcinfo -> flinfo , 6 ) , } ; DimensionInfo space_dim_info = { . table_relid = table_relid , . colname = PG_ARGISNULL ( 2 ) ? NULL : PG_GETARG_NAME ( 2 ) , . num_slices = PG_ARGISNULL ( 3 ) ? - 1 : PG_GETARG_INT16 ( 3 ) , . num_slices_is_set = ! PG_ARGISNULL ( 3 ) , . partitioning_func = PG_ARGISNULL ( 9 ) ? InvalidOid : PG_GETARG_OID ( 9 ) , } ; Cache * hcache ; Hypertable * ht ; Oid associated_schema_oid ; Oid user_oid = GetUserId ( ) ; Oid tspc_oid = get_rel_tablespace ( table_relid ) ; bool table_has_data ; NameData schema_name , table_name , default_associated_schema_name ; LockRelationOid ( table_relid , ShareRowExclusiveLock ) ; if ( is_hypertable ( table_relid ) ) { if ( if_not_exists ) { ereport ( NOTICE , ( errcode ( ERRCODE_IO_HYPERTABLE_EXISTS ) , errmsg ( "table<S2SV_blank>\\"%s\\"<S2SV_blank>is<S2SV_blank>already<S2SV_blank>a<S2SV_blank>hypertable,<S2SV_blank>skipping" , get_rel_name ( table_relid ) ) ) ) ; PG_RETURN_VOID ( ) ; } ereport ( ERROR , ( errcode ( ERRCODE_IO_HYPERTABLE_EXISTS ) , errmsg ( "table<S2SV_blank>\\"%s\\"<S2SV_blank>is<S2SV_blank>already<S2SV_blank>a<S2SV_blank>hypertable" , get_rel_name ( table_relid ) ) ) ) ; } hypertable_permissions_check ( table_relid , user_oid ) ; switch ( get_rel_relkind ( table_relid ) ) { # if PG10 case RELKIND_PARTITIONED_TABLE : ereport ( ERROR , ( errcode ( ERRCODE_WRONG_OBJECT_TYPE ) , errmsg ( "table<S2SV_blank>\\"%s\\"<S2SV_blank>is<S2SV_blank>already<S2SV_blank>partitioned" , get_rel_name ( table_relid ) ) , errdetail ( "It<S2SV_blank>is<S2SV_blank>not<S2SV_blank>possible<S2SV_blank>to<S2SV_blank>turn<S2SV_blank>partitioned<S2SV_blank>tables<S2SV_blank>into<S2SV_blank>hypertables." ) ) ) ; # endif case RELKIND_RELATION : break ; default : ereport ( ERROR , ( errcode ( ERRCODE_WRONG_OBJECT_TYPE ) , errmsg ( "invalid<S2SV_blank>relation<S2SV_blank>type" ) ) ) ; } hypertable_validate_constraints ( table_relid ) ; table_has_data = table_has_tuples ( table_relid , GetActiveSnapshot ( ) , NoLock ) ; if ( ! migrate_data && table_has_data ) ereport ( ERROR , ( errcode ( ERRCODE_FEATURE_NOT_SUPPORTED ) , errmsg ( "table<S2SV_blank>\\"%s\\"<S2SV_blank>is<S2SV_blank>not<S2SV_blank>empty" , get_rel_name ( table_relid ) ) , errhint ( "You<S2SV_blank>can<S2SV_blank>migrate<S2SV_blank>data<S2SV_blank>by<S2SV_blank>specifying<S2SV_blank>\'migrate_data<S2SV_blank>=><S2SV_blank>true\'<S2SV_blank>when<S2SV_blank>calling<S2SV_blank>this<S2SV_blank>function." ) ) ) ; if ( is_inheritance_table ( table_relid ) ) ereport ( ERROR , ( errcode ( ERRCODE_FEATURE_NOT_SUPPORTED ) , errmsg ( "table<S2SV_blank>\\"%s\\"<S2SV_blank>is<S2SV_blank>already<S2SV_blank>partitioned" , get_rel_name ( table_relid ) ) , errdetail ( "It<S2SV_blank>is<S2SV_blank>not<S2SV_blank>possible<S2SV_blank>to<S2SV_blank>turn<S2SV_blank>tables<S2SV_blank>that<S2SV_blank>use<S2SV_blank>inheritance<S2SV_blank>into<S2SV_blank>hypertables." ) ) ) ; if ( NULL == associated_schema_name ) { namestrcpy ( & default_associated_schema_name , INTERNAL_SCHEMA_NAME ) ; associated_schema_name = & default_associated_schema_name ; } associated_schema_oid = hypertable_check_associated_schema_permissions ( NameStr ( * associated_schema_name ) , user_oid ) ; if ( ! OidIsValid ( associated_schema_oid ) ) hypertable_create_schema ( NameStr ( * associated_schema_name ) ) ; if ( relation_has_transition_table_trigger ( table_relid ) ) ereport ( ERROR , ( errcode ( ERRCODE_FEATURE_NOT_SUPPORTED ) , errmsg ( "hypertables<S2SV_blank>do<S2SV_blank>not<S2SV_blank>support<S2SV_blank>transition<S2SV_blank>tables<S2SV_blank>in<S2SV_blank>triggers" ) ) ) ; dimension_validate_info ( & time_dim_info ) ; if ( DIMENSION_INFO_IS_SET ( & space_dim_info ) ) dimension_validate_info ( & space_dim_info ) ; namestrcpy ( & schema_name , get_namespace_name ( get_rel_namespace ( table_relid ) ) ) ; namestrcpy ( & table_name , get_rel_name ( table_relid ) ) ; hypertable_insert ( & schema_name , & table_name , associated_schema_name , associated_table_prefix , DIMENSION_INFO_IS_SET ( & space_dim_info ) ? 2 : 1 ) ; hcache = hypertable_cache_pin ( ) ; time_dim_info . ht = space_dim_info . ht = hypertable_cache_get_entry ( hcache , table_relid ) ; Assert ( time_dim_info . ht != NULL ) ; dimension_add_from_info ( & time_dim_info ) ; if ( DIMENSION_INFO_IS_SET ( & space_dim_info ) ) dimension_add_from_info ( & space_dim_info ) ; cache_release ( hcache ) ; hcache = hypertable_cache_pin ( ) ; ht = hypertable_cache_get_entry ( hcache , table_relid ) ; Assert ( ht != NULL ) ; indexing_verify_indexes ( ht ) ; if ( OidIsValid ( tspc_oid ) ) { NameData tspc_name ; namestrcpy ( & tspc_name , get_tablespace_name ( tspc_oid ) ) ; tablespace_attach_internal ( & tspc_name , table_relid , false ) ; } if ( table_has_data ) { ereport ( NOTICE , ( errmsg ( "migrating<S2SV_blank>data<S2SV_blank>to<S2SV_blank>chunks" ) , errdetail ( "Migration<S2SV_blank>might<S2SV_blank>take<S2SV_blank>a<S2SV_blank>while<S2SV_blank>depending<S2SV_blank>on<S2SV_blank>the<S2SV_blank>amount<S2SV_blank>of<S2SV_blank>data." ) ) ) ; <S2SV_StartBug> timescaledb_copy_from_table_to_chunks ( ht , AccessShareLock ) ; <S2SV_EndBug> <S2SV_StartBug> } <S2SV_EndBug> if ( create_default_indexes ) indexing_create_default_indexes ( ht ) ; cache_release ( hcache ) ; PG_RETURN_VOID ( ) ; } | <S2SV_ModStart> ) ) ; timescaledb_move_from_table_to_chunks <S2SV_ModEnd> ( ht , <S2SV_ModStart> ) ; } insert_blocker_trigger_add ( table_relid ) ; |
1,659 | CWE-000 NV_ID NV_Op_callArgs ( const NV_ID * tList , int index , const NV_ID * ctx ) { NV_ID t , r ; const NV_ID scope = NV_Context_getCurrentScope ( ctx ) ; int phase ; phase = NV_Op_Internal_getCurrentPhase ( tList ) ; t = NV_Array_getByIndex ( tList , index - 1 ) ; <S2SV_StartBug> t = NV_Term_tryReadAsVariable ( & t , & scope ) ; <S2SV_EndBug> if ( ! NV_Term_isArray ( & t , & scope ) ) { return NV_Node_createWithString ( "pre<S2SV_blank>term<S2SV_blank>is<S2SV_blank>not<S2SV_blank>an<S2SV_blank>Array" ) ; } if ( IS_DEBUG_MODE ( ) ) { printf ( "Exec<S2SV_blank>block:<S2SV_blank>" ) ; NV_Array_print ( & t ) ; putchar ( '\\n' ) ; } r = NV_Op_codeBlock ( tList , index , "(" , ")" ) ; NV_Context_pushToEvalStack ( ctx , & t , NULL ) ; return NODEID_NULL ; } | <S2SV_ModStart> ; t = NV_Term_tryReadAsVariableData <S2SV_ModEnd> ( & t |
1,660 | CWE-000 int ft_printf ( char * format , ... ) { va_list arglist ; <S2SV_StartBug> int len ; <S2SV_EndBug> <S2SV_StartBug> va_start ( arglist , format ) ; <S2SV_EndBug> len = 0 ; if ( format ) <S2SV_StartBug> len = read_format ( format , arglist ) ; <S2SV_EndBug> <S2SV_StartBug> va_end ( arglist ) ; <S2SV_EndBug> return ( len ) ; } | <S2SV_ModStart> va_list arglist ; va_list copy ; <S2SV_ModStart> arglist , format ) ; va_copy ( copy , arglist <S2SV_ModStart> ( format ) { <S2SV_ModStart> arglist ) ; len += check_char_nulls ( format , copy ) ; } <S2SV_ModStart> va_end ( arglist ) ; va_end ( copy |
1,661 | CWE-000 ACPI_STATUS AcpiUtGetResourceEndTag ( ACPI_OPERAND_OBJECT * ObjDesc , UINT8 * * EndTag ) { ACPI_STATUS Status ; ACPI_FUNCTION_TRACE ( UtGetResourceEndTag ) ; <S2SV_StartBug> if ( ! ObjDesc -> Buffer . Length ) <S2SV_EndBug> { * EndTag = ObjDesc -> Buffer . Pointer ; return_ACPI_STATUS ( AE_OK ) ; } Status = AcpiUtWalkAmlResources ( NULL , ObjDesc -> Buffer . Pointer , <S2SV_StartBug> ObjDesc -> Buffer . Length , NULL , ( void * * ) EndTag ) ; <S2SV_EndBug> return_ACPI_STATUS ( Status ) ; } | <S2SV_ModStart> UtGetResourceEndTag ) ; <S2SV_ModEnd> Status = AcpiUtWalkAmlResources <S2SV_ModStart> * ) EndTag , FALSE ) ; if ( Status == AE_AML_NO_RESOURCE_END_TAG ) { Status = AE_OK ; } <S2SV_ModEnd> return_ACPI_STATUS ( Status |
1,662 | CWE-000 void SimulateTagLowFrequency ( int period , int gap , int ledcontrol ) { int i ; uint8_t * tab = BigBuf_get_addr ( ) ; FpgaDownloadAndGo ( FPGA_BITSTREAM_LF ) ; FpgaWriteConfWord ( FPGA_MAJOR_MODE_LF_EDGE_DETECT ) ; AT91C_BASE_PIOA -> PIO_PER = GPIO_SSC_DOUT | GPIO_SSC_CLK ; AT91C_BASE_PIOA -> PIO_OER = GPIO_SSC_DOUT ; AT91C_BASE_PIOA -> PIO_ODR = GPIO_SSC_CLK ; # define SHORT_COIL ( ) LOW ( GPIO_SSC_DOUT ) # define OPEN_COIL ( ) HIGH ( GPIO_SSC_DOUT ) i = 0 ; for ( ; ; ) { while ( ! ( AT91C_BASE_PIOA -> PIO_PDSR & GPIO_SSC_CLK ) ) { if ( BUTTON_PRESS ( ) || ( usb_poll_validate_length ( ) ) ) { <S2SV_StartBug> DbpString ( "Stopped" ) ; <S2SV_EndBug> return ; } WDT_HIT ( ) ; } if ( ledcontrol ) LED_D_ON ( ) ; if ( tab [ i ] ) OPEN_COIL ( ) ; else SHORT_COIL ( ) ; if ( ledcontrol ) LED_D_OFF ( ) ; while ( AT91C_BASE_PIOA -> PIO_PDSR & GPIO_SSC_CLK ) { <S2SV_StartBug> if ( BUTTON_PRESS ( ) ) { <S2SV_EndBug> <S2SV_StartBug> DbpString ( "Stopped" ) ; <S2SV_EndBug> return ; } WDT_HIT ( ) ; } i ++ ; if ( i == period ) { i = 0 ; if ( gap ) { SHORT_COIL ( ) ; SpinDelayUs ( gap ) ; } } } } | <S2SV_ModStart> ) ) { FpgaWriteConfWord ( FPGA_MAJOR_MODE_OFF ) ; <S2SV_ModStart> BUTTON_PRESS ( ) || ( usb_poll_validate_length ( ) ) <S2SV_ModStart> DbpString ( "Stopped" ) ; FpgaWriteConfWord ( FPGA_MAJOR_MODE_OFF |
1,663 | CWE-000 void transport_receiver ( unsigned char * buffer , size_t buffer_len ) { int i ; sml_file * file = sml_file_parse ( buffer + 8 , buffer_len - 16 ) ; sml_file_print ( file ) ; printf ( "OBIS<S2SV_blank>data\\n" ) ; for ( i = 0 ; i < file -> messages_len ; i ++ ) { sml_message * message = file -> messages [ i ] ; if ( * message -> message_body -> tag == SML_MESSAGE_GET_LIST_RESPONSE ) { double value ; sml_list * entry ; sml_get_list_response * body ; body = ( sml_get_list_response * ) message -> message_body -> data ; for ( entry = body -> val_list ; entry != NULL ; entry = entry -> next ) { value = sml_value_to_double ( entry -> value ) ; if ( value != 0 ) { int scaler = ( entry -> scaler ) ? * entry -> scaler : 1 ; if ( scaler == - 1 ) value *= 0.1 ; printf ( "%d-%d:%d.%d.%d*%d#%.1f#" , entry -> obj_name -> str [ 0 ] , entry -> obj_name -> str [ 1 ] , entry -> obj_name -> str [ 2 ] , entry -> obj_name -> str [ 3 ] , entry -> obj_name -> str [ 4 ] , entry -> obj_name -> str [ 5 ] , value ) ; switch ( * entry -> unit ) { case 0x1B : printf ( "W" ) ; break ; case 0x1E : printf ( "Wh" ) ; break ; } printf ( "\\n" ) ; <S2SV_StartBug> } <S2SV_EndBug> } sml_file_free ( file ) ; <S2SV_StartBug> exit ( 0 ) ; <S2SV_EndBug> } } sml_file_free ( file ) ; } | <S2SV_ModStart> "\\n" ) ; fflush ( stdout ) ; } } <S2SV_ModStart> file ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,664 | CWE-000 bool device_attach_att ( struct btd_device * dev , GIOChannel * io ) { GError * gerr = NULL ; GAttrib * attrib ; BtIOSecLevel sec_level ; uint16_t mtu ; uint16_t cid ; struct btd_gatt_database * database ; bt_io_get ( io , & gerr , BT_IO_OPT_SEC_LEVEL , & sec_level , BT_IO_OPT_IMTU , & mtu , BT_IO_OPT_CID , & cid , BT_IO_OPT_INVALID ) ; if ( gerr ) { error ( "bt_io_get:<S2SV_blank>%s" , gerr -> message ) ; g_error_free ( gerr ) ; return false ; } if ( sec_level == BT_IO_SEC_LOW && dev -> le_state . paired ) { DBG ( "Elevating<S2SV_blank>security<S2SV_blank>level<S2SV_blank>since<S2SV_blank>LTK<S2SV_blank>is<S2SV_blank>available" ) ; sec_level = BT_IO_SEC_MEDIUM ; bt_io_set ( io , & gerr , BT_IO_OPT_SEC_LEVEL , sec_level , BT_IO_OPT_INVALID ) ; if ( gerr ) { error ( "bt_io_set:<S2SV_blank>%s" , gerr -> message ) ; g_error_free ( gerr ) ; return false ; } } dev -> att_mtu = MIN ( mtu , BT_ATT_MAX_LE_MTU ) ; <S2SV_StartBug> attrib = g_attrib_new ( io , dev -> att_mtu ) ; <S2SV_EndBug> if ( ! attrib ) { error ( "Unable<S2SV_blank>to<S2SV_blank>create<S2SV_blank>new<S2SV_blank>GAttrib<S2SV_blank>instance" ) ; return false ; } dev -> attrib = attrib ; dev -> att = g_attrib_get_att ( attrib ) ; bt_att_ref ( dev -> att ) ; dev -> att_disconn_id = bt_att_register_disconnect ( dev -> att , att_disconnected_cb , dev , NULL ) ; bt_att_set_close_on_unref ( dev -> att , true ) ; if ( dev -> local_csrk ) bt_att_set_local_key ( dev -> att , dev -> local_csrk -> key , local_counter , dev ) ; if ( dev -> remote_csrk ) bt_att_set_remote_key ( dev -> att , dev -> remote_csrk -> key , remote_counter , dev ) ; database = btd_adapter_get_database ( dev -> adapter ) ; gatt_client_init ( dev ) ; gatt_server_init ( dev , btd_gatt_database_get_db ( database ) ) ; adapter_connect_list_remove ( dev -> adapter , dev ) ; return true ; } | <S2SV_ModStart> dev -> att_mtu , false |
1,665 | CWE-000 void netcode_server_connect_client ( struct netcode_server_t * server , int client_index , struct netcode_address_t * address , uint64_t client_id , int encryption_index ) { assert ( server ) ; assert ( server -> running ) ; assert ( client_index >= 0 ) ; assert ( client_index < server -> max_clients ) ; assert ( address ) ; assert ( encryption_index != - 1 ) ; server -> num_connected_clients ++ ; assert ( server -> num_connected_clients <= server -> max_clients ) ; assert ( server -> client_connected [ client_index ] == 0 ) ; server -> client_connected [ client_index ] = 1 ; server -> client_encryption_index [ client_index ] = encryption_index ; server -> client_id [ client_index ] = client_id ; server -> client_sequence [ client_index ] = 0 ; server -> client_address [ client_index ] = * address ; server -> client_last_packet_send_time [ client_index ] = server -> time ; server -> client_last_packet_receive_time [ client_index ] = server -> time ; char address_string [ NETCODE_MAX_ADDRESS_STRING_LENGTH ] ; netcode_printf ( NETCODE_LOG_LEVEL_INFO , "server<S2SV_blank>accepted<S2SV_blank>client<S2SV_blank>%.16" PRIx64 "<S2SV_blank>%s<S2SV_blank>in<S2SV_blank>slot<S2SV_blank>%d\\n" , client_id , netcode_address_to_string ( address , address_string ) , client_index ) ; struct netcode_connection_keep_alive_packet_t packet ; packet . packet_type = NETCODE_CONNECTION_KEEP_ALIVE_PACKET ; packet . client_index = client_index ; <S2SV_StartBug> netcode_server_send_client_packet ( server , & packet , client_index ) ; <S2SV_EndBug> } | <S2SV_ModStart> = client_index ; packet . max_clients = server -> max_clients ; |
1,666 | CWE-000 static Node * insertNode ( Node * tree , char * word , int file_num ) { if ( tree == NULL ) { return newNode ( word ) ; } if ( strcasecmp ( tree -> word , word ) < 0 ) { tree -> rightNode = insertNode ( tree -> rightNode , word , file_num ) ; } else if ( strcasecmp ( tree -> word , word ) > 0 ) { tree -> leftNode = insertNode ( tree -> leftNode , word , file_num ) ; } else { <S2SV_StartBug> if ( tree -> count < file_num ) <S2SV_EndBug> { tree -> count ++ ; } } return tree ; } | <S2SV_ModStart> { if ( file_num != 1 && |
1,667 | CWE-000 int main ( void ) { HAL_Init ( ) ; SystemClock_Config ( ) ; MX_GPIO_Init ( ) ; MX_I2C2_Init ( ) ; MX_RTC_Init ( ) ; MX_USART2_UART_Init ( ) ; pca9685_init ( ) ; pca9685_set_pin ( 1 , 2048 ) ; <S2SV_StartBug> while ( 1 ) <S2SV_EndBug> { <S2SV_StartBug> } <S2SV_EndBug> } | <S2SV_ModStart> 2048 ) ; HAL_GPIO_WritePin ( OutputEnable_GPIO_Port , OutputEnable_Pin , 0 ) ; <S2SV_ModStart> 1 ) { HAL_GPIO_WritePin ( OutputEnable_GPIO_Port , OutputEnable_Pin , 0 ) ; |
1,668 | CWE-000 int contemplate_new_session ( ) { if ( packd . hook == 3 ) return contemplate_new_session_output ( ) ; if ( packd . hook == 2 ) { if ( packd . nb_mptcp_options > 0 ) return contemplate_new_session_input ( ) ; else return contemplate_new_session_output ( ) ; } if ( packd . hook == 1 && packd . nb_mptcp_options > 0 ) return contemplate_new_session_input ( ) ; snprintf ( msg_buf , MAX_MSG_LENGTH , "contemplate_new_session:<S2SV_blank>nb_mptcp_options=%zu,<S2SV_blank>hook=%zu,<S2SV_blank>fwd_type=%zu,<S2SV_blank>no<S2SV_blank>action<S2SV_blank>taken" , packd . nb_mptcp_options , packd . hook , packd . fwd_type ) ; add_msg ( msg_buf ) ; <S2SV_StartBug> set_verdict ( 1 , 0 , 0 ) ; <S2SV_EndBug> return 0 ; } | <S2SV_ModStart> msg_buf ) ; <S2SV_ModEnd> return 0 ; |
1,669 | CWE-000 static void bfq_exit_queue ( struct elevator_queue * e ) { struct bfq_data * bfqd = e -> elevator_data ; struct request_queue * q = bfqd -> queue ; struct bfq_queue * bfqq , * n ; bfq_shutdown_timer_wq ( bfqd ) ; spin_lock_irq ( q -> queue_lock ) ; BUG_ON ( bfqd -> in_service_queue ) ; list_for_each_entry_safe ( bfqq , n , & bfqd -> idle_list , bfqq_list ) bfq_deactivate_bfqq ( bfqd , bfqq , false , false ) ; spin_unlock_irq ( q -> queue_lock ) ; bfq_shutdown_timer_wq ( bfqd ) ; BUG_ON ( hrtimer_active ( & bfqd -> idle_slice_timer ) ) ; # ifdef CONFIG_BFQ_GROUP_IOSCHED blkcg_deactivate_policy ( q , & blkcg_policy_bfq ) ; # else <S2SV_StartBug> kfree ( bfqd -> root_group ) ; <S2SV_EndBug> # endif kfree ( bfqd ) ; } | <S2SV_ModStart> ; # else bfq_put_async_queues ( bfqd , bfqd -> root_group ) ; |
1,670 | CWE-000 void pchar ( stack_t * * stack , unsigned int line_number ) { int i ; if ( stack_len ( * stack ) < 1 || * stack == NULL ) { printf ( "L%u:<S2SV_blank>can\'t<S2SV_blank>pchar,<S2SV_blank>stack<S2SV_blank>empty\\n" , line_number ) ; exit ( EXIT_FAILURE ) ; } i = ( * stack ) -> n ; <S2SV_StartBug> if ( i <= 0 && i >= 127 ) <S2SV_EndBug> { printf ( "L%u:<S2SV_blank>can\'t<S2SV_blank>pchar,<S2SV_blank>value<S2SV_blank>out<S2SV_blank>of<S2SV_blank>range\\n" , line_number ) ; exit ( EXIT_FAILURE ) ; } printf ( "%c\\n" , i ) ; } | <S2SV_ModStart> i <= 0 || i >= 128 <S2SV_ModEnd> ) { printf |
1,671 | CWE-000 void USBD_Reset ( void ) { uint32_t i ; <S2SV_StartBug> for ( i = 1 ; i < 16 ; i ++ ) { <S2SV_EndBug> USB0 -> ENDPOINT [ i ] . ENDPT = 0x00 ; <S2SV_StartBug> } <S2SV_EndBug> BD [ IDX ( 0 , RX , ODD ) ] . bc = USBD_MAX_PACKET0 ; BD [ IDX ( 0 , RX , ODD ) ] . buf_addr = ( uint32_t ) & ( EPBuf [ IDX ( 0 , RX , ODD ) ] [ 0 ] ) ; BD [ IDX ( 0 , RX , ODD ) ] . stat = BD_OWN_MASK | BD_DTS_MASK | BD_DATA01_MASK ; BD [ IDX ( 0 , RX , EVEN ) ] . stat = 0 ; BD [ IDX ( 0 , TX , ODD ) ] . buf_addr = ( uint32_t ) & ( EPBuf [ IDX ( 0 , TX , ODD ) ] [ 0 ] ) ; BD [ IDX ( 0 , TX , EVEN ) ] . buf_addr = 0 ; USB0 -> ENDPOINT [ 0 ] . ENDPT = USB_ENDPT_EPHSHK_MASK | USB_ENDPT_EPTXEN_MASK | USB_ENDPT_EPRXEN_MASK ; Data1 = 0x55555555 ; USB0 -> CTL |= USB_CTL_ODDRST_MASK ; USB0 -> ISTAT = 0xFF ; USB0 -> ERRSTAT = 0xFF ; USB0 -> ERREN = 0xFF ; USB0 -> ADDR = 0x00 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> uint32_t i ; NVIC_DisableIRQ ( USB0_IRQn ) ; <S2SV_ModStart> 0x00 ; } memset ( StatQueue , 0 , sizeof ( StatQueue ) ) ; StatQueueHead = 0 ; StatQueueTail = 0 ; LastIstat = 0 ; UsbSuspended = 0 ; <S2SV_ModStart> = 0x00 ; NVIC_EnableIRQ ( USB0_IRQn ) ; |
1,672 | CWE-000 int all_case_redirection ( t_word * list ) { int res ; res = 0 ; while ( list && ! is_logic ( list -> type ) && list -> type != SEMI_DOT && list -> type != PIPE ) { if ( list -> type == GREAT ) res = redi_great ( list ) ; else if ( list -> type == DGREAT ) res = redi_dgreat ( list ) ; else if ( list -> type == GREATAND ) res = redi_greatand ( list ) ; else if ( list -> type == GREATANDMINUS ) res = redi_greatandminus ( list ) ; <S2SV_StartBug> else if ( list -> type == LESS ) <S2SV_EndBug> res = redi_less ( list ) ; else if ( list -> type == LESSAND ) res = redi_lessand ( list ) ; else if ( list -> type == LESSANDMINUS ) res = redi_lessandminus ( list ) ; if ( res < 0 ) return ( - 1 ) ; list = list -> next ; } return ( 0 ) ; } | <S2SV_ModStart> -> type == <S2SV_ModEnd> LESSAND ) res |
1,673 | CWE-000 static int sof_probe ( struct platform_device * pdev ) { struct snd_sof_pdata * plat_data = dev_get_platdata ( & pdev -> dev ) ; struct snd_sof_dev * sdev ; int ret ; sdev = devm_kzalloc ( & pdev -> dev , sizeof ( * sdev ) , GFP_KERNEL ) ; if ( sdev == NULL ) return - ENOMEM ; dev_dbg ( & pdev -> dev , "probing<S2SV_blank>SOF<S2SV_blank>DSP<S2SV_blank>device....\\n" ) ; sdev -> dev = & pdev -> dev ; if ( plat_data -> pci ) { sdev -> pci = plat_data -> pci ; sdev -> parent = & plat_data -> pci -> dev ; } else if ( plat_data -> pdev ) { sdev -> parent = & plat_data -> pdev -> dev ; } else sdev -> parent = plat_data -> dev ; sdev -> ops = plat_data -> machine -> ops ; sdev -> pdata = plat_data ; INIT_LIST_HEAD ( & sdev -> pcm_list ) ; INIT_LIST_HEAD ( & sdev -> kcontrol_list ) ; INIT_LIST_HEAD ( & sdev -> widget_list ) ; dev_set_drvdata ( & pdev -> dev , sdev ) ; <S2SV_StartBug> snd_sof_new_platform_drv ( sdev ) ; <S2SV_EndBug> snd_sof_new_dai_drv ( sdev ) ; if ( plat_data -> desc -> ipc_timeout == 0 ) sdev -> ipc_timeout = TIMEOUT_IPC ; else sdev -> ipc_timeout = plat_data -> desc -> ipc_timeout ; if ( plat_data -> desc -> boot_timeout == 0 ) sdev -> boot_timeout = TIMEOUT_BOOT ; else sdev -> boot_timeout = plat_data -> desc -> boot_timeout ; ret = snd_sof_probe ( sdev ) ; if ( ret < 0 ) { dev_err ( sdev -> dev , "error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>probe<S2SV_blank>DSP<S2SV_blank>%d\\n" , ret ) ; return ret ; } ret = snd_sof_dbg_init ( sdev ) ; if ( ret < 0 ) { dev_err ( sdev -> dev , "error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>init<S2SV_blank>DSP<S2SV_blank>trace/debug<S2SV_blank>%d\\n" , ret ) ; return ret ; } sdev -> ipc = snd_sof_ipc_init ( sdev ) ; if ( sdev -> ipc == NULL ) { dev_err ( sdev -> dev , "error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>init<S2SV_blank>DSP<S2SV_blank>IPC<S2SV_blank>%d\\n" , ret ) ; goto err ; } ret = snd_sof_load_firmware ( sdev , plat_data -> fw ) ; if ( ret < 0 ) { dev_err ( sdev -> dev , "error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>load<S2SV_blank>DSP<S2SV_blank>firmware<S2SV_blank>%d\\n" , ret ) ; goto err ; } ret = snd_sof_run_firmware ( sdev ) ; if ( ret < 0 ) { dev_err ( sdev -> dev , "error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>boot<S2SV_blank>DSP<S2SV_blank>firmware<S2SV_blank>%d\\n" , ret ) ; goto err ; } ret = snd_soc_register_platform ( & pdev -> dev , & sdev -> plat_drv ) ; if ( ret < 0 ) { dev_err ( sdev -> dev , "error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>DSP<S2SV_blank>platform<S2SV_blank>driver<S2SV_blank>%d\\n" , ret ) ; goto err ; } ret = snd_soc_register_component ( & pdev -> dev , sdev -> cmpnt_drv , & sdev -> dai_drv , sdev -> num_dai ) ; if ( ret < 0 ) { dev_err ( sdev -> dev , "error:<S2SV_blank>failed<S2SV_blank>to<S2SV_blank>register<S2SV_blank>DSP<S2SV_blank>DAI<S2SV_blank>driver<S2SV_blank>%d\\n" , ret ) ; goto err ; } err : # if defined DEBUG return 0 ; # else return ret ; # endif } | <S2SV_ModStart> sdev ) ; spin_lock_init ( & sdev -> ipc_lock ) ; spin_lock_init ( & sdev -> hw_lock ) ; |
1,674 | CWE-000 static void get_path ( t_ls_file * file , char * path ) { size_t path_len ; size_t name_len ; char * path_tmp ; char * name_tmp ; if ( ! * path ) <S2SV_StartBug> if ( ! ( file -> path = ft_strdup ( file -> name ) ) ) <S2SV_EndBug> ft_error ( "Error:<S2SV_blank>ft_strdup<S2SV_blank>failed" ) ; <S2SV_StartBug> path_len = ft_strlen ( path ) ; <S2SV_EndBug> name_len = ft_strlen ( file -> name ) ; <S2SV_StartBug> if ( ! ( file -> path = ( char * ) malloc ( path_len + name_len + 2 ) ) ) <S2SV_EndBug> ft_error ( "Error:<S2SV_blank>malloc<S2SV_blank>failed." ) ; <S2SV_StartBug> path_tmp = file -> path ; <S2SV_EndBug> while ( * path ) * path_tmp ++ = * path ++ ; * path_tmp ++ = '/' ; name_tmp = file -> name ; while ( * name_tmp ) * path_tmp ++ = * name_tmp ++ ; * path_tmp = '\\0' ; } | <S2SV_ModStart> * path ) { <S2SV_ModStart> "Error:<S2SV_blank>ft_strdup<S2SV_blank>failed" ) ; return ; } <S2SV_ModStart> ( ! ( path_tmp <S2SV_ModEnd> = ( char <S2SV_ModStart> "Error:<S2SV_blank>malloc<S2SV_blank>failed." ) ; <S2SV_ModEnd> file -> path <S2SV_ModStart> file -> path = path_tmp |
1,675 | CWE-000 void init_globals ( void ) { gGameState = TITLE_SCREEN_STATE ; gDisplayLives = 0 ; gPpuCtrlBase = 0x94 ; gMusicOn = 0 ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> = 0 ; gSoundEffectCounter = 0xFF ; |
1,676 | CWE-000 int32_t LP_mypriceset ( int32_t * changedp , char * base , char * rel , double price ) { struct LP_priceinfo * basepp , * relpp ; struct LP_pubkeyinfo * pubp ; * changedp = 0 ; if ( base != 0 && rel != 0 && ( basepp = LP_priceinfofind ( base ) ) != 0 && ( relpp = LP_priceinfofind ( rel ) ) != 0 ) { if ( fabs ( basepp -> myprices [ relpp -> ind ] - price ) / price > 0.001 ) * changedp = 1 ; basepp -> myprices [ relpp -> ind ] = price ; if ( ( pubp = LP_pubkeyadd ( G . LP_mypub25519 ) ) != 0 ) { pubp -> timestamp = ( uint32_t ) time ( NULL ) ; pubp -> matrix [ basepp -> ind ] [ relpp -> ind ] = price ; <S2SV_StartBug> pubp -> timestamps [ basepp -> ind ] [ relpp -> ind ] = pubp -> timestamp ; <S2SV_EndBug> } return ( 0 ) ; } else return ( - 1 ) ; } | <S2SV_ModStart> = price ; <S2SV_ModEnd> } return ( |
1,677 | CWE-000 <S2SV_StartBug> static void CG_DoSaber ( vec3_t origin , vec3_t dir , float length , saber_colors_t color , int rfx ) <S2SV_EndBug> { vec3_t mid , rgb = { 1 , 1 , 1 } ; qhandle_t blade = 0 , glow = 0 ; refEntity_t saber ; float radiusmult ; if ( length < 0.5f ) { return ; } VectorMA ( origin , length * 0.5f , dir , mid ) ; switch ( color ) { case SABER_RED : glow = cgs . media . redSaberGlowShader ; blade = cgs . media . redSaberCoreShader ; VectorSet ( rgb , 1.0f , 0.2f , 0.2f ) ; break ; case SABER_ORANGE : glow = cgs . media . orangeSaberGlowShader ; blade = cgs . media . orangeSaberCoreShader ; VectorSet ( rgb , 1.0f , 0.5f , 0.1f ) ; break ; case SABER_YELLOW : glow = cgs . media . yellowSaberGlowShader ; blade = cgs . media . yellowSaberCoreShader ; VectorSet ( rgb , 1.0f , 1.0f , 0.2f ) ; break ; case SABER_GREEN : glow = cgs . media . greenSaberGlowShader ; blade = cgs . media . greenSaberCoreShader ; VectorSet ( rgb , 0.2f , 1.0f , 0.2f ) ; break ; case SABER_BLUE : glow = cgs . media . blueSaberGlowShader ; blade = cgs . media . blueSaberCoreShader ; VectorSet ( rgb , 0.2f , 0.4f , 1.0f ) ; break ; case SABER_PURPLE : glow = cgs . media . purpleSaberGlowShader ; blade = cgs . media . purpleSaberCoreShader ; VectorSet ( rgb , 0.9f , 0.2f , 1.0f ) ; break ; default : glow = cgs . media . blueSaberGlowShader ; blade = cgs . media . blueSaberCoreShader ; VectorSet ( rgb , 0.2f , 0.4f , 1.0f ) ; break ; } trap_R_AddLightToScene ( mid , ( length * 2.0f ) + ( random ( ) * 8.0f ) , rgb [ 0 ] , rgb [ 1 ] , rgb [ 2 ] ) ; memset ( & saber , 0 , sizeof ( refEntity_t ) ) ; if ( isnan ( length ) ) return ; saber . saberLength = length ; if ( length < SABER_LENGTH_MAX ) { radiusmult = 1.0f + ( 2.0f / length ) ; } else { radiusmult = 1.0f ; } saber . radius = ( 2.8f + crandom ( ) * 0.2f ) * radiusmult ; VectorCopy ( origin , saber . origin ) ; VectorCopy ( dir , saber . axis [ 0 ] ) ; saber . reType = RT_SABER_GLOW ; saber . customShader = glow ; saber . shaderRGBA [ 0 ] = saber . shaderRGBA [ 1 ] = saber . shaderRGBA [ 2 ] = saber . shaderRGBA [ 3 ] = 0xff ; saber . renderfx = rfx ; trap_R_AddRefEntityToScene ( & saber ) ; VectorMA ( origin , length , dir , saber . origin ) ; VectorMA ( origin , - 1 , dir , saber . oldorigin ) ; saber . customShader = blade ; saber . reType = RT_LINE ; saber . radius = ( 1.0f + crandom ( ) * 0.2f ) * radiusmult ; saber . shaderTexCoord [ 0 ] = saber . shaderTexCoord [ 1 ] = 1.0f ; saber . shaderRGBA [ 0 ] = saber . shaderRGBA [ 1 ] = saber . shaderRGBA [ 2 ] = saber . shaderRGBA [ 3 ] = 0xff ; trap_R_AddRefEntityToScene ( & saber ) ; } | <S2SV_ModStart> void CG_DoSaber ( const <S2SV_ModStart> vec3_t origin , const |
1,678 | CWE-000 static int d_demangle_callback ( const char * mangled , int options , demangle_callbackref callback , void * opaque ) { enum { DCT_TYPE , DCT_MANGLED , DCT_GLOBAL_CTORS , DCT_GLOBAL_DTORS } type ; struct d_info di ; struct demangle_component * dc ; int status ; if ( mangled [ 0 ] == '_' && mangled [ 1 ] == 'Z' ) type = DCT_MANGLED ; else if ( strncmp ( mangled , "_GLOBAL_" , 8 ) == 0 && ( mangled [ 8 ] == '.' || mangled [ 8 ] == '_' || mangled [ 8 ] == '$' ) && ( mangled [ 9 ] == 'D' || mangled [ 9 ] == 'I' ) && mangled [ 10 ] == '_' ) type = mangled [ 9 ] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS ; else { if ( ( options & DMGL_TYPES ) == 0 ) return 0 ; type = DCT_TYPE ; } cplus_demangle_init_info ( mangled , options , strlen ( mangled ) , & di ) ; { # ifdef CP_DYNAMIC_ARRAYS __extension__ struct demangle_component comps [ di . num_comps ] ; __extension__ struct demangle_component * subs [ di . num_subs ] ; di . comps = comps ; di . subs = subs ; # else <S2SV_StartBug> di . comps = alloca ( di . num_comps * sizeof ( * di . comps ) ) ; <S2SV_EndBug> <S2SV_StartBug> di . subs = alloca ( di . num_subs * sizeof ( * di . subs ) ) ; <S2SV_EndBug> # endif switch ( type ) { case DCT_TYPE : dc = cplus_demangle_type ( & di ) ; break ; case DCT_MANGLED : dc = cplus_demangle_mangled_name ( & di , 1 ) ; break ; case DCT_GLOBAL_CTORS : case DCT_GLOBAL_DTORS : d_advance ( & di , 11 ) ; dc = d_make_comp ( & di , ( type == DCT_GLOBAL_CTORS ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS ) , d_make_demangle_mangled_name ( & di , d_str ( & di ) ) , NULL ) ; d_advance ( & di , strlen ( d_str ( & di ) ) ) ; break ; } if ( ( ( options & DMGL_PARAMS ) != 0 ) && d_peek_char ( & di ) != '\\0' ) dc = NULL ; # ifdef CP_DEMANGLE_DEBUG d_dump ( dc , 0 ) ; # endif status = ( dc != NULL ) ? cplus_demangle_print_callback ( options , dc , callback , opaque ) : 0 ; } return status ; } | <S2SV_ModStart> ; # else # ifdef _MSC_VER di . comps = calloc ( di . num_comps * sizeof ( * di . comps ) , 1 ) ; di . subs = calloc ( di . num_subs * sizeof ( * di . subs ) , 1 ) ; # else <S2SV_ModStart> ) ) ; # endif |
1,679 | CWE-000 int msm_jpeg_hw_exec_cmds ( struct msm_jpeg_hw_cmd * hw_cmd_p , uint32_t m_cmds , uint32_t max_size , void * base ) { int is_copy_to_user = - 1 ; uint32_t data ; while ( m_cmds -- ) { <S2SV_StartBug> if ( hw_cmd_p -> offset > max_size ) { <S2SV_EndBug> JPEG_PR_ERR ( "%s:%d]<S2SV_blank>%d<S2SV_blank>exceed<S2SV_blank>hw<S2SV_blank>region<S2SV_blank>%d\\n" , __func__ , __LINE__ , hw_cmd_p -> offset , max_size ) ; return - EFAULT ; } if ( hw_cmd_p -> offset & 0x3 ) { JPEG_PR_ERR ( "%s:%d]<S2SV_blank>%d<S2SV_blank>Invalid<S2SV_blank>alignment\\n" , __func__ , __LINE__ , hw_cmd_p -> offset ) ; return - EFAULT ; } switch ( hw_cmd_p -> type ) { case MSM_JPEG_HW_CMD_TYPE_READ : hw_cmd_p -> data = msm_jpeg_hw_read ( hw_cmd_p , base ) ; is_copy_to_user = 1 ; break ; case MSM_JPEG_HW_CMD_TYPE_WRITE : msm_jpeg_hw_write ( hw_cmd_p , base ) ; break ; case MSM_JPEG_HW_CMD_TYPE_WRITE_OR : data = msm_jpeg_hw_read ( hw_cmd_p , base ) ; hw_cmd_p -> data = ( hw_cmd_p -> data & hw_cmd_p -> mask ) | data ; msm_jpeg_hw_write ( hw_cmd_p , base ) ; break ; case MSM_JPEG_HW_CMD_TYPE_UWAIT : msm_jpeg_hw_wait ( hw_cmd_p , 1 , base ) ; break ; case MSM_JPEG_HW_CMD_TYPE_MWAIT : msm_jpeg_hw_wait ( hw_cmd_p , 1000 , base ) ; break ; case MSM_JPEG_HW_CMD_TYPE_UDELAY : msm_jpeg_hw_delay ( hw_cmd_p , 1 ) ; break ; case MSM_JPEG_HW_CMD_TYPE_MDELAY : msm_jpeg_hw_delay ( hw_cmd_p , 1000 ) ; break ; default : JPEG_PR_ERR ( "wrong<S2SV_blank>hw<S2SV_blank>command<S2SV_blank>type\\n" ) ; break ; } hw_cmd_p ++ ; } return is_copy_to_user ; } | <S2SV_ModStart> hw_cmd_p -> offset >= <S2SV_ModEnd> max_size ) { |
1,680 | CWE-000 LinkedListValue linked_list_pop_element ( LinkedList * l ) { void * result = NULL ; <S2SV_StartBug> if ( LOCK_LIST ) { <S2SV_EndBug> pthread_mutex_lock ( & ( l -> mutex ) ) ; <S2SV_StartBug> } <S2SV_EndBug> LinkedListItem * li = l -> head ; if ( li != NULL ) { if ( li -> prev != NULL ) { li -> prev -> next = NULL ; } else { l -> tail = NULL ; } l -> head = li -> prev ; l -> count -- ; result = li -> value ; free ( li ) ; } <S2SV_StartBug> if ( LOCK_LIST ) { <S2SV_EndBug> pthread_mutex_unlock ( & ( l -> mutex ) ) ; <S2SV_StartBug> } <S2SV_EndBug> return result ; } | <S2SV_ModStart> = NULL ; <S2SV_ModEnd> pthread_mutex_lock ( & <S2SV_ModStart> ) ) ; <S2SV_ModEnd> LinkedListItem * li <S2SV_ModStart> ) ; } <S2SV_ModEnd> pthread_mutex_unlock ( & <S2SV_ModStart> ) ) ; <S2SV_ModEnd> return result ; |
1,681 | CWE-000 static void omap_hsmmc_soft_timeout ( unsigned long data ) { struct omap_hsmmc_host * host = ( struct omap_hsmmc_host * ) data ; hsmmc_command_incomplete ( host , - ETIMEDOUT , 0 ) ; <S2SV_StartBug> } <S2SV_EndBug> | <S2SV_ModStart> 0 ) ; host -> data_timeout = 0 ; |
1,682 | CWE-000 static int glusterBlockParseArgs ( int count , char * * options ) { int ret = 0 ; size_t opt = 0 ; int json = GB_JSON_NONE ; opt = glusterBlockCLIOptEnumParse ( options [ 1 ] ) ; if ( ! opt || opt >= GB_CLI_OPT_MAX ) { <S2SV_StartBug> MSG ( "Unknown<S2SV_blank>option:<S2SV_blank>%s\\n" , options [ 1 ] ) ; <S2SV_EndBug> return - 1 ; } if ( opt > 0 && opt < GB_CLI_HELP ) { json = jsonResponseFormatParse ( options [ count - 1 ] ) ; if ( json == GB_JSON_MAX ) { <S2SV_StartBug> MSG ( "expecting<S2SV_blank>\'--json*\',<S2SV_blank>got<S2SV_blank>\'%s\'\\n" , <S2SV_EndBug> options [ count - 1 ] ) ; return - 1 ; } else if ( json != GB_JSON_NONE ) { count -- ; } } while ( 1 ) { switch ( opt ) { case GB_CLI_CREATE : ret = glusterBlockCreate ( count , options , json ) ; if ( ret && ret != EEXIST ) { LOG ( "cli" , GB_LOG_ERROR , "%s" , FAILED_CREATE ) ; } goto out ; case GB_CLI_LIST : ret = glusterBlockList ( count , options , json ) ; if ( ret ) { LOG ( "cli" , GB_LOG_ERROR , "%s" , FAILED_LIST ) ; } goto out ; case GB_CLI_INFO : ret = glusterBlockInfo ( count , options , json ) ; if ( ret ) { LOG ( "cli" , GB_LOG_ERROR , "%s" , FAILED_INFO ) ; } goto out ; case GB_CLI_MODIFY : ret = glusterBlockModify ( count , options , json ) ; if ( ret ) { LOG ( "cli" , GB_LOG_ERROR , "%s" , FAILED_MODIFY ) ; } goto out ; case GB_CLI_REPLACE : ret = glusterBlockReplace ( count , options , json ) ; if ( ret ) { LOG ( "cli" , GB_LOG_ERROR , "%s" , FAILED_REPLACE ) ; } goto out ; case GB_CLI_GENCONFIG : ret = glusterBlockGenConfig ( count , options , json ) ; if ( ret ) { LOG ( "cli" , GB_LOG_ERROR , "%s" , FAILED_GENCONFIG ) ; } goto out ; case GB_CLI_DELETE : ret = glusterBlockDelete ( count , options , json ) ; if ( ret ) { LOG ( "cli" , GB_LOG_ERROR , "%s" , FAILED_DELETE ) ; } goto out ; case GB_CLI_HELP : case GB_CLI_HYPHEN_HELP : case GB_CLI_USAGE : case GB_CLI_HYPHEN_USAGE : glusterBlockHelp ( ) ; goto out ; case GB_CLI_VERSION : case GB_CLI_HYPHEN_VERSION : <S2SV_StartBug> MSG ( "%s\\n" , argp_program_version ) ; <S2SV_EndBug> goto out ; } } out : return ret ; } | <S2SV_ModStart> { MSG ( stderr , <S2SV_ModStart> { MSG ( stderr , <S2SV_ModStart> : MSG ( stdout , |
1,683 | CWE-000 static int cxd2841er_write_reg ( struct cxd2841er_priv * priv , u8 addr , u8 reg , u8 val ) { <S2SV_StartBug> return cxd2841er_write_regs ( priv , addr , reg , & val , 1 ) ; <S2SV_EndBug> } | <S2SV_ModStart> val ) { u8 tmp = val ; <S2SV_ModStart> reg , & tmp <S2SV_ModEnd> , 1 ) |
1,684 | CWE-000 char * _gwd ( ) { size_t size = 255 ; char * pwd ; while ( ( pwd = getcwd ( NULL , size ) ) == NULL ) { switch ( errno ) { case ERANGE : size = ( size * 3 ) / 2 ; continue ; <S2SV_StartBug> case EACCES : error ( ALARM_PERMDENY ) ; return NULL ; <S2SV_EndBug> <S2SV_StartBug> default : error ( "" ) ; return NULL ; <S2SV_EndBug> } } return pwd ; } | <S2SV_ModStart> case EACCES : pwd_error <S2SV_ModEnd> ( ALARM_PERMDENY ) <S2SV_ModStart> ; default : pwd_error <S2SV_ModEnd> ( "" ) |
1,685 | CWE-000 static int init_tx_pools ( struct net_device * netdev ) { struct ibmvnic_adapter * adapter = netdev_priv ( netdev ) ; struct device * dev = & adapter -> vdev -> dev ; struct ibmvnic_tx_pool * tx_pool ; int tx_subcrqs ; int i , j ; tx_subcrqs = be32_to_cpu ( adapter -> login_rsp_buf -> num_txsubm_subcrqs ) ; adapter -> tx_pool = kcalloc ( tx_subcrqs , sizeof ( struct ibmvnic_tx_pool ) , GFP_KERNEL ) ; if ( ! adapter -> tx_pool ) return - 1 ; <S2SV_StartBug> for ( i = 0 ; i < tx_subcrqs ; i ++ ) { <S2SV_EndBug> tx_pool = & adapter -> tx_pool [ i ] ; netdev_dbg ( adapter -> netdev , "Initializing<S2SV_blank>tx_pool[%d],<S2SV_blank>%lld<S2SV_blank>buffs\\n" , i , adapter -> req_tx_entries_per_subcrq ) ; tx_pool -> tx_buff = kcalloc ( adapter -> req_tx_entries_per_subcrq , sizeof ( struct ibmvnic_tx_buff ) , GFP_KERNEL ) ; if ( ! tx_pool -> tx_buff ) { dev_err ( dev , "tx<S2SV_blank>pool<S2SV_blank>buffer<S2SV_blank>allocation<S2SV_blank>failed\\n" ) ; release_tx_pools ( adapter ) ; return - 1 ; } if ( alloc_long_term_buff ( adapter , & tx_pool -> long_term_buff , adapter -> req_tx_entries_per_subcrq * adapter -> req_mtu ) ) { release_tx_pools ( adapter ) ; return - 1 ; } if ( alloc_long_term_buff ( adapter , & tx_pool -> tso_ltb , IBMVNIC_TSO_BUFS * IBMVNIC_TSO_BUF_SZ ) ) { release_tx_pools ( adapter ) ; return - 1 ; } tx_pool -> tso_index = 0 ; tx_pool -> free_map = kcalloc ( adapter -> req_tx_entries_per_subcrq , sizeof ( int ) , GFP_KERNEL ) ; if ( ! tx_pool -> free_map ) { release_tx_pools ( adapter ) ; return - 1 ; } for ( j = 0 ; j < adapter -> req_tx_entries_per_subcrq ; j ++ ) tx_pool -> free_map [ j ] = j ; tx_pool -> consumer_index = 0 ; tx_pool -> producer_index = 0 ; } <S2SV_StartBug> return 0 ; <S2SV_EndBug> } | <S2SV_ModStart> - 1 ; adapter -> num_active_tx_pools = 0 ; <S2SV_ModStart> 0 ; } adapter -> num_active_tx_pools = tx_subcrqs ; |
1,686 | CWE-000 SPDConnection * spd_open2 ( const char * client_name , const char * connection_name , const char * user_name , SPDConnectionMode mode , SPDConnectionAddress * address , int autospawn , char * * error_result ) { SPDConnection * connection = NULL ; SPDConnectionAddress * defaultAddress = NULL ; char * set_client_name = NULL ; char * conn_name = NULL ; char * usr_name = NULL ; int ret ; char tcp_no_delay = 1 ; int spawn_err ; gchar * spawn_report ; char * host_ip ; int is_localhost = 1 ; struct sockaddr_in address_inet ; struct sockaddr_un address_unix ; struct sockaddr * sock_address ; size_t sock_address_len ; _init_debug ( ) ; if ( client_name == NULL ) { * error_result = strdup ( "ERROR:<S2SV_blank>Client<S2SV_blank>name<S2SV_blank>not<S2SV_blank>specified" ) ; SPD_DBG ( * error_result ) ; return NULL ; } if ( user_name == NULL ) { usr_name = strdup ( ( char * ) g_get_user_name ( ) ) ; } else usr_name = strdup ( user_name ) ; if ( connection_name == NULL ) conn_name = strdup ( "main" ) ; else conn_name = strdup ( connection_name ) ; if ( address == NULL ) { char * err = NULL ; defaultAddress = spd_get_default_address ( & err ) ; address = defaultAddress ; if ( ! address ) { assert ( err ) ; * error_result = err ; SPD_DBG ( * error_result ) ; goto out ; } } connection = malloc ( sizeof ( SPDConnection ) ) ; if ( address -> method == SPD_METHOD_INET_SOCKET ) { gchar * resolve_error ; host_ip = resolve_host ( address -> inet_socket_host , & is_localhost , & resolve_error ) ; if ( host_ip == NULL ) { * error_result = strdup ( resolve_error ) ; <S2SV_StartBug> g_free ( resolve_error ) ; <S2SV_EndBug> goto out ; } address_inet . sin_addr . s_addr = inet_addr ( host_ip ) ; free ( host_ip ) ; address_inet . sin_port = htons ( address -> inet_socket_port ) ; address_inet . sin_family = AF_INET ; connection -> socket = socket ( AF_INET , SOCK_STREAM , 0 ) ; sock_address = ( struct sockaddr * ) & address_inet ; sock_address_len = sizeof ( address_inet ) ; } else if ( address -> method == SPD_METHOD_UNIX_SOCKET ) { address_unix . sun_family = AF_UNIX ; strncpy ( address_unix . sun_path , address -> unix_socket_name , sizeof ( address_unix . sun_path ) ) ; address_unix . sun_path [ sizeof ( address_unix . sun_path ) - 1 ] = '\\0' ; connection -> socket = socket ( AF_UNIX , SOCK_STREAM , 0 ) ; sock_address = ( struct sockaddr * ) & address_unix ; sock_address_len = SUN_LEN ( & address_unix ) ; } else SPD_FATAL ( "Unsupported<S2SV_blank>connection<S2SV_blank>method<S2SV_blank>for<S2SV_blank>spd_open2()" ) ; ret = connect ( connection -> socket , sock_address , sock_address_len ) ; if ( ret == - 1 ) { if ( autospawn ) { spawn_err = spawn_server ( address , is_localhost , & spawn_report ) ; if ( ! spawn_err ) spawn_report = g_strdup ( "Server<S2SV_blank>successfully<S2SV_blank>autospawned" ) ; ret = connect ( connection -> socket , sock_address , sock_address_len ) ; } else { spawn_report = g_strdup ( "Autospawn<S2SV_blank>disabled" ) ; } if ( ret == - 1 ) { if ( address -> method == SPD_METHOD_INET_SOCKET ) * error_result = g_strdup_printf ( "Error:<S2SV_blank>Can\'t<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>%s<S2SV_blank>on<S2SV_blank>port<S2SV_blank>%d<S2SV_blank>using<S2SV_blank>inet<S2SV_blank>sockets:<S2SV_blank>%s.<S2SV_blank>" "Autospawn:<S2SV_blank>%s" , address -> inet_socket_host , address -> inet_socket_port , strerror ( errno ) , spawn_report ) ; else if ( address -> method == SPD_METHOD_UNIX_SOCKET ) * error_result = g_strdup_printf ( "Error:<S2SV_blank>Can\'t<S2SV_blank>connect<S2SV_blank>to<S2SV_blank>unix<S2SV_blank>socket<S2SV_blank>%s:<S2SV_blank>%s.<S2SV_blank>Autospawn:<S2SV_blank>%s" , address -> unix_socket_name , strerror ( errno ) , spawn_report ) ; else assert ( 0 ) ; SPD_DBG ( * error_result ) ; close ( connection -> socket ) ; <S2SV_StartBug> goto out ; <S2SV_EndBug> } g_free ( spawn_report ) ; } if ( address -> method == SPD_METHOD_INET_SOCKET ) setsockopt ( connection -> socket , IPPROTO_TCP , TCP_NODELAY , & tcp_no_delay , sizeof ( int ) ) ; connection -> callback_begin = NULL ; connection -> callback_end = NULL ; connection -> callback_im = NULL ; connection -> callback_pause = NULL ; connection -> callback_resume = NULL ; connection -> callback_cancel = NULL ; connection -> mode = mode ; connection -> stream = fdopen ( connection -> socket , "r" ) ; if ( ! connection -> stream ) SPD_FATAL ( "Can\'t<S2SV_blank>create<S2SV_blank>a<S2SV_blank>stream<S2SV_blank>for<S2SV_blank>socket,<S2SV_blank>fdopen()<S2SV_blank>failed." ) ; ret = setvbuf ( connection -> stream , NULL , _IONBF , SPD_REPLY_BUF_SIZE ) ; if ( ret ) SPD_FATAL ( "Can\'t<S2SV_blank>set<S2SV_blank>buffering,<S2SV_blank>setvbuf<S2SV_blank>failed." ) ; pthread_mutex_init ( & connection -> ssip_mutex , NULL ) ; if ( mode == SPD_MODE_THREADED ) { SPD_DBG ( "Initializing<S2SV_blank>threads,<S2SV_blank>condition<S2SV_blank>variables<S2SV_blank>and<S2SV_blank>mutexes..." ) ; connection -> td = malloc ( sizeof ( * connection -> td ) ) ; pthread_cond_init ( & connection -> td -> cond_reply_ready , NULL ) ; pthread_mutex_init ( & connection -> td -> mutex_reply_ready , NULL ) ; pthread_cond_init ( & connection -> td -> cond_reply_ack , NULL ) ; pthread_mutex_init ( & connection -> td -> mutex_reply_ack , NULL ) ; ret = pthread_create ( & connection -> td -> events_thread , NULL , spd_events_handler , connection ) ; if ( ret != 0 ) { * error_result = strdup ( "Thread<S2SV_blank>initialization<S2SV_blank>failed" ) ; SPD_DBG ( * error_result ) ; fclose ( connection -> stream ) ; close ( connection -> socket ) ; <S2SV_StartBug> goto out ; <S2SV_EndBug> } } set_client_name = g_strdup_printf ( "SET<S2SV_blank>SELF<S2SV_blank>CLIENT_NAME<S2SV_blank>\\"%s:%s:%s\\"" , usr_name , client_name , conn_name ) ; ret = spd_execute_command_wo_mutex ( connection , set_client_name ) ; out : free ( usr_name ) ; free ( conn_name ) ; free ( set_client_name ) ; SPDConnectionAddress__free ( defaultAddress ) ; return connection ; } | <S2SV_ModStart> ( resolve_error ) ; free ( connection ) ; connection = NULL <S2SV_ModStart> socket ) ; free ( connection ) ; connection = NULL ; <S2SV_ModStart> socket ) ; free ( connection ) ; connection = NULL ; |
1,687 | CWE-000 int huge_ptep_set_access_flags ( struct vm_area_struct * vma , unsigned long addr , pte_t * ptep , pte_t pte , int dirty ) { pte_t * cpte ; if ( pte_cont ( pte ) ) { int ncontig , i , changed = 0 ; size_t pgsize = 0 ; unsigned long pfn = pte_pfn ( pte ) ; pgprot_t hugeprot = __pgprot ( pte_val ( pfn_pte ( pfn , __pgprot ( 0 ) ) ) ^ pte_val ( pte ) ) ; cpte = huge_pte_offset ( vma -> vm_mm , addr ) ; pfn = pte_pfn ( * cpte ) ; ncontig = find_num_contig ( vma -> vm_mm , addr , cpte , <S2SV_StartBug> * cpte , & pgsize ) ; <S2SV_EndBug> for ( i = 0 ; i < ncontig ; ++ i , ++ cpte , addr += pgsize ) { changed |= ptep_set_access_flags ( vma , addr , cpte , pfn_pte ( pfn , hugeprot ) , dirty ) ; pfn += pgsize >> PAGE_SHIFT ; } return changed ; } else { return ptep_set_access_flags ( vma , addr , ptep , pte , dirty ) ; } } | <S2SV_ModStart> , cpte , <S2SV_ModEnd> & pgsize ) |
1,688 | CWE-000 static <S2SV_StartBug> int loop ( unsigned int entry_point , unsigned int capacity ) <S2SV_EndBug> { unsigned int g = entry_point % capacity ; unsigned int res = ( g + capacity ) % capacity ; int s_res = ( int ) res ; <S2SV_StartBug> return s_res ; <S2SV_EndBug> } | <S2SV_ModStart> <S2SV_null> <S2SV_null> static unsigned <S2SV_ModStart> res ; return res <S2SV_ModEnd> ; } <S2SV_null> |
1,689 | CWE-000 static void f2fs_write_block ( struct f2fs_sb_info * sbi , nid_t ino , void * buffer , u64 count , pgoff_t offset ) { u64 start = F2FS_BYTES_TO_BLK ( offset ) ; u64 len = F2FS_BYTES_TO_BLK ( count ) ; u64 end_offset ; u64 off_in_block , len_in_block , len_already ; struct dnode_of_data dn = { 0 } ; void * data_blk ; struct node_info ni ; struct f2fs_node * inode ; <S2SV_StartBug> int ret = - 1 ; <S2SV_EndBug> get_node_info ( sbi , ino , & ni ) ; inode = calloc ( BLOCK_SZ , 1 ) ; ASSERT ( inode ) ; ret = dev_read_block ( inode , ni . blk_addr ) ; ASSERT ( ret >= 0 ) ; if ( S_ISDIR ( le16_to_cpu ( inode -> i . i_mode ) ) || S_ISLNK ( le16_to_cpu ( inode -> i . i_mode ) ) ) ASSERT ( 0 ) ; off_in_block = offset & ( ( 1 << F2FS_BLKSIZE_BITS ) - 1 ) ; <S2SV_StartBug> len_in_block = ( 1 << F2FS_BLKSIZE_BITS ) - off_in_block ; <S2SV_EndBug> len_already = 0 ; len = F2FS_BYTES_TO_BLK ( count + off_in_block + ( ( 1 << F2FS_BLKSIZE_BITS ) - 1 ) ) ; data_blk = calloc ( BLOCK_SZ , 1 ) ; ASSERT ( data_blk ) ; set_new_dnode ( & dn , inode , NULL , ino ) ; while ( len ) { if ( dn . node_blk != dn . inode_blk ) free ( dn . node_blk ) ; set_new_dnode ( & dn , inode , NULL , ino ) ; get_dnode_of_data ( sbi , & dn , start , ALLOC_NODE ) ; end_offset = ADDRS_PER_PAGE ( dn . node_blk ) ; while ( dn . ofs_in_node < end_offset && len ) { block_t blkaddr ; blkaddr = datablock_addr ( dn . node_blk , dn . ofs_in_node ) ; <S2SV_StartBug> if ( blkaddr == NULL_ADDR ) <S2SV_EndBug> new_data_block ( sbi , data_blk , & dn , CURSEG_WARM_DATA ) ; <S2SV_StartBug> ret = dev_read_block ( data_blk , dn . data_blkaddr ) ; <S2SV_EndBug> ASSERT ( ret >= 0 ) ; memcpy ( data_blk + off_in_block , buffer , len_in_block ) ; <S2SV_StartBug> ret = dev_write_block ( data_blk , dn . data_blkaddr ) ; <S2SV_EndBug> ASSERT ( ret >= 0 ) ; off_in_block = 0 ; len_already += len_in_block ; if ( ( count - len_already ) > ( 1 << F2FS_BLKSIZE_BITS ) ) len_in_block = 1 << F2FS_BLKSIZE_BITS ; else len_in_block = count - len_already ; len -- ; start ++ ; dn . ofs_in_node ++ ; } if ( dn . ndirty ) { ret = dev_write_block ( dn . node_blk , dn . node_blkaddr ) ; ASSERT ( ret >= 0 ) ; } } if ( le64_to_cpu ( inode -> i . i_size ) < offset + count ) { inode -> i . i_size = cpu_to_le64 ( offset + count ) ; <S2SV_StartBug> dn . idirty = 1 ; <S2SV_EndBug> } <S2SV_StartBug> if ( dn . idirty ) { <S2SV_EndBug> ASSERT ( inode == dn . inode_blk ) ; <S2SV_StartBug> ret = dev_write_block ( inode , ni . blk_addr ) ; <S2SV_EndBug> ASSERT ( ret >= 0 ) ; } if ( dn . node_blk && dn . node_blk != dn . inode_blk ) free ( dn . node_blk ) ; free ( data_blk ) ; free ( inode ) ; } | <S2SV_ModStart> inode ; int idirty = 0 ; int <S2SV_ModStart> ) - off_in_block ; if ( len_in_block > count ) len_in_block = count <S2SV_ModStart> == NULL_ADDR ) { <S2SV_ModStart> CURSEG_WARM_DATA ) ; blkaddr = dn . data_blkaddr ; idirty |= dn . idirty ; } <S2SV_ModStart> ( data_blk , blkaddr <S2SV_ModEnd> ) ; ASSERT <S2SV_ModStart> ( data_blk , blkaddr <S2SV_ModEnd> ) ; ASSERT <S2SV_ModStart> count ) ; <S2SV_ModEnd> idirty = 1 <S2SV_ModStart> } if ( <S2SV_ModEnd> idirty ) { <S2SV_ModStart> inode_blk ) ; write_inode ( <S2SV_ModEnd> ni . blk_addr <S2SV_ModStart> ni . blk_addr , inode <S2SV_ModEnd> ) ; } |
1,690 | CWE-000 int acqQueue ( const char * buf , int length ) { <S2SV_StartBug> # if 0 <S2SV_EndBug> ESP_LOGI ( TAG , "in<S2SV_blank>acqQueue<S2SV_blank><S2SV_blank><S2SV_blank><S2SV_blank>buf:%s,<S2SV_blank>length:%d" , buf , length ) ; for ( int i = 0 ; i < length ; i ++ ) { acqwrite_buffer [ ( acqwrite_index_in + i ) % ACQWRITE_BUFFER_LEN ] = buf [ i ] ; } if ( xSemaphoreTake ( acq_file_mutex , ( TickType_t ) 200 ) == pdTRUE ) { BsetExpander ( 0 , 1 ) ; acqwrite_index_in = ( acqwrite_index_in + length ) % ACQWRITE_BUFFER_LEN ; ESP_LOGI ( TAG , "after<S2SV_blank>write<S2SV_blank>acqwrite_buffer:%s,<S2SV_blank>index_in1:%d<S2SV_blank>length:%d" , acqwrite_buffer , acqwrite_index_in , length ) ; } else { ESP_LOGE ( TAG , "Mutex<S2SV_blank>lock<S2SV_blank>timed<S2SV_blank>out<S2SV_blank>in<S2SV_blank>acqWrite()" ) ; return false ; } BsetExpander ( 0 , 0 ) ; <S2SV_StartBug> ESP_LOGE ( TAG , "gave<S2SV_blank>acq_file_mutex<S2SV_blank>1" ) ; <S2SV_EndBug> # endif return true ; } | <S2SV_ModStart> { # if 1 <S2SV_ModEnd> ESP_LOGI ( TAG <S2SV_ModStart> 0 ) ; xSemaphoreGive ( acq_file_mutex ) ; ESP_LOGI <S2SV_ModEnd> ( TAG , |
1,691 | CWE-000 static int netlink_release ( struct socket * sock ) { struct sock * sk = sock -> sk ; struct netlink_sock * nlk ; if ( ! sk ) return 0 ; netlink_remove ( sk ) ; sock_orphan ( sk ) ; nlk = nlk_sk ( sk ) ; sock -> sk = NULL ; wake_up_interruptible_all ( & nlk -> wait ) ; skb_queue_purge ( & sk -> sk_write_queue ) ; if ( nlk -> pid ) { struct netlink_notify n = { . net = sock_net ( sk ) , . protocol = sk -> sk_protocol , . pid = nlk -> pid , } ; atomic_notifier_call_chain ( & netlink_chain , NETLINK_URELEASE , & n ) ; } module_put ( nlk -> module ) ; netlink_table_grab ( ) ; if ( netlink_is_kernel ( sk ) ) { BUG_ON ( nl_table [ sk -> sk_protocol ] . registered == 0 ) ; if ( -- nl_table [ sk -> sk_protocol ] . registered == 0 ) { <S2SV_StartBug> kfree ( nl_table [ sk -> sk_protocol ] . listeners ) ; <S2SV_EndBug> nl_table [ sk -> sk_protocol ] . module = NULL ; nl_table [ sk -> sk_protocol ] . registered = 0 ; } } else if ( nlk -> subscriptions ) netlink_update_listeners ( sk ) ; netlink_table_ungrab ( ) ; kfree ( nlk -> groups ) ; nlk -> groups = NULL ; local_bh_disable ( ) ; sock_prot_inuse_add ( sock_net ( sk ) , & netlink_proto , - 1 ) ; local_bh_enable ( ) ; sock_put ( sk ) ; return 0 ; } | <S2SV_ModStart> 0 ) { struct listeners * old ; old = nl_deref_protected ( nl_table [ sk -> sk_protocol ] . listeners ) ; RCU_INIT_POINTER ( nl_table [ sk -> sk_protocol ] . listeners , NULL ) ; kfree_rcu ( old , rcu <S2SV_ModEnd> ) ; nl_table |
1,692 | CWE-000 static gboolean lua_tcp_process_read_handler ( struct lua_tcp_cbdata * cbd , struct lua_tcp_read_handler * rh , gboolean eof ) { guint slen ; goffset pos ; if ( rh -> stop_pattern ) { slen = rh -> plen ; if ( cbd -> in -> len >= slen ) { if ( ( pos = rspamd_substring_search ( cbd -> in -> data , cbd -> in -> len , rh -> stop_pattern , slen ) ) != - 1 ) { msg_debug_tcp ( "found<S2SV_blank>TCP<S2SV_blank>stop<S2SV_blank>pattern" ) ; lua_tcp_push_data ( cbd , cbd -> in -> data , pos ) ; if ( ! IS_SYNC ( cbd ) ) { lua_tcp_shift_handler ( cbd ) ; } if ( pos + slen < cbd -> in -> len ) { memmove ( cbd -> in -> data , cbd -> in -> data + pos + slen , cbd -> in -> len - ( pos + slen ) ) ; cbd -> in -> len = cbd -> in -> len - ( pos + slen ) ; } else { cbd -> in -> len = 0 ; } return TRUE ; } else { msg_debug_tcp ( "NOT<S2SV_blank>found<S2SV_blank>TCP<S2SV_blank>stop<S2SV_blank>pattern" ) ; <S2SV_StartBug> lua_tcp_plan_read ( cbd ) ; <S2SV_EndBug> } } } else { msg_debug_tcp ( "read<S2SV_blank>TCP<S2SV_blank>partial<S2SV_blank>data" ) ; slen = cbd -> in -> len ; cbd -> in -> len = 0 ; lua_tcp_push_data ( cbd , cbd -> in -> data , slen ) ; if ( ! IS_SYNC ( cbd ) ) { lua_tcp_shift_handler ( cbd ) ; } return TRUE ; } return FALSE ; } | <S2SV_ModStart> "NOT<S2SV_blank>found<S2SV_blank>TCP<S2SV_blank>stop<S2SV_blank>pattern" ) ; if ( ! cbd -> eof ) { <S2SV_ModStart> cbd ) ; } else { lua_tcp_push_error ( cbd , TRUE , "IO<S2SV_blank>read<S2SV_blank>error:<S2SV_blank>connection<S2SV_blank>terminated" ) ; } |
1,693 | CWE-000 static void sdma_load_firmware ( const struct firmware * fw , void * context ) { struct sdma_engine * sdma = context ; const struct sdma_firmware_header * header ; const struct sdma_script_start_addrs * addr ; unsigned short * ram_code ; <S2SV_StartBug> if ( ! fw ) { <S2SV_EndBug> dev_err ( sdma -> dev , "firmware<S2SV_blank>not<S2SV_blank>found\\n" ) ; return ; } if ( fw -> size < sizeof ( * header ) ) goto err_firmware ; header = ( struct sdma_firmware_header * ) fw -> data ; if ( header -> magic != SDMA_FIRMWARE_MAGIC ) goto err_firmware ; if ( header -> ram_code_start + header -> ram_code_size > fw -> size ) goto err_firmware ; switch ( header -> version_major ) { case 1 : sdma -> script_number = SDMA_SCRIPT_ADDRS_ARRAY_SIZE_V1 ; break ; case 2 : sdma -> script_number = SDMA_SCRIPT_ADDRS_ARRAY_SIZE_V2 ; break ; default : dev_err ( sdma -> dev , "unknown<S2SV_blank>firmware<S2SV_blank>version\\n" ) ; goto err_firmware ; } addr = ( void * ) header + header -> script_addrs_start ; ram_code = ( void * ) header + header -> ram_code_start ; clk_enable ( sdma -> clk_ipg ) ; clk_enable ( sdma -> clk_ahb ) ; sdma_load_script ( sdma , ram_code , header -> ram_code_size , addr -> ram_code_start_addr ) ; clk_disable ( sdma -> clk_ipg ) ; clk_disable ( sdma -> clk_ahb ) ; sdma_add_scripts ( sdma , addr ) ; dev_info ( sdma -> dev , "loaded<S2SV_blank>firmware<S2SV_blank>%d.%d\\n" , header -> version_major , header -> version_minor ) ; err_firmware : release_firmware ( fw ) ; } | <S2SV_ModStart> ! fw ) return ; <S2SV_ModEnd> if ( fw |
1,694 | CWE-000 bool srsMemStack_Push ( srsMEMSTACK * stack , const void * data ) { bool result = false ; void * top = NULL ; size_t count = 0 ; if ( stack == NULL ) { goto done ; } <S2SV_StartBug> if ( stack -> memory == NULL ) <S2SV_EndBug> { goto done ; } count = stack -> count ; <S2SV_StartBug> top = stack -> top ; <S2SV_EndBug> stack -> count ++ ; if ( ! srsMemStack_UpdateCapacity ( stack ) ) { srsLOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>update<S2SV_blank>size<S2SV_blank>of<S2SV_blank>srsMEMSTACK<S2SV_blank>while<S2SV_blank>Pushing<S2SV_blank>-<S2SV_blank>count<S2SV_blank>will<S2SV_blank>remain<S2SV_blank>at<S2SV_blank>%d" , count ) ; <S2SV_StartBug> goto done ; <S2SV_EndBug> } top = srsMemStack_CalculatedTop ( stack ) ; srsASSERT ( top != NULL ) ; if ( memcpy ( top , data , stack -> element_size ) != top ) { srsLOG_ERROR ( "Failed<S2SV_blank>to<S2SV_blank>copy<S2SV_blank>pushed<S2SV_blank>data<S2SV_blank>to<S2SV_blank>the<S2SV_blank>srsMEMSTACK" ) ; <S2SV_StartBug> goto done ; <S2SV_EndBug> } result = true ; revert : stack -> count = count ; srsMemStack_UpdateCapacity ( stack ) ; top = srsMemStack_CalculatedTop ( stack ) ; srsASSERT ( top != NULL ) ; done : if ( top != NULL ) { stack -> top = top ; } return result ; } | <S2SV_ModStart> } if ( data == NULL ) { goto done ; } if ( <S2SV_ModStart> -> count ; <S2SV_ModEnd> stack -> count <S2SV_ModStart> ) ; goto revert <S2SV_ModEnd> ; } top <S2SV_ModStart> ) ; goto revert <S2SV_ModEnd> ; } result |
1,695 | CWE-000 static void selection_buffer_read_cb ( GObject * object , GAsyncResult * result , gpointer user_data ) { SelectionBuffer * buffer = user_data ; gboolean finished = TRUE ; GError * error = NULL ; GBytes * bytes ; bytes = g_input_stream_read_bytes_finish ( buffer -> stream , result , & error ) ; if ( bytes ) { <S2SV_StartBug> finished = g_bytes_get_size ( bytes ) < get_buffer_size ( ) ; <S2SV_EndBug> selection_buffer_append_data ( buffer , g_bytes_get_data ( bytes , NULL ) , g_bytes_get_size ( bytes ) ) ; g_bytes_unref ( bytes ) ; } if ( ! finished ) selection_buffer_read ( buffer ) ; else { if ( error ) { g_warning ( G_STRLOC ":<S2SV_blank>error<S2SV_blank>reading<S2SV_blank>selection<S2SV_blank>buffer:<S2SV_blank>%s" , error -> message ) ; g_error_free ( error ) ; } else selection_buffer_notify ( buffer ) ; g_input_stream_close ( buffer -> stream , NULL , NULL ) ; g_clear_object ( & buffer -> stream ) ; g_clear_object ( & buffer -> cancellable ) ; } selection_buffer_unref ( buffer ) ; } | <S2SV_ModStart> ( bytes ) == 0 <S2SV_ModEnd> ; selection_buffer_append_data ( |
1,696 | CWE-000 static void CleanupTransaction ( void ) { TransactionState s = CurrentTransactionState ; if ( s -> state != TRANS_ABORT ) elog ( FATAL , "CleanupTransaction:<S2SV_blank>unexpected<S2SV_blank>state<S2SV_blank>%s" , TransStateAsString ( s -> state ) ) ; AtCleanup_Portals ( ) ; CurrentResourceOwner = NULL ; if ( TopTransactionResourceOwner ) ResourceOwnerDelete ( TopTransactionResourceOwner ) ; s -> curTransactionOwner = NULL ; CurTransactionResourceOwner = NULL ; TopTransactionResourceOwner = NULL ; AtCleanup_Memory ( ) ; <S2SV_StartBug> s -> distribXid = InvalidDistributedTransactionId ; <S2SV_EndBug> s -> transactionId = InvalidTransactionId ; s -> subTransactionId = InvalidSubTransactionId ; s -> nestingLevel = 0 ; s -> gucNestLevel = 0 ; s -> childXids = NULL ; s -> nChildXids = 0 ; s -> maxChildXids = 0 ; s -> executorSaysXactDoesWrites = false ; s -> state = TRANS_DEFAULT ; finishDistributedTransactionContext ( "CleanupTransaction" , true ) ; <S2SV_StartBug> if ( ShouldAssignResGroupOnMaster ( ) ) <S2SV_EndBug> UnassignResGroupOnMaster ( ) ; } | <S2SV_ModStart> ( ) ; AtEOXact_ResGroup ( false ) ; <S2SV_ModStart> true ) ; <S2SV_ModEnd> } <S2SV_null> <S2SV_null> |
1,697 | CWE-000 void ioreg_write ( byte r , byte b ) { if ( ! hw . cgb ) { switch ( r ) { case RI_VBK : case RI_BCPS : case RI_OCPS : case RI_BCPD : case RI_OCPD : case RI_SVBK : case RI_KEY1 : case RI_HDMA1 : case RI_HDMA2 : case RI_HDMA3 : case RI_HDMA4 : case RI_HDMA5 : return ; } } switch ( r ) { case RI_TIMA : case RI_TMA : case RI_TAC : case RI_SCY : case RI_SCX : case RI_WY : case RI_WX : REG ( r ) = b ; break ; case RI_BGP : if ( R_BGP == b ) break ; pal_write_dmg ( 0 , 0 , b ) ; pal_write_dmg ( 8 , 1 , b ) ; R_BGP = b ; break ; case RI_OBP0 : if ( R_OBP0 == b ) break ; pal_write_dmg ( 64 , 2 , b ) ; R_OBP0 = b ; break ; case RI_OBP1 : if ( R_OBP1 == b ) break ; pal_write_dmg ( 72 , 3 , b ) ; R_OBP1 = b ; break ; case RI_IF : case RI_IE : REG ( r ) = b & 0x1F ; break ; case RI_P1 : REG ( r ) = b ; pad_refresh ( ) ; break ; case RI_SC : if ( ( b & 0x81 ) == 0x81 ) { R_SB = 0xff ; hw_interrupt ( IF_SERIAL , IF_SERIAL ) ; hw_interrupt ( 0 , IF_SERIAL ) ; } <S2SV_StartBug> R_SC = b ; <S2SV_EndBug> break ; case RI_SB : REG ( r ) = b ; break ; case RI_DIV : REG ( r ) = 0 ; break ; case RI_LCDC : lcdc_change ( b ) ; break ; case RI_STAT : stat_write ( b ) ; break ; case RI_LYC : REG ( r ) = b ; stat_trigger ( ) ; break ; case RI_VBK : REG ( r ) = b | 0xFE ; mem_updatemap ( ) ; break ; case RI_BCPS : R_BCPS = b & 0xBF ; R_BCPD = lcd . pal [ b & 0x3F ] ; break ; case RI_OCPS : R_OCPS = b & 0xBF ; R_OCPD = lcd . pal [ 64 + ( b & 0x3F ) ] ; break ; case RI_BCPD : R_BCPD = b ; pal_write ( R_BCPS & 0x3F , b ) ; if ( R_BCPS & 0x80 ) R_BCPS = ( R_BCPS + 1 ) & 0xBF ; break ; case RI_OCPD : R_OCPD = b ; pal_write ( 64 + ( R_OCPS & 0x3F ) , b ) ; if ( R_OCPS & 0x80 ) R_OCPS = ( R_OCPS + 1 ) & 0xBF ; break ; case RI_SVBK : REG ( r ) = b & 0x07 ; mem_updatemap ( ) ; break ; case RI_DMA : hw_dma ( b ) ; break ; case RI_KEY1 : REG ( r ) = ( REG ( r ) & 0x80 ) | ( b & 0x01 ) ; break ; case RI_HDMA1 : REG ( r ) = b ; break ; case RI_HDMA2 : REG ( r ) = b & 0xF0 ; break ; case RI_HDMA3 : REG ( r ) = b & 0x1F ; break ; case RI_HDMA4 : REG ( r ) = b & 0xF0 ; break ; case RI_HDMA5 : hw_hdma_cmd ( b ) ; break ; } switch ( r ) { case RI_BGP : case RI_OBP0 : case RI_OBP1 : case RI_HDMA1 : case RI_HDMA2 : case RI_HDMA3 : case RI_HDMA4 : case RI_HDMA5 : break ; } } | <S2SV_ModStart> ; } R_SC <S2SV_ModEnd> = b ; |
1,698 | CWE-000 const char * hsm_client_http_edge_get_trusted_certificates ( HSM_CLIENT_HANDLE handle ) { const char * trusted_certificates ; BUFFER_HANDLE http_response = NULL ; STRING_HANDLE uri_path = NULL ; if ( handle == NULL ) { LogError ( "Invalid<S2SV_blank>handle<S2SV_blank>value<S2SV_blank>specified<S2SV_blank>handle:<S2SV_blank>%p" , handle ) ; trusted_certificates = NULL ; } else { HSM_CLIENT_HTTP_EDGE * hsm_client_http_edge = ( HSM_CLIENT_HTTP_EDGE * ) handle ; if ( ( uri_path = STRING_construct_sprintf ( "/trust-bundle?api-version=%s" , HSM_HTTP_EDGE_VERSION ) ) == NULL ) { LogError ( "STRING_construct_sprintf<S2SV_blank>failed" ) ; trusted_certificates = NULL ; } else if ( ( http_response = send_http_workload_request ( hsm_client_http_edge , uri_path , NULL ) ) == NULL ) { LogError ( "send_http_workload_request<S2SV_blank>failed" ) ; trusted_certificates = NULL ; } <S2SV_StartBug> else if ( ( trusted_certificates = parse_json_certificate_response ( http_response ) ) != NULL ) <S2SV_EndBug> { LogError ( "parse_json_certificate_response<S2SV_blank>failed" ) ; trusted_certificates = NULL ; } } STRING_delete ( uri_path ) ; BUFFER_delete ( http_response ) ; return trusted_certificates ; } | <S2SV_ModStart> http_response ) ) = = <S2SV_ModEnd> NULL ) { |
1,699 | CWE-000 void setDungeon ( Dungeon * d ) { printf ( "Initilizing<S2SV_blank>Dungeon...\\n" ) ; int row , col ; char topBorder = '-' ; char sideBorder = '|' ; char cornerBorder = '+' ; for ( row = 0 ; row < DUNGEON_HEIGHT ; row ++ ) { for ( col = 0 ; col < DUNGEON_WIDTH ; col ++ ) { if ( row == 0 || row == 20 ) { d -> map [ row ] [ col ] = topBorder ; d -> hardnessMap [ row ] [ col ] = MAX_HARDNESS ; } else if ( col == 0 || col == 79 ) { d -> map [ row ] [ col ] = sideBorder ; d -> hardnessMap [ row ] [ col ] = MAX_HARDNESS ; } else { d -> map [ row ] [ col ] = rockCell ; <S2SV_StartBug> d -> hardnessMap [ row ] [ col ] = generateRange ( MIN_HARDNESS , MAX_HARDNESS ) ; <S2SV_EndBug> } if ( ( row == 0 && col == 0 ) || ( row == 0 && col == 79 ) || ( row == 20 && col == 0 ) || ( row == 20 && col == 79 ) ) { d -> map [ row ] [ col ] = cornerBorder ; d -> hardnessMap [ row ] [ col ] = MAX_HARDNESS ; } } } } | <S2SV_ModStart> generateRange ( MIN_HARDNESS + 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.