# -------------------------------------------------------------------------
import ntpath
import os
import zlib
from abc import ABCMeta
import shared
from codechecker_lib import client
from codechecker_lib import logger
from codechecker_lib import plist_parser
from codechecker_lib import suppress_handler
from codechecker_lib.analyzers.result_handler_base import ResultHandler
LOG = logger.get_new_logger('PLIST TO DB')
class PlistToDB(ResultHandler):
"""
Result handler for processing a plist file with the
analysis results and stores them to the database.
"""
__metaclass__ = ABCMeta
def __init__(self, buildaction, workspace, run_id):
super(PlistToDB, self).__init__(buildaction, workspace)
self.__run_id = run_id
def __store_bugs(self, files, bugs, connection, analisys_id):
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import os
import sys
import json
from codechecker_lib import context_base
from codechecker_lib import logger
from codechecker_lib import db_version
from codechecker_lib.analyzers import analyzer_types
LOG = logger.get_new_logger('CONTEXT')
# -----------------------------------------------------------------------------
class Context(context_base.ContextBase):
''' generic package specific context'''
__instance = None
logger_bin = None
logger_file = None
logger_compilers = None
ld_preload = None
__package_version = None
__package_root = None
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
from codechecker_lib import logger
from codechecker_lib import tidy_output_converter
from codechecker_lib.analyzers.result_handler_plist_to_db import PlistToDB
from codechecker_lib.analyzers.result_handler_plist_to_stdout import \
PlistToStdout
LOG = logger.get_new_logger('CLANG_TIDY_RESULT_HANDLER')
def generate_plist_from_tidy_result(output_file, tidy_stdout):
"""
Generate a plist file from the clang tidy analyzer results.
"""
parser = tidy_output_converter.OutputParser()
messages = parser.parse_messages(tidy_stdout)
plist_converter = tidy_output_converter.PListConverter()
plist_converter.add_messages(messages)
plist_converter.write_to_file(output_file)
class ClangTidyPlistToDB(PlistToDB):
def __init__(self, context, analyzer_env):
self._context = context
self._analyzer_env = analyzer_env
self._logger = logger.get_new_logger('ANALYZER_CRASH_HANDLER')
"root", "myname"
],
"groups": [
"adm", "cc-users"
]
}
"""
import pam
import grp
import pwd
from codechecker_lib import logger
LOG = logger.get_new_logger("PAM")
def auth_user(pam_config, username, password):
"""
Authenticate user with PAM.
"""
LOG.debug('Authenticating user with PAM.')
auth = pam.pam()
if auth.authenticate(username, password):
allowed_users = pam_config.get("users") \
or []
allowed_group = pam_config.get("groups")\
or []
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
"""
build and log related stuff
"""
import os
import pickle
import subprocess
import sys
from codechecker_lib import logger
from codechecker_lib import analyzer_env
LOG = logger.get_new_logger('BUILD MANAGER')
def execute_buildcmd(command, silent=False, env=None, cwd=None):
"""
Execute the the build command and continously write
the output from the process to the standard output.
"""
proc = subprocess.Popen(command,
bufsize=-1,
env=env,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=cwd,
shell=True)
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
''''''
import os
import sys
import signal
import subprocess
import ntpath
from codechecker_lib import client
from codechecker_lib import logger
from codechecker_lib import analyzer_env
LOG = logger.get_new_logger('ANALYZER')
# -----------------------------------------------------------------------------
class StaticAnalyzer(object):
''''''
def __init__(self, context):
self._context = context
# Load all plugin from plugin directory
plugin_dir = os.path.join(context.package_root, context.checker_plugin)
self._plugins = [os.path.join(plugin_dir, f)
for f in os.listdir(plugin_dir)
if os.path.isfile(os.path.join(plugin_dir, f))]
self._config = None
self._skip = []
# -------------------------------------------------------------------------
import os
import sys
import sqlalchemy
from sqlalchemy.sql import and_
from codechecker_lib import analyzer_crash_handler
from codechecker_lib import analyzer_env
from codechecker_lib import database_handler
from codechecker_lib import logger
from db_model.orm_model import BuildAction
from db_model.orm_model import Run
LOG = logger.get_new_logger('DEBUG_REPORTER')
# -----------------------------------------------------------------------------
def get_dump_file_name(run_id, action_id):
return 'action_' + str(run_id) + '_' + str(action_id) + '_dump.log'
# -----------------------------------------------------------------------------
def debug(context, connection_string, force):
try:
engine = database_handler.SQLServer.create_engine(connection_string)
session = sqlalchemy.orm.scoped_session(
sqlalchemy.orm.sessionmaker(bind=engine))
# Get latest run id.
'''
import zlib
import os
import datetime
from collections import defaultdict
import ntpath
import codecs
import shared
from Authentication import constants
from Authentication.ttypes import *
from codechecker_lib import logger
from codechecker_lib import session_manager
LOG = logger.get_new_logger('AUTH HANDLER')
# -----------------------------------------------------------------------
def timefunc(function):
'''
timer function
'''
func_name = function.__name__
def debug_wrapper(*args, **kwargs):
'''
wrapper for debug log
'''
before = datetime.now()
# -------------------------------------------------------------------------
import ntpath
import os
import zlib
from abc import ABCMeta
import shared
from codechecker_lib import client
from codechecker_lib import logger
from codechecker_lib import plist_parser
from codechecker_lib import suppress_handler
from codechecker_lib.analyzers.result_handler_base import ResultHandler
LOG = logger.get_new_logger('PLIST TO DB')
class PlistToDB(ResultHandler):
"""
Result handler for processing a plist file with the
analysis results and stores them to the database.
"""
__metaclass__ = ABCMeta
def __init__(self, buildaction, workspace, run_id):
super(PlistToDB, self).__init__(buildaction, workspace)
self.__run_id = run_id
def __store_bugs(self, files, bugs, connection, analisys_id):
import copy
import json
import os
import shlex
import subprocess
import sys
import time
from codechecker_lib import analysis_manager
from codechecker_lib import client
from codechecker_lib import logger
from codechecker_lib import skiplist_handler
from codechecker_lib import analyzer_env
from codechecker_lib.analyzers import analyzer_types
LOG = logger.get_new_logger('ANALYZER')
def prepare_actions(actions, enabled_analyzers):
"""
Set the analyzer type for each buildaction.
Multiple actions if multiple source analyzers are set.
"""
res = []
for ea in enabled_analyzers:
for action in actions:
new_action = copy.deepcopy(action)
new_action.analyzer_type = ea
res.append(new_action)
return res
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import os
import traceback
from codechecker_lib import build_action
from codechecker_lib import logger
from codechecker_lib import option_parser
LOG = logger.get_new_logger('LOG PARSER')
# -----------------------------------------------------------------------------
def parse_compile_commands_json(logfile):
import json
actions = []
filtered_build_actions = {}
logfile.seek(0)
data = json.load(logfile)
counter = 0
for entry in data:
sourcefile = entry['file']
lang = option_parser.get_language(sourcefile[sourcefile.rfind('.'):])
from codechecker_lib import generic_package_context
from codechecker_lib import analyzer
from codechecker_lib import log_parser
from codechecker_lib import util
from codechecker_lib import debug_reporter
from codechecker_lib import logger
from codechecker_lib import analyzer_env
from codechecker_lib import host_check
from codechecker_lib import generic_package_suppress_handler
from codechecker_lib.database_handler import SQLServer
from codechecker_lib import build_manager
from codechecker_lib.analyzers import analyzer_types
LOG = logger.get_new_logger('ARG_HANDLER')
def handle_list_checkers(args):
"""
list the supported checkers by the analyzers
list the default enabled and disabled checkers
in the config
"""
context = generic_package_context.get_context()
enabled_analyzers = args.analyzers
analyzer_environment = analyzer_env.get_check_env(
context.path_env_extra, context.ld_lib_path_extra)
if not enabled_analyzers:
# noting set list checkers for all supported analyzers
# This is the new format.
123324353456463442341242342343#1 || filename || bug hash comment
After removing the hash_value_type the generated format is:
123324353456463442341242342343 || filename || bug hash comment
For backward compatibility the hash_value_type is an optional filed.
"""
import codecs
import os
import re
from codechecker_lib import logger
LOG = logger.get_new_logger('SUPPRESS_FILE_HANDLER')
COMMENT_SEPARATOR = '||'
HASH_TYPE_SEPARATOR = '#'
def get_suppress_data(suppress_file):
"""
Process a file object for suppress information.
"""
old_format_pattern = r"^(?P<bug_hash>[\d\w]{32})(\#(?P<bug_hash_type>\d))?\s*\|\|\s*(?P<comment>[^\|]*)$"
old_format = re.compile(old_format_pattern, re.UNICODE)
new_format_pattern = r"^(?P<bug_hash>[\d\w]{32})(\#(?P<bug_hash_type>\d))?\s*\|\|\s*(?P<file_name>[^\\\|]+)\s*\|\|\s*(?P<comment>[^\|]*)$"
new_format = re.compile(new_format_pattern, re.UNICODE)
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import os
import uuid
import ntpath
from abc import ABCMeta, abstractmethod
from codechecker_lib import logger
LOG = logger.get_new_logger('RESULT_HANDLER_BASE')
class ResultHandler(object):
"""
handle and store the results at runtime for the analyzer
stdout, stderr, temporarly generated files
do result postprocessing if required
For each buildaction there is one result handler
the result handler can handle multiple results if there
are more than one analyzed source file in one buildaction
For each build action
- postprocess_result and handle_results can be called multiple times
for the source files in one buildaction they will be analyzed separately
with the same build options
from codechecker_lib import pgpass
from codechecker_lib import host_check
from db_model.orm_model import CC_META
from db_model.orm_model import DBVersion
from db_model.orm_model import CreateSession
import sqlalchemy
from sqlalchemy.engine.url import URL, make_url
from sqlalchemy.sql.elements import quoted_name
from sqlalchemy.engine import Engine
from sqlalchemy import event
from alembic import command, config
LOG = logger.get_new_logger('DB_HANDLER')
class SQLServer(object):
'''
Abstract base class for database server handling. An SQLServer instance is
responsible for the initialization, starting, and stopping the database
server, and also for connection string management.
SQLServer implementations are created via SQLServer.from_cmdline_args().
How to add a new database server implementation:
1, Derive from SQLServer and implement the abstract methods
2, Add/modify some command line options in CodeChecker.py
3, Modify SQLServer.from_cmdline_args() in order to create an
instance of the new server type if needed
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import os
import sys
import sqlalchemy
from db_model.orm_model import *
from codechecker_lib import analyzer_env
from codechecker_lib import logger
from codechecker_lib import analyzer_crash_handler
LOG = logger.get_new_logger('DEBUG_REPORTER')
# -----------------------------------------------------------------------------
def get_dump_file_name(run_id, action_id):
return 'action_' + str(run_id) + '_' + str(action_id) + '_dump.log'
# -----------------------------------------------------------------------------
def debug(context, dbusername, dbhost, dbport, dbname, force):
try:
connection_string = 'postgres://' + dbusername + '@' + dbhost + ':' + \
str(dbport) + '/' + dbname
engine = sqlalchemy.create_engine(connection_string)
print(connection_string)
session = sqlalchemy.orm.scoped_session(
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
"""
Handler for suppressing a bug.
"""
from codechecker_lib import logger
from codechecker_lib import suppress_file_handler
from codechecker_lib import suppress_handler
# Warning! this logger should only be used in this module.
LOG = logger.get_new_logger('SUPPRESS')
class GenericSuppressHandler(suppress_handler.SuppressHandler):
def store_suppress_bug_id(self, bug_id, file_name, comment):
if self.suppress_file is None:
return False
ret = suppress_file_handler.write_to_suppress_file(
self.suppress_file, bug_id, file_name, comment)
return ret
def remove_suppress_bug_id(self, bug_id, file_name):
if self.suppress_file is None:
return False
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
'''
handler for suppressing a bug
'''
from codechecker_lib import logger
from codechecker_lib import suppress_handler
from codechecker_lib import suppress_file_handler
# Warning! this logger should only be used in this module
LOG = logger.get_new_logger('SUPPRESS')
class GenericSuppressHandler(suppress_handler.SuppressHandler):
def store_suppress_bug_id(self, source_file_path, bug_id, hash_type, comment):
if self.suppress_file is None:
return True
ret = suppress_file_handler.write_to_suppress_file(self.suppress_file,
bug_id, hash_type,
comment)
return ret
def remove_suppress_bug_id(self, source_file_path, bug_id, hash_type):
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import re
from codechecker_lib import logger
from codechecker_lib.analyzers import config_handler
LOG = logger.get_new_logger("CLANGSA CONFIG HANDLER")
class ClangSAConfigHandler(config_handler.AnalyzerConfigHandler):
"""
Configuration handler for the clang static analyzer.
"""
def __init__(self):
super(ClangSAConfigHandler, self).__init__()
self.__checker_configs = []
def add_checker_config(self, config):
"""
Add a (checker_name, key, value) tuple to the list.
"""
self.__checker_configs.append(config)
def get_checker_configs(self):
"""
from alembic.util import CommandError
from alembic import command, config
from sqlalchemy import event
from sqlalchemy.engine import Engine
from sqlalchemy.engine.url import URL, make_url
from sqlalchemy.sql.elements import quoted_name
from codechecker_lib import host_check
from codechecker_lib import logger
from codechecker_lib import pgpass
from codechecker_lib import util
from db_model.orm_model import CC_META
from db_model.orm_model import CreateSession
from db_model.orm_model import DBVersion
LOG = logger.get_new_logger('DB_HANDLER')
class SQLServer(object):
"""
Abstract base class for database server handling. An SQLServer instance is
responsible for the initialization, starting, and stopping the database
server, and also for connection string management.
SQLServer implementations are created via SQLServer.from_cmdline_args().
How to add a new database server implementation:
1, Derive from SQLServer and implement the abstract methods
2, Add/modify some command line options in CodeChecker.py
3, Modify SQLServer.from_cmdline_args() in order to create an
instance of the new server type if needed
def __init__(self, context, analyzer_env):
self._context = context
self._analyzer_env = analyzer_env
self._logger = logger.get_new_logger('ANALYZER_CRASH_HANDLER')
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
""""""
import os
from codechecker_lib import logger
LOG = logger.get_new_logger('ENV')
# ------------------------------------------------------------------------------
def get_log_env(logfile, context, original_env):
"""
Environment for logging. With the ld logger.
Keep the original environment unmodified as possible.
Only environment variables required for logging are changed.
"""
new_env = original_env
new_env[context.env_var_cc_logger_bin] = context.path_logger_bin
new_env['LD_PRELOAD'] = context.logger_lib_name
try:
original_ld_library_path = new_env['LD_LIBRARY_PATH']
new_env['LD_LIBRARY_PATH'] = context.path_logger_lib + ':' + \
original_ld_library_path
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import re
import json
import shlex
import argparse
from codechecker_lib.analyzers import config_handler
from codechecker_lib import logger
LOG = logger.get_new_logger('CLANG TIDY CONFIG')
class ClangTidyConfigHandler(config_handler.AnalyzerConfigHandler):
'''
Configuration handler for Clang-tidy analyzer
'''
def __init__(self):
super(ClangTidyConfigHandler, self).__init__()
def get_checker_configs(self):
"""
process the raw extra analyzer arguments and get the configuration
data ('-config=' argument for Clang tidy) for the checkers
Clang tidy accepts YAML or JSON formatted config, right now
from DBThriftAPI import CheckerReport
from DBThriftAPI.ttypes import *
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from codechecker_lib import logger
from codechecker_lib import plist_parser
from codechecker_lib import database_handler
from codechecker_lib import util
from codechecker_lib import suppress_file_handler
from codechecker_lib import suppress_handler
LOG = logger.get_new_logger('CLIENT')
# -----------------------------------------------------------------------------
def send_plist_content(connection, plist_file, build_action_id, run_id,
severity_map, should_skip):
try:
files, bugs = plist_parser.parse_plist(plist_file)
except Exception:
LOG.info('The generated plist is not valid, so parsing failed.')
return
file_ids = {}
# Send content of file to the server if needed
for file_name in files:
file_descriptor = connection.need_file_content(file_name)
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import re
import json
import shlex
import argparse
from codechecker_lib.analyzers import config_handler
from codechecker_lib import logger
LOG = logger.get_new_logger('CLANG TIDY CONFIG')
class ClangTidyConfigHandler(config_handler.AnalyzerConfigHandler):
'''
Configuration handler for Clang-tidy analyzer
'''
def __init__(self):
super(ClangTidyConfigHandler, self).__init__()
def get_checker_configs(self):
"""
process the raw extra analyzer arguments and get the configuration
data ('-config=' argument for Clang tidy) for the checkers
Clang tidy accepts YAML or JSON formatted config, right now
from codechecker_lib import logger
unsupported_methods = []
try:
from codechecker_lib.auth import cc_ldap
except ImportError:
unsupported_methods.append("ldap")
try:
from codechecker_lib.auth import cc_pam
except ImportError:
unsupported_methods.append("pam")
LOG = logger.get_new_logger("SESSION MANAGER")
SESSION_COOKIE_NAME = "__ccPrivilegedAccessToken"
session_lifetimes = {}
# ------------------------------
# ----------- SERVER -----------
class _Session():
"""A session for an authenticated, privileged client connection."""
# Create an initial salt from system environment for use with the session
# permanent persistency routine.
__initial_salt = hashlib.sha256(SESSION_COOKIE_NAME + "__" +
str(time.time()) + "__" +
os.urandom(16)).hexdigest()
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.transport import TZlibTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
from thrift.server import TProcessPoolServer
from codechecker_gen.DBThriftAPI import CheckerReport
from codechecker_gen.DBThriftAPI.ttypes import *
from db_model.orm_model import *
from codechecker_lib import logger
from codechecker_lib import decorators
LOG = logger.get_new_logger("CC SERVER")
# -----------------------------------------------------------------------
if os.environ.get("CODECHECKER_ALCHEMY_LOG") is not None:
import logging
logging.basicConfig()
logging.getLogger("sqlalchemy.engine").setLevel(logging.DEBUG)
logging.getLogger("sqlalchemy.orm").setLevel(logging.DEBUG)
# -----------------------------------------------------------------------
class CheckerReportHandler(object):
"""
Class to handle requests from the codechecker script to store run
information to the database
# this is the new format
123324353456463442341242342343#1 || filename || bug hash comment
after removing the hash_value_type the generated format is:
123324353456463442341242342343 || filename || bug hash comment
for backward compatibility the hash_value_type is an optional filed
'''
import re
import os
import string
import codecs
from codechecker_lib import logger
LOG = logger.get_new_logger('SUPPRESS_FILE_HANDLER')
COMMENT_SEPARATOR = '||'
HASH_TYPE_SEPARATOR = '#'
def get_suppress_data(suppress_file):
"""
processs a file object for suppress information
"""
old_format_pattern = r"^(?P<bug_hash>[\d\w]{32})(\#(?P<bug_hash_type>\d))?\s*\|\|\s*(?P<comment>[^\|]*)$"
old_format = re.compile(old_format_pattern, re.UNICODE)
new_format_pattern = r"^(?P<bug_hash>[\d\w]{32})(\#(?P<bug_hash_type>\d))?\s*\|\|\s*(?P<file_name>[^\\\|]+)\s*\|\|\s*(?P<comment>[^\|]*)$"
'''
import datetime
import os
import hashlib
import ntpath
import sys
import glob
import socket
import shutil
import subprocess
from codechecker_lib import logger
# WARNING! LOG should be only used in this module
LOG = logger.get_new_logger('UTIL')
# ---------------------------------------------------------------------
def get_free_port():
''' get a free port from the os'''
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', 0))
free_port = s.getsockname()[1]
s.close()
return free_port
# ---------------------------------------------------------------------
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import os
import traceback
from codechecker_lib import build_action
from codechecker_lib import logger
from codechecker_lib import option_parser
LOG = logger.get_new_logger('LOG PARSER')
# -----------------------------------------------------------------------------
def parse_compile_commands_json(logfile):
import json
actions = []
filtered_build_actions = {}
logfile.seek(0)
data = json.load(logfile)
counter = 0
for entry in data:
sourcefile = entry['file']
lang = option_parser.get_language(sourcefile[sourcefile.rfind('.'):])
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
'''
This module is responsible for parsing clang-tidy output and generating plist
for the plist_parser module.
'''
import re
import os
import copy
import plistlib
from codechecker_lib import logger
LOG = logger.get_new_logger('TIDY_OUTPUT_HANDLER')
class Note(object):
'''
Represents a note and also this is the base class of Message.
'''
def __init__(self, path, line, column, message):
self.path = path
self.line = line
self.column = column
self.message = message
def __eq__(self, other):
return self.path == other.path and \
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import ntpath
import os
import uuid
from abc import ABCMeta, abstractmethod
from codechecker_lib import logger
LOG = logger.get_new_logger('RESULT_HANDLER_BASE')
class ResultHandler(object):
"""
Handle and store the results at runtime for the analyzer:
stdout, stderr, temporarily generated files.
Do result postprocessing if required.
For each buildaction there is one result handler.
The result handler can handle multiple results if there
are more than one analyzed source file in one buildaction.
handle_results() handles the results of a static analysis tool processed on
a build action. Alternatively one can also handle results given by plist
files for which handle_plist() can be used.
For each build action
import zlib
import os
from collections import defaultdict
import ntpath
import codecs
import shared
from Authentication import constants
from Authentication.ttypes import *
from codechecker_lib import logger
from codechecker_lib import session_manager
from codechecker_lib.profiler import timeit
LOG = logger.get_new_logger('AUTH HANDLER')
def conv(text):
'''
Convert * to % got from clients for the database queries.
'''
if text is None:
return '%'
return text.replace('*', '%')
class ThriftAuthHandler():
'''
Handle Thrift authentication requests.
'''
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import re
import shlex
import subprocess
from codechecker_lib import logger
from codechecker_lib.analyzers import analyzer_base
LOG = logger.get_new_logger('CLANGSA')
class ClangSA(analyzer_base.SourceAnalyzer):
"""
Constructs clang static analyzer commands.
"""
def __parse_checkers(self, clangsa_output):
"""
Parse clang static analyzer checkers, store them to checkers.
"""
# Checker name and description in one line.
pattern = re.compile(
r'^\s\s(?P<checker_name>\S*)\s*(?P<description>.*)')
checker_name = None
import multiprocessing
import ntpath
import os
import re
import shutil
import signal
import sys
import traceback
from collections import defaultdict
from codechecker_lib import analyzer_env
from codechecker_lib import logger
from codechecker_lib.analyzers import analyzer_types
LOG = logger.get_new_logger('ANALYSIS MANAGER')
def worker_result_handler(results):
"""
Print the analysis summary.
"""
successful_analysis = defaultdict(int)
failed_analysis = defaultdict(int)
skipped_num = 0
for res, skipped, analyzer_type in results:
if skipped:
skipped_num += 1
else:
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import os
import sys
import json
from codechecker_lib import context_base
from codechecker_lib import logger
from codechecker_lib import db_version
LOG = logger.get_new_logger('CONTEXT')
# -----------------------------------------------------------------------------
class Context(context_base.ContextBase):
''' generic package specific context'''
__instance = None
logger_bin = None
logger_file = None
logger_compilers = None
ld_preload = None
__package_version = None
__package_root = None
def __init__(self, package_root, pckg_layout, cfg_dict):
Used to filter out or change compiler argument not supported by clang
or clang-tidy.
Keys are the option name, value is the number of options to skip.
Possible improvements:
- modular option handling system configuring possibility from config file
"""
import os
import re
import shlex
from codechecker_lib import logger
LOG = logger.get_new_logger('OPTION PARSER')
# Compiler options.
COMPILE_OPTION_MAP = {
'-idirafter': 1,
'-imacros': 1,
'-include': 1,
'-iprefix': 1,
'-isysroot': 1,
'-isystem': 1,
'-iwithprefix': 1,
'-iwithprefixbefore': 1,
'-nostdinc': 0,
'-sysroot': 1
}
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import collections
import os
from abc import ABCMeta, abstractmethod
from codechecker_lib import logger
LOG = logger.get_new_logger('CONFIG HANDLER')
class AnalyzerConfigHandler(object):
"""
Handle the checker configurations and enabled disabled checkers lists.
"""
__metaclass__ = ABCMeta
def __init__(self):
self.__analyzer_binary = None
self.__analyzer_plugins_dir = None
self.__compiler_sysroot = None
self.__compiler_resource_dirs = []
self.__sys_inc = []
self.__includes = []
self.__analyzer_extra_arguments = ''
# -------------------------------------------------------------------------
import os
import sys
import math
import ntpath
import linecache
from abc import ABCMeta
from codechecker_lib import logger
from codechecker_lib import plist_parser
from codechecker_lib.analyzers.result_handler_base import ResultHandler
LOG = logger.get_new_logger('PLIST TO STDOUT')
class PlistToStdout(ResultHandler):
"""
Result handler for processing a plist file with the
analysis results and print them to the standard output.
"""
__metaclass__ = ABCMeta
def __init__(self, buildaction, workspace):
super(PlistToStdout, self).__init__(buildaction, workspace)
self.__print_steps = False
self.__output = sys.stdout
import sys
from codechecker_lib import logger
from codechecker_lib import analyzer_env
from codechecker_lib import host_check
from codechecker_lib import client
from codechecker_lib.analyzers import analyzer_clangsa
from codechecker_lib.analyzers import config_handler_clangsa
from codechecker_lib.analyzers import result_handler_clangsa
from codechecker_lib.analyzers import analyzer_clang_tidy
from codechecker_lib.analyzers import result_handler_clang_tidy
from codechecker_lib.analyzers import config_handler_clang_tidy
LOG = logger.get_new_logger('ANALYZER TYPES')
CLANG_SA = 'clangsa'
CLANG_TIDY = 'clang-tidy'
supported_analyzers = {CLANG_SA, CLANG_TIDY}
def is_sa_checker_name(checker_name):
"""
match for Clang Static analyzer names like
unix
unix.Malloc
security.insecureAPI
security.insecureAPI.gets
from codechecker_lib import build_action
from codechecker_lib import build_manager
from codechecker_lib import client
from codechecker_lib import debug_reporter
from codechecker_lib import generic_package_context
from codechecker_lib import generic_package_suppress_handler
from codechecker_lib import host_check
from codechecker_lib import log_parser
from codechecker_lib import logger
from codechecker_lib import session_manager
from codechecker_lib import util
from codechecker_lib.analyzers import analyzer_types
from codechecker_lib.database_handler import SQLServer
from viewer_server import client_db_access_server
LOG = logger.get_new_logger('ARG_HANDLER')
def handle_list_checkers(args):
"""
List the supported checkers by the analyzers.
List the default enabled and disabled checkers in the config.
"""
context = generic_package_context.get_context()
enabled_analyzers = args.analyzers
analyzer_environment = analyzer_env.get_check_env(context.path_env_extra,
context.ld_lib_path_extra)
if not enabled_analyzers:
# Noting set list checkers for all supported analyzers.
enabled_analyzers = list(analyzer_types.supported_analyzers)
from codechecker_gen.DBThriftAPI import CheckerReport
from codechecker_gen.DBThriftAPI.ttypes import *
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
from thrift.transport import TSocket
from thrift.transport import TTransport
from codechecker_lib import database_handler
from codechecker_lib import decorators
from codechecker_lib import logger
from db_model.orm_model import *
from codechecker_lib.profiler import timeit
from codechecker_lib.profiler import profileit
LOG = logger.get_new_logger('CC SERVER')
if os.environ.get('CODECHECKER_ALCHEMY_LOG') is not None:
import logging
logging.basicConfig()
logging.getLogger('sqlalchemy.engine').setLevel(logging.DEBUG)
logging.getLogger('sqlalchemy.orm').setLevel(logging.DEBUG)
class CheckerReportHandler(object):
"""
Class to handle requests from the CodeChecker script to store run
information to the database.
"""
def __sequence_deleter(self, table, first_id):
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
""""""
# FIXME: This file contains some workarounds.
# Remove them as soon as a proper clang version comes out.
import plistlib
from xml.parsers.expat import ExpatError
from codechecker_lib import logger
from . import plist_helper
LOG = logger.get_new_logger('PLIST_PARSER')
class GenericEquality(object):
def __eq__(self, other):
return (isinstance(other, self.__class__) and
self.__dict__ == other.__dict__)
def __ne__(self, other):
return not self.__eq__(other)
# -----------------------------------------------------------------------------
class Position(GenericEquality):
import shared
from codeCheckerDBAccess import codeCheckerDBAccess
from codeCheckerDBAccess import constants
from codeCheckerDBAccess.ttypes import *
from Authentication import codeCheckerAuthentication
from Authentication import constants
from Authentication.ttypes import *
from client_db_access_handler import ThriftRequestHandler
from client_auth_handler import ThriftAuthHandler
from codechecker_lib import logger
from codechecker_lib import database_handler
from codechecker_lib import session_manager
LOG = logger.get_new_logger('DB ACCESS')
class RequestHandler(SimpleHTTPRequestHandler):
"""
Handle thrift and browser requests
Simply modified and extended version of SimpleHTTPRequestHandler
"""
def __init__(self, request, client_address, server):
self.sc_session = server.sc_session
self.db_version_info = server.db_version_info
self.manager = server.manager
BaseHTTPRequestHandler.__init__(self,
import codecs
import sqlalchemy
from sqlalchemy import asc, desc
from sqlalchemy.sql import or_, and_, func
from sqlalchemy.sql.expression import literal_column
from db_model.orm_model import *
import shared
from codeCheckerDBAccess import constants
from codeCheckerDBAccess.ttypes import *
from codechecker_lib import logger
LOG = logger.get_new_logger('ACCESS HANDLER')
# -----------------------------------------------------------------------
def timefunc(function):
'''
timer function
'''
func_name = function.__name__
def debug_wrapper(*args, **kwargs):
'''
wrapper for debug log
'''
before = datetime.now()
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import argparse
import json
import re
import shlex
from codechecker_lib import logger
from codechecker_lib.analyzers import config_handler
LOG = logger.get_new_logger("CLANG TIDY CONFIG")
class ClangTidyConfigHandler(config_handler.AnalyzerConfigHandler):
"""
Configuration handler for Clang-tidy analyzer.
"""
def __init__(self):
super(ClangTidyConfigHandler, self).__init__()
def get_checker_configs(self):
"""
Process the raw extra analyzer arguments and get the configuration
data ('-config=' argument for Clang tidy) for the checkers.
Clang tidy accepts YAML or JSON formatted config, right now
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
""""""
import os
from codechecker_lib import logger
LOG = logger.get_new_logger('ENV')
# ------------------------------------------------------------------------------
def get_log_env(logfile, context, original_env):
"""
Environment for logging. With the ld logger.
Keep the original environment unmodified as possible.
Only environment variables required for logging are changed.
"""
new_env = original_env
new_env[context.env_var_cc_logger_bin] = context.path_logger_bin
new_env['LD_PRELOAD'] = context.logger_lib_name
try:
original_ld_library_path = new_env['LD_LIBRARY_PATH']
new_env['LD_LIBRARY_PATH'] = context.path_logger_lib + ':' + \
original_ld_library_path
import os
import re
import sys
from codechecker_lib import analyzer_env
from codechecker_lib import client
from codechecker_lib import host_check
from codechecker_lib import logger
from codechecker_lib.analyzers import analyzer_clang_tidy
from codechecker_lib.analyzers import analyzer_clangsa
from codechecker_lib.analyzers import config_handler_clang_tidy
from codechecker_lib.analyzers import config_handler_clangsa
from codechecker_lib.analyzers import result_handler_clang_tidy
from codechecker_lib.analyzers import result_handler_clangsa
LOG = logger.get_new_logger('ANALYZER TYPES')
CLANG_SA = 'clangsa'
CLANG_TIDY = 'clang-tidy'
supported_analyzers = {CLANG_SA, CLANG_TIDY}
def is_sa_checker_name(checker_name):
"""
Match for Clang Static analyzer names like:
- unix
- unix.Malloc
- security.insecureAPI
- security.insecureAPI.gets
"""
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
import os
import sys
import shlex
import signal
import subprocess
from abc import ABCMeta, abstractmethod
from codechecker_lib import logger
LOG = logger.get_new_logger('ANALYZER_BASE')
class SourceAnalyzer(object):
"""
base class for different source analyzers
"""
__metaclass__ = ABCMeta
def __init__(self, config_handler, buildaction):
self.__config_handler = config_handler
self.__buildaction = buildaction
self.__source_file = ''
self.__checkers = []
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
"""
"""
import fnmatch
import re
from codechecker_lib import logger
LOG = logger.get_new_logger('SKIPLIST_HANDLER')
class SkipListHandler(object):
"""
Skiplist file format:
-/skip/all/source/in/directory*
-/do/not/check/this.file
+/dir/check.this.file
-/dir/*
"""
def __init__(self, skip_file):
"""
read up the skip file
"""
self.__skip = []
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
'''
suppress handling
'''
import re
import abc
import linecache
from codechecker_lib import logger
LOG = logger.get_new_logger('SUPPRESS HANDLER')
class SuppressHandler(object):
""" suppress handler base class """
__metaclass__ = abc.ABCMeta
__suppressfile = None
@abc.abstractmethod
def store_suppress_bug_id(self,
source_file_path,
bug_id,
file_name,
comment):
import sys
import sqlalchemy
from sqlalchemy import asc, desc
from sqlalchemy.sql import or_, and_, func
from sqlalchemy.sql.expression import literal_column
from db_model.orm_model import *
import shared
from codeCheckerDBAccess import constants
from codeCheckerDBAccess.ttypes import *
from codechecker_lib import logger
LOG = logger.get_new_logger('ACCESS HANDLER')
# -----------------------------------------------------------------------
def timefunc(function):
'''
timer function
'''
func_name = function.__name__
def debug_wrapper(*args, **kwargs):
'''
wrapper for debug log
'''
before = datetime.now()
import os
import sys
import signal
import multiprocessing
import ntpath
import traceback
import shutil
from collections import defaultdict
from codechecker_lib import logger
from codechecker_lib import analyzer_env
from codechecker_lib.analyzers import analyzer_types
LOG = logger.get_new_logger('ANALISYS MANAGER')
def worker_result_handler(results):
"""
print the analisys summary
"""
successful_analysis = defaultdict(int)
failed_analisys = defaultdict(int)
skipped_num = 0
for res, skipped, analyzer_type in results:
if skipped:
skipped_num += 1
else:
# -------------------------------------------------------------------------
# The CodeChecker Infrastructure
# This file is distributed under the University of Illinois Open Source
# License. See LICENSE.TXT for details.
# -------------------------------------------------------------------------
"""
"""
import re
import shlex
import subprocess
from codechecker_lib import logger
from codechecker_lib.analyzers import analyzer_base
LOG = logger.get_new_logger('CLANG TIDY')
class ClangTidy(analyzer_base.SourceAnalyzer):
"""
Constructs the clang tidy analyzer commands.
"""
def __parse_checkers(self, tidy_output):
"""
Parse clang tidy checkers list.
Skip clang static analyzer checkers.
Store them to checkers.
"""
for line in tidy_output.splitlines():
line = line.strip()
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from SimpleHTTPServer import SimpleHTTPRequestHandler
from thrift.transport import TTransport
from thrift.protocol import TJSONProtocol
from codeCheckerDBAccess import codeCheckerDBAccess
from codeCheckerDBAccess.ttypes import *
from client_db_access_handler import ThriftRequestHandler
from codechecker_lib import logger
from codechecker_lib import database_handler
LOG = logger.get_new_logger('DB ACCESS')
class RequestHander(SimpleHTTPRequestHandler):
'''
Handle thrift and browser requests
Simply modified and extended version of SimpleHTTPRequestHandler
'''
def __init__(self, request, client_address, server):
self.sc_session = server.sc_session
self.db_version_info = server.db_version_info
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
