# Y2038-unsafe types by definition

'time_t'

# Types using Y2038-unsafe types

'lastlog',

'msqid_ds',

'semid_ds',

'timeb',

'timespec',

'timeval',

'utimbuf',

'itimerspec',

'clnt_ops',

'elf_prstatus',

'itimerval',

'ntptimeval',

'rusage',

'timex',

'utmp',

'utmpx',

# APIs using 2038-unsafe types

'ctime',

'ctime_r',

'difftime',

'gmtime',

'gmtime_r',

'localtime',

'localtime_r',

'mktime',

'stime',

'timegm',

'timelocal',

'time',

'msgctl',

'ftime',

'aio_suspend',

'clock_getres',

'clock_gettime',

'clock_nanosleep',

'clock_settime',

'futimens',

'mq_timedreceive',

'mq_timedsend',

'nanosleep',

'pselect',

'pthread_cond_timedwait',

'pthread_mutex_timedlock',

'pthread_rwlock_timedrdlock',

'pthread_rwlock_timedwrlock',

'sched_rr_get_interval',

'sem_timedwait',

'sigtimedwait',

'timespec_get',

'utimensat',

'adjtime',

'pmap_rmtcall',

'clntudp_bufcreate',

'clntudp_create',

'futimes',

'gettimeofday',

'lutimes',

'select',

'settimeofday',

'utimes',

'utime',

'timerfd_gettime',

'timerfd_settime',

'timer_gettime',

'timer_settime',

'fstatat',

'fstat',

'__fxstatat',

'__fxstat',

'lstat',

'__lxstat',

'stat',

'__xstat',

'struct itimerval',

'setitimer',

'getitimer',

'ntp_gettime',

'getrusage',

'wait3',

'wait4',

'adjtimex',

'ntp_adjtime',

'getutent_r',

'getutent',

'getutid_r',

'getutid',

'getutline_r',

'getutline',

'login',

'pututline',

'updwtmp',

'getutxent',

'getutxid',

'getutxline',

'pututxline'

"""

result = {

'time_bits_defined': False,

'time_bits_value': None,

'use_time_bits64_defined': False,

'file_offset_bits_defined': False,

'file_offset_bits_value': None

}

if not config_name:

return result

try:

# Check for _TIME_BITS=64 (correct value)

if re_flag_time_bits_64.search(config_name):

result['time_bits_defined'] = True

result['time_bits_value'] = Y2038_SAFE_TIME_BITS

else:

# Check for _TIME_BITS=other_value

match = re_flag_time_bits.search(config_name)

if match:

result['time_bits_defined'] = True

try:

result['time_bits_value'] = int(match.group(1))

except (ValueError, IndexError):

# Malformed _TIME_BITS value, treat as undefined

result['time_bits_defined'] = False

result['time_bits_value'] = None

# Check for _USE_TIME_BITS64

if re_flag_use_time_bits64.search(config_name):

result['use_time_bits64_defined'] = True

# Check for _FILE_OFFSET_BITS=64 (correct value)

if re_flag_file_offset_bits_64.search(config_name):

result['file_offset_bits_defined'] = True

result['file_offset_bits_value'] = Y2038_SAFE_FILE_OFFSET_BITS

else:

# Check for _FILE_OFFSET_BITS=other_value

match = re_flag_file_offset_bits.search(config_name)

if match:

result['file_offset_bits_defined'] = True

try:

result['file_offset_bits_value'] = int(match.group(1))

except (ValueError, IndexError):

# Malformed _FILE_OFFSET_BITS value, treat as undefined

result['file_offset_bits_defined'] = False

result['file_offset_bits_value'] = None

except (AttributeError, TypeError, ValueError):

# If any unexpected error occurs during parsing, return empty result

# This ensures the addon continues to work even with malformed configurations

# Note: We catch specific exceptions rather than broad Exception for better debugging

pass

"""

# Assume that the code is Y2038 safe until proven otherwise

y2038safe = True

# load XML from .dump file

data = cppcheckdata.CppcheckData(dumpfile)

srcfile = data.files[0]

for cfg in data.iterconfigurations():

if not quiet:

print('Checking %s, config %s...' % (srcfile, cfg.name))

safe_ranges = []

safe = -1

time_bits_defined = False

srclinenr = 0

# Priority-based flag detection: dump file configuration > source code directives

# 1. Check dump file configuration (from cppcheck's project parsing - highest priority)

dump_config_flags = parse_dump_config(cfg.name)

# Initialize effective flags with dump file configuration

effective_flags = {

'time_bits_defined': dump_config_flags['time_bits_defined'],

'time_bits_value': dump_config_flags['time_bits_value'],

'use_time_bits64_defined': dump_config_flags['use_time_bits64_defined'],

'file_offset_bits_defined': dump_config_flags['file_offset_bits_defined'],

'file_offset_bits_value': dump_config_flags['file_offset_bits_value']

}

