dbgen.py

   1 #!/usr/bin/env python
   2
   3 from pysqlite2 import dbapi2 as db
   4 from cStringIO import StringIO
   5 import struct
   6 from M2Crypto import RSA
   7 import sha
   8
   9 MAGIC = 0x52474442
  10 VERSION = 19
  11
  12 def be32(output, val):
  13     output.write(struct.pack('>I', val))
  14
  15 class PTR(object):
  16     def __init__(self, output):
  17         self._output = output
  18         self._pos = output.tell()
  19         be32(output, 0xFFFFFFFF)
  20
  21     def set(self, val=None):
  22         if val is None:
  23             val = self._output.tell()
  24         self._offset = val
  25         pos = self._output.tell()
  26         self._output.seek(self._pos)
  27         be32(self._output, val)
  28         self._output.seek(pos)
  29
  30     def get(self):
  31         return self._offset
  32
  33 regdb = db.connect('regulatory.sqlite')
  34 cursor = regdb.cursor()
  35
  36 output = StringIO()
  37
  38 # struct regdb_file_header
  39 be32(output, MAGIC)
  40 be32(output, VERSION)
  41 reg_country_ptr = PTR(output)
  42 # add number of countries
  43 cursor.execute('SELECT COUNT(*) FROM reg_country;')
  44 be32(output, cursor.fetchone()[0])
  45 siglen = PTR(output)
  46
  47 power_rules = {}
  48 # just to make sure db scheme isn't bad
  49 cursor.execute('''SELECT power_rule_id,
  50                          environment_cap,
  51                          max_antenna_gain_mbi,
  52                          max_ir_ptmp_mbm,
  53                          max_ir_ptp_mbm,
  54                          max_eirp_pmtp_mbm,
  55                          max_eirp_ptp_mbm FROM power_rule;''')
  56 for pr in cursor:
  57     power_rule_id = pr[0]
  58     power_rules[power_rule_id] = output.tell()
  59     # struct regdb_file_power_rule
  60     output.write(struct.pack('>cxxxIIIII', str(pr[1]), *pr[2:]))
  61
  62 freq_ranges = {}
  63 # just to make sure db scheme isn't bad
  64 cursor.execute('''SELECT freq_range_id,
  65                          start_freq_khz,
  66                          end_freq_khz,
  67                          max_bandwidth_khz,
  68                          modulation_cap,
  69                          misc_restrictions FROM freq_range;''')
  70 for fr in cursor:
  71     freq_range_id = fr[0]
  72     freq_ranges[freq_range_id] = output.tell()
  73     # struct regdb_file_freq_range
  74     output.write(struct.pack('>IIIII', *fr[1:]))
  75
  76
  77 reg_rules = {}
  78 # just to make sure db scheme isn't bad
  79 cursor.execute('SELECT reg_rule_id, freq_range_id, power_rule_id FROM reg_rule;')
  80 for reg_rule in cursor:
  81     reg_rule_id, freq_range_id, power_rule_id = reg_rule
  82     reg_rules[reg_rule_id] = output.tell()
  83     # struct regdb_file_reg_rule
  84     output.write(struct.pack('>II', freq_ranges[freq_range_id], power_rules[power_rule_id]))
  85
  86
  87 collection_data = {}
  88 # just to make sure db scheme isn't bad
  89 cursor.execute('SELECT entry_id, reg_collection_id, reg_rule_id FROM reg_rules_collection;')
  90 for coll in cursor:
  91     entry_id, reg_collection_id, reg_rule_id = coll
  92     l = collection_data.get(reg_collection_id, [])
  93     l.append(reg_rule_id)
  94     collection_data[reg_collection_id] = l
  95
  96 reg_rules_collections = {}
  97
  98 for rc, l in collection_data.iteritems():
  99     reg_rules_collections[rc] = output.tell()
 100     # struct regdb_file_reg_rules_collection
 101     be32(output, len(l))
 102     for regrule in l:
 103         be32(output, reg_rules[regrule])
 104
 105 # update country pointer now!
 106 reg_country_ptr.set()
 107
 108 # just to make sure db scheme isn't bad
 109 cursor.execute('SELECT reg_country_id, alpha2, reg_collection_id FROM reg_country;')
 110 for country in cursor:
 111     reg_country_id, alpha2, reg_collection_id = country
 112     # struct regdb_file_reg_country
 113     output.write(struct.pack('>ccxxI', str(alpha2[0]), str(alpha2[1]), reg_rules_collections[reg_collection_id]))
 114
 115 # determine signature length
 116 key = RSA.load_key('key.priv.pem')
 117 hash = sha.new()
 118 hash.update(output.getvalue())
 119 sig = key.sign(hash.digest())
 120 # write it to file
 121 siglen.set(len(sig))
 122 # sign again
 123 hash = sha.new()
 124 hash.update(output.getvalue())
 125 sig = key.sign(hash.digest())
 126
 127 output.write(sig)
 128
 129 outfile = open('regulatory.bin', 'w')
 130 outfile.write(output.getvalue())