root/trunk/libffado/support/mixer-qt4/ffado/registration.py

Revision 2690, 8.1 kB (checked in by jwoithe, 7 years ago)

ffado-mixer: deal with python 2/3 differences when converting registration email addresses to ascii. Code for python3 suggested by Xavier Forestier.

  • Property svn:mergeinfo set to
Line 
1 #
2 # Copyright (C) 2008-2009 by Pieter Palmers
3 #               2009      by Arnold Krille
4 #
5 # This file is part of FFADO
6 # FFADO = Free Firewire (pro-)audio drivers for linux
7 #
8 # FFADO is based upon FreeBoB.
9 #
10 # This program is free software: you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation, either version 3 of the License, or
13 # (at your option) any later version.
14 #
15 # This program is distributed in the hope that it will be useful,
16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 # GNU General Public License for more details.
19 #
20 # You should have received a copy of the GNU General Public License
21 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 #
23
24 import urllib
25 import os
26
27 # Python3 renamed ConfigParser to configparser.  Deal with this in a way
28 # which maintains compatibility with python2.
29 try:
30     from configparser import SafeConfigParser
31 except:
32     from ConfigParser import SafeConfigParser
33
34 # The urlopen()/urlencode() functions from urllib in python2 are in
35 # urllib.request and urllib.parse respectively under python2.
36 try:
37     import urllib.request, urllib.parse
38     url_newapi = 1
39 except ImportError:
40     import urllib
41     url_newapi = 0
42
43 from sys import version_info
44
45 from ffado.config import REGISTER_URL, INI_FILE_PATH, FFADO_CONFIG_DIR
46 from PyQt4.QtGui import QMessageBox
47 from PyQt4.QtCore import QByteArray
48
49 from ffado.regdialog import *
50
51 import logging
52 log = logging.getLogger('registration')
53
54 class ffado_registration:
55     def __init__(self, ffado_version,
56                        guid,
57                        vendor_id,
58                        model_id,
59                        vendor_string,
60                        model_string):
61         # only use the section before the SVN mark
62         # we don't need to keep track of all SVN version changes
63         self.ffado_version = ffado_version.split('-')[0]
64         self.guid = guid
65         self.vendor_id = vendor_id
66         self.model_id = model_id
67         self.vendor_string = vendor_string
68         self.model_string = model_string
69
70         #check if config file path exists, if not, create it
71         config_path = os.path.expanduser(FFADO_CONFIG_DIR)
72         if not os.path.exists(config_path):
73             os.makedirs(config_path)
74
75         # parse the ini file
76         self.config_filename = os.path.expanduser(INI_FILE_PATH)
77         self.parser = SafeConfigParser()
78         self.parser.read(self.config_filename)
79         self.section_name = "%s:%X" % (self.ffado_version, self.guid)
80         self.email = "(optional)"
81         if self.parser.has_section("history") \
82            and self.parser.has_option("history", "email"):
83             self.email = self.parser.get("history", "email")
84
85     def register_ffado_usage(self):
86         post_vals = {}
87         post_vals['guid'] = self.guid
88         post_vals['vendor_id'] = self.vendor_id
89         post_vals['model_id'] = self.model_id
90         post_vals['vendor_string'] = self.vendor_string
91         post_vals['model_string'] = self.model_string
92         post_vals['ffado_version'] = self.ffado_version
93         post_vals['email'] = self.email
94
95         try:
96             if url_newapi == 1:
97                 response = urllib.request.urlopen(REGISTER_URL,
98                                                   urllib.parse.urlencode(post_vals).encode('ascii'))
99             else:
100                 response = urllib.urlopen(REGISTER_URL,
101                                           urllib.urlencode(post_vals))
102         except:
103             log.error("failed, network error")
104             return (-1, "Network Error")
105    
106         lines = response.readlines()
107        
108         ok = False
109         errline = "Bad response from server"
110         for i in range(len(lines)):
111             if lines[i][0:10] == b"RESULT: OK":
112                 ok = True
113             elif lines[i][0:12] == b"RESULT: FAIL":
114                 ok = False
115                 if len(lines)>i+1:
116                     errline = lines[i+1]
117         if not ok:
118             log.info("registration failed %s" % errline)
119             return (-2, errline)
120         else:
121             return (0, "")
122    
123     def check_for(self, what):
124         if not self.parser.has_section(self.section_name):
125             return False
126         if not self.parser.has_option(self.section_name, what):
127             return False
128         return self.parser.getboolean(self.section_name, what)
129    
130     def check_if_already_registered(self):
131         return self.check_for("registered")
132    
133     def check_for_ignore(self):
134         return self.check_for("ignore")
135    
136     def mark(self, what, value):
137         if not self.parser.has_section(self.section_name):
138             self.parser.add_section(self.section_name)
139         self.parser.set(self.section_name, what, str(value))
140    
141     def mark_version_registered(self):
142         self.mark("registered", True)
143    
144     def mark_ignore_version(self):
145         self.mark("ignore", True)
146
147     def remember_email(self, email):
148         if not self.parser.has_section("history"):
149             self.parser.add_section("history")
150         self.parser.set("history", "email", str(email))
151
152     def check_for_registration(self):
153
154         if self.check_for_ignore():
155             log.debug("user requested to ignore registration")
156         else:
157             if self.check_if_already_registered():
158                 log.debug("version/GUID combo already registered")
159             else:
160                 log.debug("show dialog...")
161
162                 dlg = ffadoRegDialog(self.vendor_string, "0x%X" % self.vendor_id,
163                                      self.model_string, "0x%X" % self.model_id,
164                                      "0x%016X" % self.guid, self.ffado_version,
165                                      self.email)
166                 dlg.exec_()
167
168                 if dlg.choice == "neversend":
169                     self.mark_ignore_version()
170                 elif dlg.choice == "send":
171                     if version_info[0] < 3:
172                         # Python 2.x
173                         asciiData = dlg.getEmail().toAscii()
174                         self.email = asciiData.data()
175                     else:
176                         # Python 3 and above
177                         self.email = ascii(dlg.getEmail())
178                     self.remember_email(self.email)
179
180                     retval = self.register_ffado_usage()
181                     msg = QMessageBox()
182                     if retval[0] == 0:
183                         log.debug("registration successful")
184                         devinfomsg = "<p>Device: %s %s<br> Vendor/Model Id: %X/%X<br>Device GUID: %016X<br>FFADO Version: %s<br>E-Mail: %s</p>" % \
185                             (self.vendor_string, self.model_string, self.vendor_id, self.model_id, self.guid, self.ffado_version, self.email)
186                         tmp = msg.question( msg, "Registration Successful",
187                                             "<qt><b>Thank you.</b>" +
188                                             "<p>The registration of the following information was successful:</p>" +
189                                             devinfomsg +
190                                             "</p>For this device you won't be asked to register again until you upgrade to a new version of FFADO.</p>",
191                                             QMessageBox.Ok )
192                         self.mark_version_registered()
193                     else:
194                         log.error("error: " + retval[1])
195                         tmp = msg.question( msg, "Registration Failed",
196                                             "<qt><b>The registration at ffado.org failed.</b>" +
197                                             "<p>Error message:</p><p>" + retval[1] +
198                                             "</p><p>Try again next time?</p></qt>",
199                                             QMessageBox.Yes, QMessageBox.No )
200                         if tmp == 4:
201                             self.mark_ignore_version()
202                 elif dlg.choice == "nosend":
203                     pass
204         # write the updated config
205         f = open(self.config_filename, "w+")
206         self.parser.write(f)
207         f.close()
208
209 # vim: et
Note: See TracBrowser for help on using the browser.