# Determine configuration source for reporting

config_source = None

has_dump_config = (dump_config_flags['time_bits_defined'] or

dump_config_flags['file_offset_bits_defined'] or

dump_config_flags['use_time_bits64_defined'])

if has_dump_config:

config_source = "cppcheck configuration"

# Track time_bits_defined for _USE_TIME_BITS64 validation

time_bits_defined = effective_flags['time_bits_defined']

# Check effective _TIME_BITS value (from dump file configuration)

if effective_flags['time_bits_defined']:

if effective_flags['time_bits_value'] != Y2038_SAFE_TIME_BITS:

fake_directive = type('FakeDirective', (), {

'file': srcfile, 'linenr': 0, 'column': 0,

'str': 'cppcheck configuration: _TIME_BITS=%s' % effective_flags['time_bits_value']

})()

cppcheckdata.reportError(fake_directive, 'error',

'_TIME_BITS must be defined equal to 64 (found in cppcheck configuration: _TIME_BITS=%s)' % effective_flags['time_bits_value'],

'y2038',

'type-bits-not-64')

y2038safe = False

# Check effective _FILE_OFFSET_BITS value (from dump file configuration)

if effective_flags['file_offset_bits_defined']:

if effective_flags['file_offset_bits_value'] != Y2038_SAFE_FILE_OFFSET_BITS:

fake_directive = type('FakeDirective', (), {

'file': srcfile, 'linenr': 0, 'column': 0,

'str': 'cppcheck configuration: _FILE_OFFSET_BITS=%s' % effective_flags['file_offset_bits_value']

})()

cppcheckdata.reportError(fake_directive, 'error',

'_FILE_OFFSET_BITS must be defined equal to 64 (found in cppcheck configuration: _FILE_OFFSET_BITS=%s)' % effective_flags['file_offset_bits_value'],

'y2038',

'file-offset-bits-not-64')

y2038safe = False

# Check effective _USE_TIME_BITS64 (from dump file configuration)

if effective_flags['use_time_bits64_defined']:

if not time_bits_defined:

# _USE_TIME_BITS64 defined without _TIME_BITS is problematic

fake_directive = type('FakeDirective', (), {

'file': srcfile, 'linenr': 0, 'column': 0,

'str': 'cppcheck configuration: _USE_TIME_BITS64'

})()

cppcheckdata.reportError(fake_directive, 'warning',

'_USE_TIME_BITS64 is defined in cppcheck configuration but _TIME_BITS was not',

'y2038',

'type-bits-undef')

y2038safe = False

else:

# _USE_TIME_BITS64 defined WITH _TIME_BITS - this is correct

safe = 0 # Start of file is safe

# 2. Fallback to source code directives when dump file configuration is not available

source_time_bits_defined = False # pylint: disable=unused-variable

source_file_offset_bits_defined = False # pylint: disable=unused-variable

source_file_offset_bits_value = None # pylint: disable=unused-variable

source_use_time_bits64_defined = False # pylint: disable=unused-variable

# Track which flags came from source code for mixed scenario reporting

source_flags_used = {

'time_bits': False,

'file_offset_bits': False,

'use_time_bits64': False

}

for directive in cfg.directives:

# track source line number

if directive.file == srcfile:

srclinenr = directive.linenr

# Process source code directives as fallback when dump config is not available

# check for correct _TIME_BITS if present

if re_define_time_bits_64.match(directive.str):

source_time_bits_defined = True

# Only use source directive if dump config doesn't define _TIME_BITS

if not effective_flags['time_bits_defined']:

effective_flags['time_bits_defined'] = True

effective_flags['time_bits_value'] = Y2038_SAFE_TIME_BITS

time_bits_defined = True

source_flags_used['time_bits'] = True

elif re_define_time_bits.match(directive.str):

source_time_bits_defined = False

# Only use source directive if dump config doesn't define _TIME_BITS

if not effective_flags['time_bits_defined']:

source_flags_used['time_bits'] = True

cppcheckdata.reportError(directive, 'error',

'_TIME_BITS must be defined equal to 64',

'y2038',

'type-bits-not-64')

y2038safe = False

elif re_undef_time_bits.match(directive.str):

source_time_bits_defined = False

# Only use source directive if dump config doesn't define _TIME_BITS

if not effective_flags['time_bits_defined']:

time_bits_defined = False

source_flags_used['time_bits'] = True

# check for correct _FILE_OFFSET_BITS if present

if re_define_file_offset_bits_64.match(directive.str):

source_file_offset_bits_defined = True

source_file_offset_bits_value = Y2038_SAFE_FILE_OFFSET_BITS

# Only use source directive if dump config doesn't define _FILE_OFFSET_BITS

