| 1 |
#!/usr/bin/python
|
| 2 |
|
| 3 |
import sys
|
| 4 |
sys.path.insert(0,'../lib/python')
|
| 5 |
|
| 6 |
if len(sys.argv) <> 3:
|
| 7 |
print "usage: python tracker_serivce.py SOCKET-PATH DATABASE-PATH"
|
| 8 |
sys.exit(1)
|
| 9 |
socket_name = sys.argv[1]
|
| 10 |
db_name = sys.argv[2]
|
| 11 |
|
| 12 |
import bugs
|
| 13 |
import re
|
| 14 |
import security_db
|
| 15 |
from web_support import *
|
| 16 |
|
| 17 |
class TrackerService(WebService):
|
| 18 |
head_contents = compose(STYLE(
|
| 19 |
"""h1 { font-size : 144%; }
|
| 20 |
h2 { font-size : 120%; }
|
| 21 |
h3 { font-size : 100%; }
|
| 22 |
|
| 23 |
table { padding-left : 1.5em }
|
| 24 |
td, th { text-align : left;
|
| 25 |
padding-left : 0.25em;
|
| 26 |
padding-right : 0.25em; }
|
| 27 |
td { vertical-align: baseline }
|
| 28 |
span.red { color: red; }
|
| 29 |
span.dangerous { color: rgb(191,127,0); }
|
| 30 |
"""), SCRIPT('''var old_query_value = "";
|
| 31 |
|
| 32 |
function selectSearch() {
|
| 33 |
document.searchForm.query.focus();
|
| 34 |
}
|
| 35 |
|
| 36 |
function onSearch(query) {
|
| 37 |
if (old_query_value == "") {
|
| 38 |
if (query.length > 5) {
|
| 39 |
old_query_value = query;
|
| 40 |
document.searchForm.submit();
|
| 41 |
} else {
|
| 42 |
old_query_value = query;
|
| 43 |
}
|
| 44 |
}
|
| 45 |
}
|
| 46 |
''')).toHTML()
|
| 47 |
|
| 48 |
def __init__(self, socket_name, db_name):
|
| 49 |
WebService.__init__(self, socket_name)
|
| 50 |
self.db = security_db.DB(db_name)
|
| 51 |
self.register('', self.page_home)
|
| 52 |
self.register('*', self.page_object)
|
| 53 |
self.register('source-package/*', self.page_source_package)
|
| 54 |
self.register('binary-package/*', self.page_binary_package)
|
| 55 |
self.register('status/release/stable', self.page_status_release_stable)
|
| 56 |
self.register('status/release/testing',
|
| 57 |
self.page_status_release_testing)
|
| 58 |
self.register('status/release/unstable',
|
| 59 |
self.page_status_release_unstable)
|
| 60 |
self.register('status/dtsa-candidates',
|
| 61 |
self.page_status_dtsa_candidates)
|
| 62 |
self.register('status/todo', self.page_status_todo)
|
| 63 |
self.register('status/itp', self.page_status_itp)
|
| 64 |
self.register('data/unknown-packages', self.page_data_unknown_packages)
|
| 65 |
self.register('data/missing-epochs', self.page_data_missing_epochs)
|
| 66 |
self.register('data/releases', self.page_data_releases)
|
| 67 |
self.register('data/funny-versions', self.page_data_funny_versions)
|
| 68 |
|
| 69 |
def page_home(self, path, params, url):
|
| 70 |
query = params.get('query', ('',))[0]
|
| 71 |
if query:
|
| 72 |
if '/' in query:
|
| 73 |
return self.page_not_found(url, query)
|
| 74 |
else:
|
| 75 |
return RedirectResult(url.scriptRelativeFull(query))
|
| 76 |
|
| 77 |
return self.create_page(
|
| 78 |
url, 'Security Bug Tracker',
|
| 79 |
[P(
|
| 80 |
"""This is the experimental issue tracker for Debian's testing
|
| 81 |
security team. Keep in mind that this is merely a prototype.
|
| 82 |
Please report any problems to """,
|
| 83 |
A("mailto:fw@deneb.enyo.de", "Florian Weimer"),
|
| 84 |
""".Note that some of the data presented here is known
|
| 85 |
to be wrong (see below), but the data for the testing suite
|
| 86 |
should be fine."""),
|
| 87 |
make_menu(
|
| 88 |
url.scriptRelative,
|
| 89 |
('status/release/stable',
|
| 90 |
'Vulnerable packages in the stable suite'),
|
| 91 |
('status/release/testing',
|
| 92 |
'Vulnerable packages in the testing suite'),
|
| 93 |
('status/release/unstable',
|
| 94 |
'Vulnerable packages in the unstable suite'),
|
| 95 |
('status/dtsa-candidates', "Candidates for DTSAs"),
|
| 96 |
('status/todo', 'TODO items'),
|
| 97 |
('status/itp', 'ITPs with potential security issues'),
|
| 98 |
('data/unknown-packages',
|
| 99 |
'Packages names not found in the archive'),
|
| 100 |
('data/missing-epochs',
|
| 101 |
'Package versions which might lack an epoch'),
|
| 102 |
('data/funny-versions',
|
| 103 |
'Packages with strange version numbers'),
|
| 104 |
('data/releases',
|
| 105 |
'Covered Debian releases and architectures (slow)'),
|
| 106 |
self.make_search_button(url)),
|
| 107 |
|
| 108 |
H2("A few notes on data sources"),
|
| 109 |
P("""Data in this tracker comes solely from the bug database
|
| 110 |
which is maintained by Debian's testing security team in their
|
| 111 |
Subversion repository. All external data (this includes
|
| 112 |
Debian bug reports and official Debian security advisories)
|
| 113 |
must be added to this database before it appears here, and there
|
| 114 |
can be some delay before this happens."""),
|
| 115 |
P("""At the moment, the database only contains information which is
|
| 116 |
relevant for tracking the security status of the stable, testing and
|
| 117 |
unstable suites. This means that data for oldstable is likely wrong.""")],
|
| 118 |
search_in_page=True)
|
| 119 |
|
| 120 |
def page_object(self, path, params, url):
|
| 121 |
obj = path[0]
|
| 122 |
|
| 123 |
if not obj:
|
| 124 |
# Redirect to start page.
|
| 125 |
return RedirectResult(url.scriptRelativeFull(""))
|
| 126 |
|
| 127 |
if 'A' <= obj[0] <= 'Z':
|
| 128 |
# Bug names start with a capital letter.
|
| 129 |
return self.page_bug(url, obj)
|
| 130 |
|
| 131 |
bugnumber = 0
|
| 132 |
try:
|
| 133 |
bugnumber = int(obj)
|
| 134 |
except ValueError:
|
| 135 |
pass
|
| 136 |
if bugnumber:
|
| 137 |
return self.page_debian_bug(url, bugnumber)
|
| 138 |
|
| 139 |
c = self.db.cursor()
|
| 140 |
if self.db.isSourcePackage(c, obj):
|
| 141 |
return RedirectResult(self.url_source_package(url, obj, full=True))
|
| 142 |
if self.db.isBinaryPackage(c, obj):
|
| 143 |
return RedirectResult(self.url_binary_package(url ,obj, full=True))
|
| 144 |
|
| 145 |
return self.page_not_found(url, obj)
|
| 146 |
|
| 147 |
def page_bug(self, url, name):
|
| 148 |
cursor = self.db.cursor()
|
| 149 |
try:
|
| 150 |
bug = bugs.BugFromDB(cursor, name)
|
| 151 |
except ValueError:
|
| 152 |
return self.page_not_found(url, name)
|
| 153 |
if bug.name <> name:
|
| 154 |
# Show the normalized bug name in the browser address bar.
|
| 155 |
return RedirectResult(url.scriptRelativeFull(bug.name))
|
| 156 |
|
| 157 |
page = []
|
| 158 |
|
| 159 |
def gen_header():
|
| 160 |
yield B("Name"), bug.name
|
| 161 |
|
| 162 |
source = bug.name.split('-')[0]
|
| 163 |
if source in ('CAN', 'CVE'):
|
| 164 |
source_xref = self.make_cve_ref(url, bug.name, 'CVE')
|
| 165 |
elif source == 'DSA':
|
| 166 |
source_xref = self.make_dsa_ref(url, bug.name, 'Debian')
|
| 167 |
elif source == 'DTSA':
|
| 168 |
source_xref = 'Debian Testing Security Team'
|
| 169 |
elif source == 'FAKE':
|
| 170 |
source_xref = (
|
| 171 |
'Automatically generated temporary name. Not for external reference.')
|
| 172 |
else:
|
| 173 |
source_xref = None
|
| 174 |
|
| 175 |
if source_xref:
|
| 176 |
yield B("Source"), source_xref
|
| 177 |
|
| 178 |
if bug.description:
|
| 179 |
yield B("Description"), bug.description
|
| 180 |
|
| 181 |
xref = list(self.db.getBugXrefs(cursor, bug.name))
|
| 182 |
if xref:
|
| 183 |
yield B("References"), self.make_xref_list(url, xref)
|
| 184 |
|
| 185 |
debian_bugs = bug.getDebianBugs(cursor)
|
| 186 |
if debian_bugs:
|
| 187 |
yield (B("Debian Bugs"),
|
| 188 |
self.make_debian_bug_list(url, debian_bugs))
|
| 189 |
|
| 190 |
if not bug.not_for_us:
|
| 191 |
for (release, status, reason) in bug.getStatus(cursor):
|
| 192 |
if status <> 'fixed':
|
| 193 |
reason = self.make_red(reason)
|
| 194 |
yield B('Status of %s' % release), reason
|
| 195 |
|
| 196 |
page.append(make_table(gen_header()))
|
| 197 |
|
| 198 |
if bug.notes:
|
| 199 |
page.append(H2("Vulnerable and fixed packages"))
|
| 200 |
|
| 201 |
def gen_source():
|
| 202 |
old_pkg = ''
|
| 203 |
for (package, release, version, vulnerable) \
|
| 204 |
in self.db.getSourcePackages(cursor, bug.name):
|
| 205 |
if package == old_pkg:
|
| 206 |
package = ''
|
| 207 |
else:
|
| 208 |
old_pkg = package
|
| 209 |
package = compose(
|
| 210 |
self.make_source_package_ref(url, package),
|
| 211 |
" (", self.make_pts_ref(url, package, 'PTS'), ")")
|
| 212 |
if vulnerable:
|
| 213 |
vuln = self.make_red('vulnerable')
|
| 214 |
version = self.make_red(version)
|
| 215 |
else:
|
| 216 |
vuln = 'fixed'
|
| 217 |
|
| 218 |
yield package, ', '.join(release), version, vuln
|
| 219 |
|
| 220 |
page.append(make_table(gen_source(),
|
| 221 |
caption=("Source Package", "Release", "Version", "Status"),
|
| 222 |
introduction=P('The table below lists information on source packages.')))
|
| 223 |
|
| 224 |
def gen_binary():
|
| 225 |
old_pkg = ''
|
| 226 |
for (packages, releases, version, archs, vulnerable) \
|
| 227 |
in self.db.getBinaryPackages(cursor, bug.name):
|
| 228 |
pkg = ', '.join(packages)
|
| 229 |
if pkg == old_pkg:
|
| 230 |
packages = ''
|
| 231 |
else:
|
| 232 |
old_pkg = pkg
|
| 233 |
packages = self.make_binary_packages_ref(url, packages)
|
| 234 |
|
| 235 |
if vulnerable:
|
| 236 |
vuln = self.make_red('vulnerable')
|
| 237 |
version = self.make_red(version)
|
| 238 |
else:
|
| 239 |
vuln = 'fixed'
|
| 240 |
yield (packages,
|
| 241 |
', '.join(releases),
|
| 242 |
version, vuln,
|
| 243 |
', '.join(archs))
|
| 244 |
|
| 245 |
page.append(make_table(gen_binary(),
|
| 246 |
caption=("Binary Package", "Release", "Version", "Status",
|
| 247 |
"Architecures"),
|
| 248 |
introduction=P("The next table lists affected binary packages.")))
|
| 249 |
|
| 250 |
def gen_data():
|
| 251 |
notes_sorted = bug.notes[:]
|
| 252 |
notes_sorted.sort(lambda a, b: cmp(a.package, b.package))
|
| 253 |
for n in notes_sorted:
|
| 254 |
if n.release:
|
| 255 |
rel = str(n.release)
|
| 256 |
else:
|
| 257 |
rel = '(unstable)'
|
| 258 |
urgency = str(n.urgency)
|
| 259 |
if n.fixed_version:
|
| 260 |
ver = str(n.fixed_version)
|
| 261 |
if ver == '0':
|
| 262 |
ver = '(not affected)'
|
| 263 |
urgency = ''
|
| 264 |
else:
|
| 265 |
ver = self.make_red('(unfixed)')
|
| 266 |
|
| 267 |
pkg = n.package
|
| 268 |
pkg_kind = n.package_kind
|
| 269 |
if pkg_kind == 'source':
|
| 270 |
pkg = self.make_source_package_ref(url, pkg)
|
| 271 |
elif pkg_kind == 'binary':
|
| 272 |
pkg = self.make_binary_package_ref(url, pkg)
|
| 273 |
elif pkg_kind == 'itp':
|
| 274 |
pkg_kind = 'ITP'
|
| 275 |
rel = ''
|
| 276 |
ver = ''
|
| 277 |
urgency = ''
|
| 278 |
|
| 279 |
bugs = n.bugs
|
| 280 |
bugs.sort()
|
| 281 |
bugs = make_list(
|
| 282 |
map(lambda x: self.make_debian_bug(url, x), bugs))
|
| 283 |
if n.bug_origin:
|
| 284 |
origin = self.make_xref(url, n.bug_origin)
|
| 285 |
else:
|
| 286 |
origin = ''
|
| 287 |
yield (pkg, pkg_kind, rel, ver, urgency, origin, bugs)
|
| 288 |
|
| 289 |
page.append(
|
| 290 |
make_table(gen_data(),
|
| 291 |
caption=("Package", "Type", "Release", "Fixed Version",
|
| 292 |
"Urgency", "Origin", "Debian Bugs"),
|
| 293 |
introduction=P("The information above is based on the following data on fixed versions.")))
|
| 294 |
|
| 295 |
if bug.comments:
|
| 296 |
page.append(H2("Notes"))
|
| 297 |
def gen_comments():
|
| 298 |
for (t, c) in bug.comments:
|
| 299 |
yield c
|
| 300 |
page.append(make_pre(gen_comments()))
|
| 301 |
|
| 302 |
return self.create_page(url, bug.name, page)
|
| 303 |
|
| 304 |
def page_debian_bug(self, url, bugnumber):
|
| 305 |
buglist = list(self.db.getBugsFromDebianBug(self.db.cursor(),
|
| 306 |
bugnumber))
|
| 307 |
if buglist:
|
| 308 |
if len(buglist) == 1:
|
| 309 |
# Single issue, redirect.
|
| 310 |
return RedirectResult(url.scriptRelativeFull(buglist[0][0]))
|
| 311 |
|
| 312 |
def gen():
|
| 313 |
for (name, urgency, description) in buglist:
|
| 314 |
if urgency == "unknown":
|
| 315 |
urgency = ""
|
| 316 |
yield self.make_xref(url, name), urgency, description
|
| 317 |
|
| 318 |
return self.create_page(
|
| 319 |
url, "Information related to Debian bug #%d" % bugnumber,
|
| 320 |
[P("The following issues reference to Debian bug ",
|
| 321 |
self.make_debian_bug(url, bugnumber), ":"),
|
| 322 |
make_table(gen(),
|
| 323 |
caption=("Name", "Urgency", "Description"))])
|
| 324 |
|
| 325 |
else:
|
| 326 |
return self.page_not_found(url, str(bugnumber))
|
| 327 |
|
| 328 |
def page_not_found(self, url, query):
|
| 329 |
return self.create_page(url, 'Not found',
|
| 330 |
[P('Your query ',
|
| 331 |
CODE(query),
|
| 332 |
' matched no results.')],
|
| 333 |
status=404)
|
| 334 |
|
| 335 |
def page_source_package(self, path, params, url):
|
| 336 |
pkg = path[0]
|
| 337 |
|
| 338 |
def gen_versions():
|
| 339 |
for (releases, version) in self.db.getSourcePackageVersions(
|
| 340 |
self.db.cursor(), pkg):
|
| 341 |
yield ', '.join(releases), version
|
| 342 |
def gen_binary():
|
| 343 |
for (packages, releases, archs, version) \
|
| 344 |
in self.db.getBinaryPackagesForSource(
|
| 345 |
self.db.cursor(), pkg):
|
| 346 |
yield (self.make_binary_packages_ref(url, packages),
|
| 347 |
', '.join(releases), version, ', '.join(archs))
|
| 348 |
def gen_bug_list(lst):
|
| 349 |
for (bug, description) in lst:
|
| 350 |
yield self.make_xref(url, bug), description
|
| 351 |
|
| 352 |
return self.create_page(
|
| 353 |
url, "Information on source package " + pkg,
|
| 354 |
[make_menu(lambda x: x,
|
| 355 |
(self.url_pts(url, pkg),
|
| 356 |
pkg + ' in the Package Tracking System'),
|
| 357 |
(self.url_debian_bug_pkg(url, pkg),
|
| 358 |
pkg + ' in the Bug Tracking System'),
|
| 359 |
(self.url_testing_status(url, pkg),
|
| 360 |
pkg + ' in the testing migration checker')),
|
| 361 |
H2("Available versions"),
|
| 362 |
make_table(gen_versions(), caption=("Release", "Version")),
|
| 363 |
|
| 364 |
H2("Available binary packages"),
|
| 365 |
make_table(gen_binary(),
|
| 366 |
caption=('Package', 'Release', 'Version', 'Architectures'),
|
| 367 |
replacement="""No binary packages are recorded in this database.
|
| 368 |
This probably means that the package is architecture-specific, and the
|
| 369 |
architecture is currently not tracked."""),
|
| 370 |
|
| 371 |
H2("Open issues"),
|
| 372 |
make_table(gen_bug_list(self.db.getBugsForSourcePackage
|
| 373 |
(self.db.cursor(), pkg, True)),
|
| 374 |
caption=('Bug', 'Description'),
|
| 375 |
replacement='No known open issues.'),
|
| 376 |
|
| 377 |
H2("Resolved issues"),
|
| 378 |
make_table(gen_bug_list(self.db.getBugsForSourcePackage
|
| 379 |
(self.db.cursor(), pkg, False)),
|
| 380 |
caption=('Bug', 'Description'),
|
| 381 |
replacement='No known resolved issues.')])
|
| 382 |
|
| 383 |
def page_binary_package(self, path, params, url):
|
| 384 |
pkg = path[0]
|
| 385 |
|
| 386 |
def gen_versions():
|
| 387 |
for (releases, source, version, archs) \
|
| 388 |
in self.db.getBinaryPackageVersions(self.db.cursor(), pkg):
|
| 389 |
yield (', '.join(releases),
|
| 390 |
self.make_source_package_ref(url, source),
|
| 391 |
version, ', '.join(archs))
|
| 392 |
def gen_bug_list(lst):
|
| 393 |
for (bug, description) in lst:
|
| 394 |
yield self.make_xref(url, bug), description
|
| 395 |
|
| 396 |
return self.create_page(
|
| 397 |
url, "Information on binary package " + pkg,
|
| 398 |
[make_menu(lambda x: x,
|
| 399 |
(self.url_debian_bug_pkg(url, pkg),
|
| 400 |
pkg + ' in the Bug Tracking System')),
|
| 401 |
H2("Available versions"),
|
| 402 |
make_table(gen_versions(),
|
| 403 |
caption=("Release", "Source", "Version", "Architectures")),
|
| 404 |
|
| 405 |
H2("Open issues"),
|
| 406 |
make_table(gen_bug_list(self.db.getBugsForBinaryPackage
|
| 407 |
(self.db.cursor(), pkg, True)),
|
| 408 |
caption=('Bug', 'Description'),
|
| 409 |
replacement='No known open issues.'),
|
| 410 |
|
| 411 |
H2("Resolved issues"),
|
| 412 |
make_table(gen_bug_list(self.db.getBugsForBinaryPackage
|
| 413 |
(self.db.cursor(), pkg, False)),
|
| 414 |
caption=('Bug', 'Description'),
|
| 415 |
replacement='No known resolved issues.'),
|
| 416 |
|
| 417 |
H2("Non-issues"),
|
| 418 |
make_table(gen_bug_list(self.db.getNonBugsForBinaryPackage
|
| 419 |
(self.db.cursor(), pkg)),
|
| 420 |
caption=('Bug', 'Description'),
|
| 421 |
replacement="""No known issues which do not affect
|
| 422 |
this package, but still reference it.""")])
|
| 423 |
|
| 424 |
def page_status_release_stable(self, path, params, url):
|
| 425 |
def gen():
|
| 426 |
old_pkg_name = ''
|
| 427 |
for (pkg_name, bug_name, archive, urgency) in \
|
| 428 |
self.db.cursor().execute(
|
| 429 |
"""SELECT package, bug, section, urgency FROM stable_status"""):
|
| 430 |
if pkg_name == old_pkg_name:
|
| 431 |
pkg_name = ''
|
| 432 |
else:
|
| 433 |
old_pkg_name = pkg_name
|
| 434 |
if archive <> 'main':
|
| 435 |
pkg_name = "%s (%s)" % (pkg_name, archive)
|
| 436 |
|
| 437 |
if urgency == 'unknown':
|
| 438 |
urgency = ''
|
| 439 |
elif urgency == 'high':
|
| 440 |
urgency = self.make_red(urgency)
|
| 441 |
|
| 442 |
yield pkg_name, self.make_xref(url, bug_name), urgency
|
| 443 |
|
| 444 |
return self.create_page(
|
| 445 |
url, 'Vulnerable source packages in the stable suite',
|
| 446 |
[make_table(gen(), caption=("Package", "Bug", "Urgency"))])
|
| 447 |
|
| 448 |
def page_status_release_testing(self, path, params, url):
|
| 449 |
def gen():
|
| 450 |
old_pkg_name = ''
|
| 451 |
for (pkg_name, bug_name, archive, urgency,
|
| 452 |
sid_vulnerable, ts_fixed) in self.db.cursor().execute(
|
| 453 |
"""SELECT package, bug, section, urgency, unstable_vulnerable,
|
| 454 |
testing_security_fixed
|
| 455 |
FROM testing_status"""):
|
| 456 |
if pkg_name == old_pkg_name:
|
| 457 |
pkg_name = ''
|
| 458 |
else:
|
| 459 |
old_pkg_name = pkg_name
|
| 460 |
if archive <> 'main':
|
| 461 |
pkg_name = "%s (%s)" % (pkg_name, archive)
|
| 462 |
|
| 463 |
if ts_fixed:
|
| 464 |
status = 'fixed in testing-security'
|
| 465 |
else:
|
| 466 |
if sid_vulnerable:
|
| 467 |
status = self.make_red('unstable is vulnerable')
|
| 468 |
else:
|
| 469 |
status = self.make_dangerous('fixed in unstable')
|
| 470 |
|
| 471 |
if urgency == 'unknown':
|
| 472 |
urgency = ''
|
| 473 |
|
| 474 |
yield (pkg_name, self.make_xref(url, bug_name),
|
| 475 |
urgency, status)
|
| 476 |
|
| 477 |
return self.create_page(
|
| 478 |
url, 'Vulnerable source packages in the testing suite',
|
| 479 |
[make_menu(url.scriptRelative,
|
| 480 |
("status/dtsa-candidates", "Candidates for DTSAs")),
|
| 481 |
make_table(gen(), caption=("Package", "Bug"))])
|
| 482 |
|
| 483 |
def page_status_release_unstable(self, path, params, url):
|
| 484 |
def gen():
|
| 485 |
old_pkg_name = ''
|
| 486 |
for (pkg_name, bug_name, section, urgency) \
|
| 487 |
in self.db.cursor().execute(
|
| 488 |
"""SELECT DISTINCT sp.name, st.bug_name,
|
| 489 |
sp.archive, st.urgency
|
| 490 |
FROM source_package_status AS st, source_packages AS sp
|
| 491 |
WHERE st.vulnerable AND st.urgency <> 'unimportant'
|
| 492 |
AND sp.rowid = st.package AND sp.release = 'sid'
|
| 493 |
AND sp.subrelease = ''
|
| 494 |
ORDER BY sp.name, st.bug_name"""):
|
| 495 |
if pkg_name == old_pkg_name:
|
| 496 |
pkg_name = ''
|
| 497 |
else:
|
| 498 |
old_pkg_name = pkg_name
|
| 499 |
if section <> 'main':
|
| 500 |
pkg_name = "%s (%s)" % (pkg_name, section)
|
| 501 |
else:
|
| 502 |
pkg_name = self.make_xref(url, pkg_name)
|
| 503 |
|
| 504 |
if urgency == 'unknown':
|
| 505 |
urgency = ''
|
| 506 |
elif urgency == 'high':
|
| 507 |
urgency = self.make_red(urgency)
|
| 508 |
|
| 509 |
yield pkg_name, self.make_xref(url, bug_name), urgency
|
| 510 |
|
| 511 |
|
| 512 |
return self.create_page(
|
| 513 |
url, 'Vulnerable source packages in the testing suite',
|
| 514 |
[P("""Note that the list below is based on source packages.
|
| 515 |
This means that packages are not listed here once a new,
|
| 516 |
fixed source version has been uploaded to the archive, even
|
| 517 |
if there are still some vulnerably binary packages present
|
| 518 |
in the archive."""),
|
| 519 |
make_table(gen(), caption=('Package', 'Bug', 'Urgency'))])
|
| 520 |
|
| 521 |
def page_status_dtsa_candidates(self, path, params, url):
|
| 522 |
def gen():
|
| 523 |
old_pkg_name = ''
|
| 524 |
for (pkg_name, bug_name, archive, urgency, stable_later) \
|
| 525 |
in self.db.cursor().execute(
|
| 526 |
"""SELECT package, bug, section, urgency,
|
| 527 |
(SELECT testing.version_id < stable.version_id
|
| 528 |
FROM source_packages AS testing, source_packages AS stable
|
| 529 |
WHERE testing.name = testing_status.package
|
| 530 |
AND testing.release = 'etch'
|
| 531 |
AND testing.subrelease = ''
|
| 532 |
AND testing.archive = testing_status.section
|
| 533 |
AND stable.name = testing_status.package
|
| 534 |
AND stable.release = 'sarge'
|
| 535 |
AND stable.subrelease = 'security'
|
| 536 |
AND stable.archive = testing_status.section)
|
| 537 |
FROM testing_status
|
| 538 |
WHERE (NOT unstable_vulnerable)
|
| 539 |
AND (NOT testing_security_fixed)"""):
|
| 540 |
if pkg_name == old_pkg_name:
|
| 541 |
pkg_name = ''
|
| 542 |
migration = ''
|
| 543 |
else:
|
| 544 |
old_pkg_name = pkg_name
|
| 545 |
migration = A(self.url_testing_status(url, pkg_name),
|
| 546 |
"check")
|
| 547 |
if archive <> 'main':
|
| 548 |
pkg_name = "%s (%s)" % (pkg_name, archive)
|
| 549 |
else:
|
| 550 |
pkg_name = self.make_source_package_ref(url, pkg_name)
|
| 551 |
|
| 552 |
if urgency == 'unknown':
|
| 553 |
urgency = ''
|
| 554 |
elif urgency == 'high':
|
| 555 |
urgency = self.make_red(urgency)
|
| 556 |
|
| 557 |
if stable_later:
|
| 558 |
notes = "(fixed in stable?)"
|
| 559 |
else:
|
| 560 |
notes = ''
|
| 561 |
|
| 562 |
yield (pkg_name, migration, self.make_xref(url, bug_name),
|
| 563 |
urgency, notes)
|
| 564 |
|
| 565 |
return self.create_page(
|
| 566 |
url, "Candidates for DTSAs",
|
| 567 |
[P("""The table below lists packages which are fixed
|
| 568 |
in unstable, but unfixed in testing. Use the testing migration
|
| 569 |
return web_supporttracker to find out why they have not entered
|
| 570 |
return web_supporttesting yet."""),
|
| 571 |
make_menu(url.scriptRelative,
|
| 572 |
("status/release/testing",
|
| 573 |
"List of vulnerable packages in testing")),
|
| 574 |
make_table(gen(),
|
| 575 |
caption=("Package", "Migration", "Bug", "Urgency"))])
|
| 576 |
|
| 577 |
def page_status_todo(self, path, params, url):
|
| 578 |
def gen():
|
| 579 |
for (bug, description) in self.db.getTODOs():
|
| 580 |
yield self.make_xref(url, bug), description
|
| 581 |
return self.create_page(
|
| 582 |
url, "Bugs with TODO items",
|
| 583 |
[make_table(gen(),
|
| 584 |
caption=("Bug", "Description"))])
|
| 585 |
|
| 586 |
def page_status_itp(self, path, params, url):
|
| 587 |
def gen():
|
| 588 |
old_pkg = ''
|
| 589 |
for pkg, bugs, debian_bugs in self.db.getITPs(self.db.cursor()):
|
| 590 |
if pkg == old_pkg:
|
| 591 |
pkg = ''
|
| 592 |
else:
|
| 593 |
old_pkg = pkg
|
| 594 |
yield (pkg, self.make_xref_list(url, bugs),
|
| 595 |
self.make_debian_bug_list(url, debian_bugs))
|
| 596 |
return self.create_page(
|
| 597 |
url, "ITPs with potential security issues",
|
| 598 |
[make_table(gen(), caption=("Package", "Issue", "Debian Bugs"),
|
| 599 |
replacement="No ITP bugs are currently known.")])
|
| 600 |
|
| 601 |
def page_data_unknown_packages(self, path, params, url):
|
| 602 |
def gen():
|
| 603 |
for name, bugs in self.db.getUnknownPackages(self.db.cursor()):
|
| 604 |
yield name, self.make_xref_list(url, bugs)
|
| 605 |
return self.create_page(
|
| 606 |
url, "Unknown packages",
|
| 607 |
[P("""Sometimes, a package referenced in a bug report
|
| 608 |
cannot be found in the database. This can be the result of a spelling
|
| 609 |
return web_supporterror, or a historic entry refers to a
|
| 610 |
return web_supportpackage which is no longer in the archive."""),
|
| 611 |
make_table(gen(), caption=("Package", "Bugs"),
|
| 612 |
replacement="No unknown packages are referenced in the database.")])
|
| 613 |
|
| 614 |
def page_data_missing_epochs(self, path, params, url):
|
| 615 |
def gen():
|
| 616 |
old_bug = ''
|
| 617 |
old_pkg = ''
|
| 618 |
for bug, pkg, ver1, ver2 in self.db.cursor().execute(
|
| 619 |
"""SELECT DISTINCT bug_name, n.package,
|
| 620 |
n.fixed_version, sp.version
|
| 621 |
FROM package_notes AS n, source_packages AS sp
|
| 622 |
WHERE n.package_kind = 'source'
|
| 623 |
AND n.fixed_version NOT LIKE '%:%'
|
| 624 |
AND n.fixed_version <> '0'
|
| 625 |
AND n.bug_origin = ''
|
| 626 |
AND sp.name = n.package
|
| 627 |
AND sp.version LIKE '%:%'
|
| 628 |
ORDER BY bug_name, package"""):
|
| 629 |
if bug == old_bug:
|
| 630 |
bug = ''
|
| 631 |
else:
|
| 632 |
old_bug = bug
|
| 633 |
old_pkg = ''
|
| 634 |
bug = self.make_xref(url, bug)
|
| 635 |
if pkg == old_pkg:
|
| 636 |
pkg = ''
|
| 637 |
else:
|
| 638 |
old_pkg = pkg
|
| 639 |
pkg = self.make_source_package_ref(url, pkg)
|
| 640 |
yield bug, pkg, ver1, ver2
|
| 641 |
|
| 642 |
return self.create_page(
|
| 643 |
url, "Missing epochs in package versions",
|
| 644 |
[make_table(gen(),
|
| 645 |
caption=("Bug", "Package", "Version 1", "Version 2"),
|
| 646 |
replacement="No source package version with missing epochs.")])
|
| 647 |
|
| 648 |
def page_data_releases(self, path, params, url):
|
| 649 |
def gen():
|
| 650 |
for (rel, subrel, archive, sources, archs) \
|
| 651 |
in self.db.availableReleases():
|
| 652 |
if sources:
|
| 653 |
sources = 'yes'
|
| 654 |
else:
|
| 655 |
sources = 'no'
|
| 656 |
yield rel, subrel, archive, sources, make_list(archs)
|
| 657 |
return self.create_page(
|
| 658 |
url, "Available releases",
|
| 659 |
[P("""The security issue database is checked against
|
| 660 |
the Debian releases listed in the table below."""),
|
| 661 |
make_table(gen(),
|
| 662 |
caption=("Release", "Subrelease", "Archive",
|
| 663 |
"Sources", "Architectures"))])
|
| 664 |
|
| 665 |
def page_data_funny_versions(self, path, params, url):
|
| 666 |
def gen():
|
| 667 |
for name, release, archive, version, source_version \
|
| 668 |
in self.db.getFunnyPackageVersions():
|
| 669 |
yield name, release, archive, source_version, version
|
| 670 |
|
| 671 |
return self.create_page(
|
| 672 |
url, "Version conflicts between source/binary packages",
|
| 673 |
[P("""The table below lists source packages
|
| 674 |
which have a binary package of the same name, but with a different
|
| 675 |
version. This means that extra care is necessary to determine
|
| 676 |
the version of a package which has been fixed. (Note that
|
| 677 |
the bug tracker prefers source versions to binary versions
|
| 678 |
in this case.)"""),
|
| 679 |
make_table(gen(),
|
| 680 |
caption=("Package",
|
| 681 |
"Release",
|
| 682 |
"Archive",
|
| 683 |
"Source Version",
|
| 684 |
"Binary Version")),
|
| 685 |
P("""Technically speaking, these version numbering is fine,
|
| 686 |
but it makes version-based bug tracking quite difficult for these packages."""),
|
| 687 |
P("""There are many binary packages which are built from source
|
| 688 |
packages with different version numbering schemes. However, as
|
| 689 |
long as none of the binary packages carries the same name as the
|
| 690 |
source package, most confusion is avoided or can be easily
|
| 691 |
explained.""")])
|
| 692 |
|
| 693 |
|
| 694 |
def create_page(self, url, title, body, search_in_page=False, status=200):
|
| 695 |
append = body.append
|
| 696 |
append(HR())
|
| 697 |
if not search_in_page:
|
| 698 |
append(self.make_search_button(url))
|
| 699 |
append(P(A(url.scriptRelative(""), "Home"),
|
| 700 |
" - ", A(url.absolute("http://secure-testing.debian.net/"),
|
| 701 |
"Testing Security Team"),
|
| 702 |
" - ", A(url.absolute("http://www.debian.org/security/"),
|
| 703 |
"Debian Security"),
|
| 704 |
" - ", A(url.absolute
|
| 705 |
("http://www.enyo.de/fw/impressum.html"),
|
| 706 |
"Imprint")))
|
| 707 |
if search_in_page:
|
| 708 |
on_load = "selectSearch()"
|
| 709 |
else:
|
| 710 |
on_load = None
|
| 711 |
return HTMLResult(self.add_title(title, body,
|
| 712 |
head_contents=self.head_contents,
|
| 713 |
body_attribs={'onload': on_load}),
|
| 714 |
doctype=self.html_dtd(),
|
| 715 |
status=status)
|
| 716 |
|
| 717 |
def make_search_button(self, url):
|
| 718 |
return FORM("Search for package or bug name: ",
|
| 719 |
INPUT(type='text', name='query',
|
| 720 |
onkeyup="onSearch(this.value)",
|
| 721 |
onmousemove="onSearch(this.value)"),
|
| 722 |
INPUT(type='submit', value='Go'),
|
| 723 |
method='get',
|
| 724 |
action=url.scriptRelative(''))
|
| 725 |
|
| 726 |
def url_cve(self, url, name):
|
| 727 |
return url.absolute("http://cve.mitre.org/cgi-bin/cvename.cgi",
|
| 728 |
name=name)
|
| 729 |
def url_dsa(self, url, dsa, re_dsa=re.compile(r'^DSA-(\d+)(?:-\d+)?$')):
|
| 730 |
match = re_dsa.match(dsa)
|
| 731 |
if match:
|
| 732 |
# We must determine the year because there is no generic URL.
|
| 733 |
(number,) = match.groups()
|
| 734 |
for (date,) in self.db.cursor().execute(
|
| 735 |
"SELECT release_date FROM bugs WHERE name = ?", (dsa,)):
|
| 736 |
(y, m, d) = date.split('-')
|
| 737 |
return url.absolute("http://www.debian.org/security/%d/dsa-%d"
|
| 738 |
% (int(y), int(number)))
|
| 739 |
return None
|
| 740 |
|
| 741 |
def url_debian_bug(self, url, debian):
|
| 742 |
return url.absolute("http://bugs.debian.org/cgi-bin/bugreport.cgi",
|
| 743 |
bug=str(debian))
|
| 744 |
def url_debian_bug_pkg(self, url, debian):
|
| 745 |
return url.absolute("http://bugs.debian.org/cgi-bin/pkgreport.cgi",
|
| 746 |
pkg=debian)
|
| 747 |
def url_pts(self, url, package):
|
| 748 |
return url.absolute("http://packages.qa.debian.org/common/index.html",
|
| 749 |
src=package)
|
| 750 |
def url_testing_status(self, url, package):
|
| 751 |
return url.absolute("http://bjorn.haxx.se/debian/testing.pl",
|
| 752 |
package=package)
|
| 753 |
def url_source_package(self, url, package, full=False):
|
| 754 |
if full:
|
| 755 |
return url.scriptRelativeFull("source-package/" + package)
|
| 756 |
else:
|
| 757 |
return url.scriptRelative("source-package/" + package)
|
| 758 |
def url_binary_package(self, url, package, full=False):
|
| 759 |
if full:
|
| 760 |
return url.scriptRelativeFull("binary-package/" + package)
|
| 761 |
else:
|
| 762 |
return url.scriptRelative("binary-package/" + package)
|
| 763 |
|
| 764 |
def make_xref(self, url, name):
|
| 765 |
return A(url.scriptRelative(name), name)
|
| 766 |
|
| 767 |
def make_xref_list(self, url, lst, separator=', '):
|
| 768 |
return make_list(map(lambda x: self.make_xref(url, x), lst), separator)
|
| 769 |
|
| 770 |
def make_debian_bug(self, url, debian):
|
| 771 |
return A(self.url_debian_bug(url, debian), str(debian))
|
| 772 |
def make_debian_bug_list(self, url, lst):
|
| 773 |
return make_list(map(lambda x: self.make_debian_bug(url, x), lst))
|
| 774 |
|
| 775 |
def make_cve_ref(self, url, cve, name=None):
|
| 776 |
if name is None:
|
| 777 |
name = cve
|
| 778 |
return A(self.url_cve(url, cve), name)
|
| 779 |
|
| 780 |
def make_dsa_ref(self, url, dsa, name=None):
|
| 781 |
if name is None:
|
| 782 |
name = dsa
|
| 783 |
u = self.url_dsa(url, dsa)
|
| 784 |
if u:
|
| 785 |
return A(u, name)
|
| 786 |
else:
|
| 787 |
return name
|
| 788 |
|
| 789 |
def make_pts_ref(self, url, pkg, name=None):
|
| 790 |
if name is None:
|
| 791 |
name = pkg
|
| 792 |
return A(self.url_pts(url, pkg), name)
|
| 793 |
|
| 794 |
def make_source_package_ref(self, url, pkg, title=None):
|
| 795 |
if title is None:
|
| 796 |
title = pkg
|
| 797 |
return A(self.url_source_package(url, pkg), title)
|
| 798 |
def make_binary_package_ref(self, url, pkg, title=None):
|
| 799 |
if title is None:
|
| 800 |
title = pkg
|
| 801 |
return A(self.url_binary_package(url, pkg), title)
|
| 802 |
def make_binary_packages_ref(self, url, lst):
|
| 803 |
assert type(lst) <> types.StringType
|
| 804 |
return make_list(map(lambda x: self.make_binary_package_ref(url, x),
|
| 805 |
lst))
|
| 806 |
|
| 807 |
def make_red(self, contents):
|
| 808 |
return SPAN(contents, _class="red")
|
| 809 |
|
| 810 |
def make_dangerous(self, contents):
|
| 811 |
return SPAN(contents, _class="dangerous")
|
| 812 |
|
| 813 |
def pre_dispatch(self):
|
| 814 |
self.db.refresh()
|
| 815 |
|
| 816 |
TrackerService(socket_name, db_name).run()
|
Parent Directory
| 
Revision Log