dbgen.py

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