if not effective_flags['file_offset_bits_defined']:

effective_flags['file_offset_bits_defined'] = True

effective_flags['file_offset_bits_value'] = Y2038_SAFE_FILE_OFFSET_BITS

source_flags_used['file_offset_bits'] = True

elif re_define_file_offset_bits.match(directive.str):

source_file_offset_bits_defined = False

# Only use source directive if dump config doesn't define _FILE_OFFSET_BITS

if not effective_flags['file_offset_bits_defined']:

source_flags_used['file_offset_bits'] = True

cppcheckdata.reportError(directive, 'error',

'_FILE_OFFSET_BITS must be defined equal to 64',

'y2038',

'file-offset-bits-not-64')

y2038safe = False

elif re_undef_file_offset_bits.match(directive.str):

source_file_offset_bits_defined = False

source_file_offset_bits_value = None

# Only use source directive if dump config doesn't define _FILE_OFFSET_BITS

if not effective_flags['file_offset_bits_defined']:

effective_flags['file_offset_bits_defined'] = False

effective_flags['file_offset_bits_value'] = None

source_flags_used['file_offset_bits'] = True

# check for _USE_TIME_BITS64 (un)definition

if re_define_use_time_bits64.match(directive.str):

safe = int(srclinenr)

source_use_time_bits64_defined = True

# Only use source directive if dump config doesn't define _USE_TIME_BITS64

if not effective_flags['use_time_bits64_defined']:

effective_flags['use_time_bits64_defined'] = True

source_flags_used['use_time_bits64'] = True

# warn about _TIME_BITS not being defined (check effective flags)

if not time_bits_defined:

cppcheckdata.reportError(directive, 'warning',

'_USE_TIME_BITS64 is defined but _TIME_BITS was not',

'y2038',

'type-bits-undef')

elif re_undef_use_time_bits64.match(directive.str):

unsafe = int(srclinenr)

source_use_time_bits64_defined = False

# Only use source directive if dump config doesn't define _USE_TIME_BITS64

if not effective_flags['use_time_bits64_defined']:

source_flags_used['use_time_bits64'] = True

# do we have a safe..unsafe area?

if unsafe > safe >= 0:

safe_ranges.append((safe, unsafe))

safe = -1

# check end of source beyond last directive

if len(cfg.tokenlist) > 0:

unsafe = int(cfg.tokenlist[-1].linenr)

if unsafe > safe >= 0:

safe_ranges.append((safe, unsafe))

# Determine if Y2038 warnings should be suppressed

# Require BOTH _TIME_BITS=64 AND _FILE_OFFSET_BITS=64 for complete Y2038 safety

y2038_safe_config = (

effective_flags['time_bits_defined'] and

effective_flags['time_bits_value'] == Y2038_SAFE_TIME_BITS and

effective_flags['file_offset_bits_defined'] and

effective_flags['file_offset_bits_value'] == Y2038_SAFE_FILE_OFFSET_BITS

)

# Update config_source for suppression reporting based on mixed scenarios

if y2038_safe_config:

# Determine configuration source for mixed scenarios

dump_flags_count = sum([

dump_config_flags['time_bits_defined'],

dump_config_flags['file_offset_bits_defined'],

dump_config_flags['use_time_bits64_defined']

])

source_flags_count = sum(source_flags_used.values())

if dump_flags_count > 0 and source_flags_count > 0:

# Mixed scenario: both dump config and source directives used

config_source = "mixed configuration (cppcheck configuration and source code directives)"

elif dump_flags_count > 0:

# Only dump config used

config_source = "cppcheck configuration"

elif source_flags_count > 0:

# Only source directives used

config_source = "source code directives"

else:

# Fallback (shouldn't happen if y2038_safe_config is True)

config_source = "configuration"

# go through all tokens

warnings_suppressed = 0

for token in cfg.tokenlist:

if token.str in id_Y2038:

is_in_safe_range = any(lower <= int(token.linenr) <= upper

for (lower, upper) in safe_ranges)

if not is_in_safe_range:

if y2038_safe_config:

# Count suppressed warnings but don't report them

warnings_suppressed += 1

else:

# Report the warning as before

cppcheckdata.reportError(token, 'warning',

token.str + ' is Y2038-unsafe',

'y2038',

'unsafe-call')

y2038safe = False

token = token.next

# Print suppression message if warnings were suppressed

if warnings_suppressed > 0 and config_source and not quiet:

print('Y2038 warnings suppressed: Found proper Y2038 configuration in %s (_TIME_BITS=%d and _FILE_OFFSET_BITS=%d)' % (config_source, Y2038_SAFE_TIME_BITS, Y2038_SAFE_FILE_OFFSET_BITS))

print('Suppressed %d Y2038-unsafe function warning(s)' % warnings_suppressed)